plan-feature
/plan-feature
Wymusza najpierw zrozumienie kodu i jawny plan przed edycją, przy zmianach nietrywialnych, takich jak funkcje i refaktoryzacje.
- Autor
- mnzralee ↗
- Repozytorium
- claude-multi-agent-architecture ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 03.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 03.10.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Wymusza najpierw zrozumienie kodu i jawny plan przed edycją, przy zmianach nietrywialnych, takich jak funkcje i refaktoryzacje.
Oryginalny opis (EN)
The Explore to Plan to Code to Commit workflow for any non-trivial change. Forces understanding and an explicit plan before edits, with a one-sentence skip heuristic for trivial work. Use when starting a feature, a refactor, or any change whose steps are not obvious. Pairs with plan mode.
Jak działa
- When to use this
- Phase 1: Explore (understand before touching)
- Phase 2: Plan (make the approach explicit and reviewable)
- Phase 3: Code (execute one verifiable step at a time)
- Phase 4: Commit (capture verifiable units)
- Anti-patterns
- Related
Podgląd SKILL.md
---
name: plan-feature
description: The Explore to Plan to Code to Commit workflow for any non-trivial change. Forces understanding and an explicit plan before edits, with a one-sentence skip heuristic for trivial work. Use when starting a feature, a refactor, or any change whose steps are not obvious. Pairs with plan mode.
---
# Plan a Feature
> The canonical agentic-coding loop, in four phases: Explore, Plan, Code, Commit. Anthropic's own guidance is that jumping straight to code is the most common way agents go wrong. This skill makes the loop explicit.
## When to use this
Invoke `/plan-feature` (or just follow this loop) for any change where the steps are not already obvious: a new feature, a multi-file refactor, a behavior change, a bug whose cause is unknown.
**The one-sentence skip heuristic:** if you can describe the entire diff in one sentence ("rename `getUser` to `fetchUser` across the repo", "bump the timeout from 5s to 30s"), skip planning and just make the change, then verify. Planning a trivial edit is waste. Everything else gets the loop.
## Phase 1: Explore (understand before touching)
Do not write code yet. Build an accurate model of the current state.
- Read the relevant files, tests, and types. Follow the real call paths, do not assume them.
- Find the existing patterns: how does this codebase already solve similar problems? Match them.
- Identify the blast radius: what else depends on what you are about to change? (See `.claude/rules/depth-first-impact-analysis.md`.)
- For verbose or wide exploration, dispatch a read-only `researcher` sub-agent so the main context stays clean (see `.claude/rules/ai-orchestration-decision-gate.md`).
Exit criterion: you can state, in plain language, what exists today and why the change is needed.
## Phase 2: Plan (make the approach explicit and reviewable)
Write the plan down before editing. Use plan mode (Shift+Tab to enter it, so the model proposes without making changes) for anything non-trivial.
A good plan states:
- **Goal**: the one-sentence outcome.
- **Approach**: the chosen design, and why, over the alternative you rejected.
- **Steps**: the ordered changes, each small enough to verify on its own.
- **Files**: the specific files each step touches (this is also the parallel-conflict map if you delegate).
- **Acceptance criteria as commands**: the exact `npm test`, `npx tsc --noEmit`, or curl that proves each step (see `.claude/rules/ai-agent-engineering.md`).
- **Risks and rollback**: what could break, and how you back out.
For high-stakes or contested designs, get the plan reviewed before coding: a `reviewer` or `architect` sub-agent, or the review-board prompt (`.claude/prompts/review-board.md`). Cheaper to fix a plan than a diff.
## Phase 3: Code (execute one verifiable step at a time)
- Implement one step. Run its acceptance command. Confirm it passes before the next step.
- Prefer test-first where it fits: write the failing test, then make it pass (see `.claude/skills/tdd-workflow/SKILL.md`).
- Keep changes small and incremental. A 600-line diff that "should work" is worse than six 100-line diffs that each verifiably do.
- If you correct the same problem twice without progress, stop. Clear the cluttered context, re-read, and re-plan with a fresh prompt rather than piling on more attempts.
## Phase 4: Commit (capture verifiable units)
- Commit after each logical, verified unit of work, not once at the end. See `.claude/skills/commit/SKILL.md`.
- Each commit message is descriptive and conventional (`type(scope): subject`), explains the why, and carries no AI attribution.
- Before declaring done, run the definition-of-done gate: `.claude/skills/verification-before-completion/SKILL.md`. Paste the actual lint/build/test output; do not claim green from memory.
## Anti-patterns
- Editing before exploring (you will fight the codebase's existing patterns).
- A plan with no acceptance commands (you cannot prove the steps).
- A single giant commit at the end (no rollback granularity, no reviewable units).
- Planning a one-sentence change (waste; just do it and verify).
## Related
- `.claude/rules/ai-orchestration-decision-gate.md`, when to delegate exploration vs do it inline
- `.claude/rules/depth-first-impact-analysis.md`, mapping the blast radius in Phase 1
- `.claude/skills/tdd-workflow/SKILL.md`, the red-green-refactor cycle for Phase 3
- `.claude/skills/commit/SKILL.md` and `.claude/skills/verification-before-completion/SKILL.md`, Phase 4 gates
- `.claude/prompts/review-board.md`, reviewing a plan before coding
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · mnzralee/claude-multi-agent-architecture | 90 | MIT |
| arozumenko/sdlc-skills | 100 | MIT |
| trihuynh-agilityio/workez | 100 | MIT |
| arozumenko/sdlc-skills | 100 | MIT |
| mo-cmyk/mazarbul | 100 | Apache-2.0 |
| smartwhale8/claude-playbook | 100 | MIT |
| arozumenko/wikis | 100 | MIT |
| Shoebtamboli/rails_claude_skills | 100 | MIT |
| matthewalton/speccle | 90 | MIT |
Migawka bazy z 13.11.2026 · wersja paczki 83768a1f04f3 (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100planning
Wymusza uporządkowane myślenie projektowe przed kodem: propozycje podejść, akceptacja, a potem plan kroków. - 90feature-flow
Prowadzi funkcje i zmiany w repozytoriach pracy od rozpoznania przez plan z pytaniami, wdrożenie zgodnie z planem i weryfikację. - 90plan-first
Podaje listę plików, testów i zmian poza zakresem, zanim powstanie kod w niebanalnym commicie, także przy zmianach schematu bazy. - 90plan-mode
Wymusza bramkę planowania przed edycją kodu: bada kontekst projektu, wskazuje niejasności, sprzeczności, ryzyka, zależności i blokery, zadaje pytania i tworzy plan z dowodami, a implementuje po zatwierdzeniu. - 100research-plan-implement
Prowadzi trzyfazowy workflow RPI (research, plan, implementacja) dla nietrywialnych zmian w kodzie. - 86plan-before-code
Ustala kształt i wielkość zmiany przed jej napisaniem: dla każdej nietrywialnej edycji, nowego mechanizmu lub refaktoryzacji.