Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

plan-feature

/plan-feature

Wymusza najpierw zrozumienie kodu i jawny plan przed edycją, przy zmianach nietrywialnych, takich jak funkcje i refaktoryzacje.

Licencja
MIT
Ostatnia zmiana repozytorium
03.10.2026

Ocena i bezpieczeństwo

90/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść25 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 03.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

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

  1. When to use this
  2. Phase 1: Explore (understand before touching)
  3. Phase 2: Plan (make the approach explicit and reviewable)
  4. Phase 3: Code (execute one verifiable step at a time)
  5. Phase 4: Commit (capture verifiable units)
  6. Anti-patterns
  7. Related
Sekcje z nagłówków SKILL.md, w oryginale · 65 linii, 620 słów
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

RepozytoriumWynikLicencja
Ta strona · mnzralee/claude-multi-agent-architecture90MIT
arozumenko/sdlc-skills100MIT
trihuynh-agilityio/workez100MIT
arozumenko/sdlc-skills100MIT
mo-cmyk/mazarbul100Apache-2.0
smartwhale8/claude-playbook100MIT
arozumenko/wikis100MIT
Shoebtamboli/rails_claude_skills100MIT
matthewalton/speccle90MIT

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.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.