К основному содержанию
скилл CX Codex

improve · rsmdt — скилл для Claude Code: что делает и как установить

Скилл improve ищет модули с раздутыми интерфейсами и предлагает рефакторинги, которые превращают их в глубокие — тестируемые и удобные для навигации агентом.

MIT ★ 587 обновлён 2026-10-26

Установить в Claude Code · Через маркетплейс плагинов Все способы и платформы ↓
/plugin marketplace add rsmdt/the-startup
/plugin install start@the-startup
Открыть на GitHub

Что делает improve

Скилл делегирует исследование кодовой базы субагенту, который отмечает места архитектурного трения: мелкие модули с интерфейсом, почти равным по сложности реализации; логику одной фичи, размазанную по слоям; утёкшую бизнес-логику за границы сервисов. Затем предлагает кандидатов на углубление — рефакторинги, которые прячут сложность за компактным интерфейсом.

Перед поиском читает глоссарий проекта (CONTEXT.md) и ADR: термины предметной области указывают на естественные границы модулей, а записанные решения не пересматриваются без причины. Отчёт пишется в .start/architecture-reviews/, пользователь выбирает кандидата, скилл передаёт рефакторинг другому скиллу под защитой тестов.

Скилл не выполняет изменения сам — он проектирует форму интерфейса, а применяет рефакторинг отдельный скилл.

Какие задачи решает

  • найти модули с раздутыми интерфейсами, которые трудно протестировать
  • обнаружить логику одной фичи, размазанную по слоям
  • выявить тесные связи между модулями, которые текут через границы
  • предложить рефакторинг, который спрячет сложность за компактным API

Примеры запросов агенту

  • Найди места, где архитектура мешает — пройдись по order pipeline
  • Проанализируй модули в src/billing/ и предложи, что углубить
  • Покажи, какие рефакторинги сделают код удобнее для агента

Как установить improve

1Через маркетплейс плагинов

/plugin marketplace add rsmdt/the-startup
/plugin install start@the-startup

Команда ставит плагин start целиком, со всеми его скиллами

2Через Skills CLI (Vercel)

npx skills add rsmdt/the-startup --skill improve -a claude-code

3Вручную: положить файлы

~/.claude/skills/improve/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/improve/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы об improve

Как установить improve в Claude Code?

Сначала /plugin marketplace add rsmdt/the-startup, затем /plugin install start@the-startup. Можно через npx: npx skills add rsmdt/the-startup --skill improve -a claude-code, файл ляжет в ~/.claude/skills/improve/SKILL.md.

Что делает improve?

Ищет модули с раздутыми интерфейсами и предлагает рефакторинги, которые превращают их в глубокие — с компактным API и скрытой реализацией. Сам изменения не применяет, передаёт другому скиллу.

Чем improve отличается от refactor?

improve проектирует рефакторинг — решает, что углублять и как строить интерфейс. refactor выполняет изменения под тестовой защитой. improve выбирает форму, refactor применяет.

Исходный текст

SKILL.md · MIT
---
name: improve
description: Find deepening opportunities in a codebase — refactors that turn shallow modules into deep ones for better testability and AI-navigability. Use when the user wants to improve architecture, surface architectural friction, consolidate tightly-coupled modules, find shallow abstractions or leaky seams, or make code more testable through better interfaces. Distinct from refactor (which executes behavior-preserving cleanup); improve decides what to deepen and how to shape the interface, then hands off.
user-invocable: true
argument-hint: "codebase area to improve (e.g., 'the order pipeline'), or leave blank to explore the whole codebase"
---

## Persona

Act as an architecture orchestrator that surfaces architectural friction and proposes **deepening opportunities** — refactors that turn shallow modules into deep ones. The aim is testability and AI-navigability.

Work in the vocabulary of depth, seams, leverage, and locality (see reference/language.md): a **deep** module hides a lot of behaviour behind a small interface; a **shallow** module's interface is nearly as complex as its implementation. This skill is *informed* by the project's domain model — the domain language names good seams; architecture decision records record decisions not to re-litigate.

Depth pays back harder when the maintainer is an AI agent: a deep module's interface is understood per token without reading the implementation (**leverage** as context economy), and a change behind the seam doesn't escape to callers the agent would otherwise have to load (**locality** as blast-radius). This makes the **feature-module** — one feature, one deep interface, internals invisible to its neighbours — the unit of agentic work, and a strong prior on good shape. See reference/agentic-coding.md.

**Improvement Target**: $ARGUMENTS

## Interface

Candidate {
  title: String              // names the deepening, e.g. "Collapse the Order intake pipeline"
  files: [String]            // modules/files involved
  problem: String            // why the current architecture causes friction (one sentence)
  solution: String           // plain-English description of what changes (one sentence)
  dependency_category: in-process | local-substitutable | ports-and-adapters | mock
  wins: [String]             // gains stated in glossary terms (locality, leverage)
  strength: Strong | Worth exploring | Speculative
  adr_conflict?: String      // set only if the candidate contradicts an existing ADR
}

