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

specify-plan — скилл для Claude Code: планирование и установка

Скилл specify-plan превращает требования и дизайн решения в план по фазам и задачи для /implement. Он пригодится, когда спецификация готова к разбиению на проверяемые части.

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

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

Что делает specify-plan

Скилл читает разделы Requirements и Solution в spec.md, инструкции проекта и кодовую базу. Затем формирует раздел Plan с целевым состоянием и фазами, а для трекера — задачи фаз, вертикальных слайсов и отдельных сценариев приёмки. Слайс описывает функции, поведение в синтаксисе EARS и проверки качества; сценарии предназначены для отдельной оценки.

До создания задач скилл показывает слайсы и сценарии пользователю на утверждение. Критерии требований должны сопоставляться со слайсами, а критерии поведения — с их описаниями; в каждом слайсе нужен сценарий уровня P0. Зависимости задаются через task.js --depends-on, а /implement использует их для порядка и параллельного запуска независимых слайсов. Поэтому независимыми можно оставить только слайсы, меняющие разные компоненты решения.

Для работы нужны разделы Requirements и Solution, инструкции проекта и доступ к его кодовой базе. Трекер запускается командой node ${CLAUDE_PLUGIN_ROOT}/scripts/task.js; объёмные описания передаются через временные файлы и --body-file. Скилл также сохраняет в spec.md значения threshold и max_iterations, которые читает /implement.

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

  • разбить требования на вертикальные слайсы по зависимостям
  • сгруппировать работу в фазы с проверяемым результатом
  • связать критерии требований и EARS-поведение с задачами
  • подготовить отдельные сценарии приёмки для оценки слайсов

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

  • Составь план реализации для спецификации 002 по разделам Requirements и Solution.
  • Разбей требования этой спецификации на фазы и вертикальные слайсы, затем покажи сценарии приёмки для утверждения.
  • Проверь, что критерии требований и EARS-поведение сопоставлены со слайсами, а зависимости заданы для task.js.

Как установить specify-plan

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

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

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

2Через Skills CLI (Vercel)

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

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

~/.claude/skills/specify-plan/SKILL.md

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

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

Вопросы о specify-plan

Как установить specify-plan в Claude Code?

В Claude Code добавьте маркетплейс командой /plugin marketplace add rsmdt/the-startup, затем установите плагин командой /plugin install start@the-startup.

Что делает specify-plan?

Он готовит раздел Plan в spec.md и задачи для /implement: фазы, вертикальные слайсы и отдельные сценарии приёмки. Перед созданием задач слайсы и сценарии нужно утвердить.

Как specify-plan разделяет задачи реализации и сценарии приёмки?

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

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

SKILL.md · MIT
---
name: specify-plan
description: Author the implementation plan — the Plan part of spec.md (target state + phases) plus the implementation TASKS in the spec's tracker that /implement runs. Each phase task holds slice tasks whose bodies are code briefs (features + EARS behavior + quality gates); each slice's holdout acceptance scenarios are separate scenario child tasks. Use after requirements and solution.
user-invocable: false
argument-hint: "spec ID to plan (e.g., 002)"
---

## Persona

Act as an implementation-plan specialist. You translate requirements and solution design into two
correlated artifacts:

1. the **Plan part** of `spec.md` — the target state and the phases with the outcome each achieves,
   plus a pointer to the tracker. It is read for orientation, never parsed for work.
2. the implementation **tasks** in the spec's tracker (`task.js`) — the operational unit `/implement`
   runs. Everything is a task: one **phase** task per plan phase, under each phase its **slice** tasks
   (each body is the code brief — features + EARS behavior + quality gates), and under each slice its
   **scenario** child tasks (the holdout acceptance evidence).

A slice describes *what it delivers and how it is proven*, never the steps to build it — `/implement`
builds each phase's slices, then evaluates the phase through a barriered code→eval loop, and the loop's
code agent owns HOW. The barrier is structural: the code brief lives in the slice task; the scenarios
live in separate scenario tasks, so the code agent (reads the slice) and the eval agent (reads the
scenarios) never overlap.

**Spec Target**: $ARGUMENTS

## Constraints

**Always:**
- Read the Requirements and Solution parts of `spec.md` before planning. If either is missing or not approved, tell the user and proceed with what's available. Read the project instructions file and codebase to ground the plan in real conventions, endpoints, data shapes, and test setup.
- Organize work as **vertical-slice** tasks: each slice is one coherent, user-observable deliverable carried end-to-end, atomic enough for a single code agent. Order slices by dependency; a later slice extends an earlier one. Never make a layer-only slice ("data-models slice"). End-to-end means through every interface the spec defines: when it has a UI and an API, each slice delivers its features in both, and an API consumer is a slice's user only when the spec has no UI.
- Group slices into **phases**: each phase is an outcome a user can see working. `/implement` builds all of a phase's slices, then evaluates the phase once; the next phase starts only after that evaluation. Make phases as large as they can be while each still ends in something working: a small spec — one service, a handful of features — is one phase; a larger spec gets the fewest phases that each deliver a working outcome. Keep each slice vertical and small enough to evaluate on its own.
- Declare each slice's dependencies accurately via `task.js --depends-on` (tracker ids) — `/implement` topo-sorts by them and runs independent slices concurrently, in the same working tree. It is the whole parallelization contract. Decide per slice whether it can run in parallel or depends on another: leave two slices independent only when they change different components of the Solution; slices that extend the same component or screen depend on each other in order.
- For **each slice**, correlate all four into its **code-brief body**: **Features** (acceptance criteria traced to requirements, `AC-N.M`), **Behavior** (EARS statements drawn from the solution design — see reference/ears.md), **Quality Gates** (checkable conditions). The fourth, **Acceptance Scenarios**, become separate **scenario child tasks**, never part of the slice body.
- Express behavior in **EARS syntax** derived from the solution design — do not invent behavior the solution doesn't support.
- Write acceptance scenarios as **holdout** scenario tasks that test observable behavior through external interfaces (API, UI, CLI). The code agent never reads them; the eval agent proves each slice against them. Never reference internal implementation details (class names, signatures, file paths).
- Present the slices (briefs + scenarios) to the user for approval before creating their tasks. The user must approve — they are what `/implement` is held to. A plan of one or two phases gets one approval for everything; a larger plan gets one per phase.
- Collect the `[ASSUMPTION An]` citations from the Requirements and Solution parts; any slice depending on a Standing assumption must cite it in its brief — the plan inherits the ledger visibly.
- Ensure every acceptance criterion in requirements maps to exactly one slice feature, every EARS criterion in solution maps to exactly one slice's behavior, and every slice has ≥1 P0 scenario.
- Keep `threshold` (default 0.90) and `max_iterations` (default 3) in the `spec.md` frontmatter — `/implement` reads them.

**Never:**
- Turn a slice into a prescription — no task-by-task instructions, file edits, code, or execution-group assignments. Dependencies (not hand-assigned groups) decide order. `/implement` owns HOW.
- Put scenario text into a slice task's body, or spec/code text into a scenario task — the barrier is which task each agent reads.
- Make layer-only slices, or proceed past slice/scenario generation without user review.
- Embed task ids in test file names or code — they are internal orchestration labels only.

## Reference Materials

- [EARS Guide](reference/ears.md) — EARS syntax for expressing behavior from the solution design
- [Scenario Guide](reference/scenario-guide.md) — Writing holdout acceptance scenarios grounded in the codebase
- [Markdown Blocks](reference/markdown-blocks.md) — Block vocabulary and document-quality discipline for spec.md
- [Validation](reference/validation.md) — Coverage and quality checks
- [Output Format](reference/output-format.md) — Phase review and status report shapes

**Templates:**
- [Spec Template](../specify-meta/template.md) — the `## Plan` part of `spec.md` (target state + phases + tracker link)
- [Scenario Template](templates/scenario.md) — body of each scenario child task

> Note: run the tracker CLI as `node ${CLAUDE_PLUGIN_ROOT}/scripts/task.js`. Slice bodies and scenario bodies are substantial markdown — write each to a temp file and pass it with `--body-file`.

## Workflow

### 1. Initialize

Read the Requirements and Solution parts of `spec.md`. Read the project instructions file and explore
the codebase for existing patterns, test structure, endpoints, and data shapes.

Identify the **slices** and **phases**: group the acceptance criteria into vertical-slice deliverables
sized to the spec, ordered by dependency, and group the slices into phases that each end in an outcome a
user can see working. This is the plan's backbone.

### 2. Write the Plan Part

Write the `## Plan` part of `spec.md`: a **Target state** paragraph (what the system does when every
phase is delivered, grounded in real components — no step list) and the **Phases** table (each phase's
outcome; its slice ids are filled in as the tasks are created). Set `gates.plan` to `draft` and record the `gate` event (`node ${CLAUDE_PLUGIN_ROOT}/scripts/spec.js {specId} --event`). Present the
Target state and the phase and slice breakdown. For a plan of three or more phases, ask the user to
*Approve slicing*, *Adjust*, or *Re-slice*. For one or two phases, do not ask yet: the breakdown is
approved with the slices in step 3.

### 3. Build Each Phase (as tasks)

For each phase, in order (read reference/ears.md and reference/scenario-guide.md first):

1. For each of the phase's slices, **assemble the code brief** — a markdown doc with: **Features** (the
   `AC-N.M` this slice delivers, traced to requirements); **Behavior — EARS** (EARS statements derived
   from the Solution part; every EARS criterion lands in exactly one slice); **Quality Gates** (the NFR-N
   gates this slice realizes, with their ids, and the test levels the plan settled). Cite any Standing assumption it
   depends on.
2. Write its **scenarios** — cover BOTH acceptance surfaces so nothing is left untested: every
   **Feature** (AC) needs ≥1 `business` scenario and every **EARS behavior** (incl. edge/error states)
   needs ≥1 `technical` scenario. Write each body from templates/scenario.md and tag its **Surface**
   (`business` | `technical`) — the eval agent scores the two surfaces separately. Assign P0/P1/P2
   (every slice needs ≥1 P0). If the project has no end-to-end test setup, ask once, in the approval
   call below, whether to add end-to-end tests; without a yes, the briefs ask for unit and integration
   tests only.