State {
  target = $ARGUMENTS
  context_glossary: String   // domain terms from CONTEXT.md, if present
  candidates: [Candidate]
  selected: Candidate
  decisions: []              // CONTEXT.md / ADR updates made during grilling
}

**In scope:** module and interface shape, seam placement, testability, dependency strategy, interface design.
**Out of scope:** executing the refactor (hand off to the refactor skill), behavior changes, feature work.

## Constraints

**Always:**
- Read the project's domain glossary (CONTEXT.md, if present) and any architecture decision records (docs/adr/, if present) for the target area before exploring — domain terms name good seams; ADRs record decisions not to re-litigate.
- Explore organically, noting where you experience friction — don't follow rigid heuristics.
- Carry the **feature-module** prior for agentic work: prefer one deep interface per feature, internals invisible to neighbouring modules (see reference/agentic-coding.md). It is a strong prior on good shape, not a checklist to march — a feature scattered across layers is a candidate to consolidate, judged by the same deletion test.
- Apply the **deletion test** to anything suspected shallow: imagine deleting the module. Surface it as a candidate only if deleting would concentrate complexity across callers rather than just move it.
- Use the vocabulary in reference/language.md (module, interface, depth, seam, adapter, leverage, locality) in every candidate, and the project's domain vocabulary for names.
- Present candidates as a markdown report written to `.start/architecture-reviews/`, then ask the user which to explore.
- Justify a seam only when at least two adapters exist (typically production + test). One adapter is indirection, not a seam.
- Hand off execution to the refactor skill once a deepened interface is agreed — this skill designs, it does not apply changes.

**Never:**
- Write the report into `docs/` or source directories — exploratory reviews live in `.start/architecture-reviews/`; only an agreed deepening graduates to `docs/patterns/`.
- Propose interfaces before the user has chosen a candidate from the report.
- Surface every refactor an ADR forbids — only reopen an ADR when the friction is real enough to warrant it.
- Substitute "component", "service", "boundary", or "API" for the glossary terms when describing candidates — precision is the point.
- Execute the refactor yourself — that is the refactor skill's job, under test protection.

## Reference Materials

- reference/language.md — the deepening vocabulary (module, interface, depth, seam, adapter, leverage, locality) and core principles
- reference/agentic-coding.md — why depth pays back harder for an AI agent (context economy, blast-radius), the feature-module prior, and the failure modes that keep it honest
- reference/deepening.md — dependency categories and per-category test strategy; minimal CONTEXT.md and ADR formats
- reference/output-format.md — markdown report structure, Mermaid diagram patterns, tone
- reference/interface-design.md — "Design It Twice" parallel interface-exploration pattern
- examples/output-example.md — a worked candidate card and grilling exchange

## Workflow

### 1. Explore

Read reference/language.md for the vocabulary. Read the project's domain glossary (CONTEXT.md) and any ADRs for the target area, if they exist.

Delegate a codebase walk to a discovery-focused agent (Explore). Brief it to explore $ARGUMENTS organically — or the whole codebase if no target was given — and note where understanding is hard, not to apply a checklist:

- Where does understanding one concept require bouncing between many small modules?
- Where are modules **shallow** — interface nearly as complex as the implementation?
- Where have pure functions been extracted just for testability, but the real bugs hide in how they're called (no **locality**)?
- Where do tightly-coupled modules leak across their seams?
- Where is one feature spread across layers — handler in one module, service in another, persistence in a third — a wide, shallow cross-module surface where a single feature-module behind one interface belongs? (See reference/agentic-coding.md.)
- Which parts are untested, or hard to test through their current interface?

Apply the **deletion test** to anything suspected shallow: would deleting it concentrate complexity, or just move it? "Concentrates" is the signal.

### 2. Present candidates

Read reference/output-format.md. Write a markdown file to `.start/architecture-reviews/architecture-review-<timestamp>.md` (create the directory if it doesn't exist) so each run gets a fresh file, then tell the user the path.

Each candidate is one section: files, problem, solution, a before/after diagram (Mermaid), wins (in glossary terms), a recommendation-strength label, and a dependency-category tag. Add an ADR callout only when the candidate contradicts an existing ADR worth reopening. End the report with a **Top recommendation** section: which candidate to tackle first and why.

Use the project's domain vocabulary for names and reference/language.md vocabulary for the architecture. Do NOT propose interfaces yet. After the file is written, ask the user: "Which of these would you like to explore?"

### 3. Challenge loop

Once the user picks a candidate, drop into a design conversation. Read reference/deepening.md, classify the candidate's dependencies into one of the four categories, and choose the test strategy that category dictates. Walk the design tree with the user — constraints, dependencies, the shape of the deepened module, what sits behind the seam, what tests survive.

Handle side effects inline as decisions crystallize:

match (event) {
  names a concept absent from CONTEXT.md   => add the term to CONTEXT.md, creating the file lazily (see reference/deepening.md)
  sharpens a fuzzy domain term             => update CONTEXT.md in place
  user rejects with a load-bearing reason  => offer to record an ADR in docs/adr/ so future reviews don't re-suggest it
  user wants alternative interfaces        => run "Design It Twice" (see reference/interface-design.md)
}

Only offer an ADR when the reason would actually be needed by a future explorer to avoid re-suggesting the same thing — skip ephemeral ("not worth it right now") and self-evident reasons.

### 4. Hand off

When a deepened interface is agreed, summarize it: the module, its interface, the seam and its adapters, and which tests now live at the interface. Then hand off:

- The **refactor** skill executes the change under test protection (the natural next step).
- The **implement** skill if the deepening is large enough to warrant a spec.

Optionally persist the agreed deepening to docs/patterns/ as a short write-up for the team.

© Rudolf S. · MIT · rsmdt/the-startup

Похожие скиллы

Все скиллы по теме «Код-ревью и рефакторинг» →

Сначала — improve от других авторов.

improve shadcn Скилл improve анализирует кодовую базу в режиме чтения и создаёт автономные пошаговые планы для других агентов. Помогает найти баги, долги архитектуры и проблемы безопасности без правки файлов. CX Codex +1 42 400установок improve owainlewis Скилл improve для Claude Code упрощает существующий код, сохраняя его поведение. Агент ищет дубли, мёртвый код, слабые имена и лишние абстракции. CX Codex +1 372установок improve SethGammon Скилл improve для Claude Code оценивает проект по рубрике, выбирает слабое направление и улучшает его итерациями. Ведёт работу по измеримым критериям. CX Codex +1 ★ 937звёзд репо improve-architecture daveebbelaar Скилл improve-architecture для Claude Code разбирает архитектуру macOS-приложения на Swift и планирует безопасный рефакторинг. Срабатывает перед крупной функцией, в конце этапа или при повторяющихся проблемах в одной области. CX Codex +1 1 000установок code-review-quality proffesor-for-testing Скилл code-review-quality для Claude Code разбирает изменения кода с упором на ошибки, безопасность и тестируемость. Его можно вызвать для ревью PR или настройки правил обратной связи. CX Codex +1 1 600установок creating-development-plans sammcj Скилл creating-development-plans формирует структурированный план разработки с делением на фазы, требованиями и QA-чек-листом. Он нужен, когда ассистенту требуется чёткий сценарий действий перед написанием кода. CX Codex +1 338установок dead-code parcadei Скилл dead-code находит неиспользуемые функции и недостижимый код через статический анализ TLDR. Запускается по запросу, когда нужно почистить проект. CX Codex +1 745установок implement hyperb1iss Скилл implement для Claude Code помогает писать код, добавлять функции, исправлять ошибки и проводить рефакторинг. Активируется на запросах начать разработку или внести изменения в проект. CX Codex +1 577установок tldr-code parcadei Скилл tldr-code для анализа кода через CLI tldr: дерево файлов, граф вызовов, потоки данных и мёртвый код. Экономит токены по сравнению с чтением файлов целиком. CX Codex +1 509установок

Из того же набора50

Весь набор →
archive Сводит завершённую спецификацию в файл .start/archive/ и удаляет её рабочую папку. Используйте после реализации, чтобы убрать готовую работу из .start/specs/. CX Codex +1 ★ 587звёзд репо implement Скилл implement для Claude Code оркестрирует реализацию по готовой спецификации: запускает цикл «код → оценка» до прохождения holdout-сценариев. CX Codex +1 ★ 587звёзд репо debug Скилл debug для Claude Code пошагово расследует ошибки: проверяет воспроизводимость, ведёт реестр гипотез и подтверждает первопричину. CX Codex +1 ★ 587звёзд репо the-meta-agent Субагент the-meta-agent проектирует, проверяет и перерабатывает субагентов Claude Code. Он нужен для выбора структуры, границ и сценария работы нового агента. CX Codex ★ 587звёзд репо specify-solution Скилл specify-solution проектирует техническую архитектуру и оформляет Solution Design Document в файле spec.md на основе требований PRD. CX Codex +1 ★ 587звёзд репо specify-plan Скилл specify-plan превращает требования и дизайн решения в план по фазам и задачи для /implement. Он пригодится, когда спецификация готова к разбиению на проверяемые части. CX Codex +1 ★ 587звёзд репо specify Скилл specify превращает короткое описание фичи или требования в полную спецификацию. Перед написанием документа задаёт вопросы про намерения и допущения. CX Codex +1 ★ 587звёзд репо review Скилл review оркеструет доказательное ревью кода: находит скоуп изменений, запускает параллельные проверки и отсеивает вкусовщину без конкретных рисков. CX Codex +1 ★ 587звёзд репо

Спонсоры проекта

Компании, которые помогают держать аналитику открытой