3. Present the phase's slices together in the reference/output-format.md phase shape, with the build
   order — which slices run in parallel and which wait on another — and a coverage map — each Feature AC and each EARS behavior mapped to the scenario(s) that exercise it, and any
   surface with **no** scenario flagged as a gap. Ask the user to *Approve phase*, *Walk me through slice
   by slice*, *Edit a brief*, *Edit scenarios*, or *Add missing scenarios*. For a plan of one or two
   phases, assemble every phase first and present them all at once with the Target state; that single
   answer (*Approve plan*, *Walk me through slice by slice*, *Edit a brief*, *Edit scenarios*, *Re-slice*)
   approves the slicing, the phases, and the plan.
4. After approval, create the tasks:
   - the phase: `node ${CLAUDE_PLUGIN_ROOT}/scripts/task.js create --spec {specId} --type phase --name "Phase {n}: {outcome}" --depends-on {previous phase id, if any}` → record `phaseId`;
   - each slice, in dependency order: `node ${CLAUDE_PLUGIN_ROOT}/scripts/task.js create --spec {specId} --parent {phaseId} --type slice --name "{title}" --depends-on {slice task ids it extends} --covers {the AC ids in its Features} --body-file {brief.md}` → record its id;
   - each scenario: `node ${CLAUDE_PLUGIN_ROOT}/scripts/task.js create --spec {specId} --parent {sliceId} --type scenario --name "{scenario title}" --priority {P0|P1|P2} --surface {business|technical} --body-file {scenario.md}`.
   Fill the phase's slice ids into the Phases table.
5. Only when at least two phases remain to be planned after the first one's tasks exist, ask once:
   *Start implementing approved phases while I plan the rest?* On yes, use the implement skill on the spec after each approved phase — it builds only the
   slices not yet built or building — and keep planning while it runs in the background. On no,
   implementation waits for the finished plan.

### 4. Validate

Read reference/validation.md and run checks against the created tasks (`task.js graph --spec {specId}`):

- Every acceptance criterion in requirements maps to exactly one slice's Features.
- Every NFR-N appears as a quality gate on ≥1 slice.
- Every `[ASSUMPTION An]` is resolved or cited on the slices that depend on it.
- Every EARS criterion in solution maps to exactly one slice's Behavior.
- Every Feature (AC) maps to ≥1 `business` scenario and every EARS behavior maps to ≥1 `technical`
  scenario — no acceptance surface is left without a scenario; every slice has ≥1 P0. Each scenario
  carries a Surface tag and tests observable behavior only.
- Every slice `--depends-on` id refers to an existing slice; the dependency graph is acyclic (task.js validates dep ids and rejects parent cycles at create time).
- The `spec.md` frontmatter has `threshold` and `max_iterations`; the tracker has one phase task per plan phase, its slice children, and each slice's scenario children.

### 5. Approve

Read reference/output-format.md and present the status report: the Plan part, the task tree
(`task.js list --spec {specId} --depth 1 --format tree`), and the coverage map. When step 3 already took
the single plan approval and validation changed nothing the user saw, set `gates.plan` to `approved` (and record the `gate` event)
without asking again. Otherwise ask the user to *Approve plan*, *Revisit a slice*, *Re-slice*, or *Adjust
threshold*, and on approval set `gates.plan` to `approved` and record the `gate` event.

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

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

Каталог скиллов SKILL.md →
specify ghaida Скилл specify собирает утверждённый дизайн в пакет для команды или кодинг-агента: артефакты проекта плюс одна входная страница. CX Codex +1 3 300установок speckit-specify github-spec-kit Скилл speckit-specify превращает фразу о фиче в папку со спецификацией: короткое имя, номер, шаблон spec.md и запись в .specify/feature.json. CX Codex +1 2 700установок speckit.specify Chat2AnyLLM Команда speckit.specify для Claude Code генерирует или обновляет спецификацию функциональности по текстовому описанию задачи. Структурирует требования до написания кода. CX Codex +1 ★ 117звёзд репо speckit.companion.after-specify alfredoperez Команда speckit.companion.after-specify для Claude Code и Codex, которая записывает текущий шаг spec-kit в .spec-context.json для GUI Companion. Запускается из корня репозитория после завершения этапа specify. CX Codex +1 ★ 110звёзд репо speckit.companion.specify alfredoperez Команда speckit.companion.specify для Claude Code запускает фазу specify в spec-kit, собирая функциональную спеку и приоритизируя юзер-стори. Создаёт точку входа для новой спецификации проекта. CX Codex +1 ★ 110звёзд репо repo-intake-and-plan lllllllama Скилл repo-intake-and-plan сканирует репозиторий по README, собирает команды и предлагает минимальный план воспроизведения. Нужен до запуска экспериментов. CX Codex +1 502 400установок

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

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

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

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