Skip to content
Claude Kit

Planning & Building

Planning & Building

Section titled “Planning & Building”

Claude Kit provides a structured workflow for turning ideas into working code: Brainstorm > Plan > Review > Execute > Verify.

The Workflow

Section titled “The Workflow”
"I need to add user authentication"
        │
        ▼
┌─────────────────┐
│  Brainstorming   │  Explore requirements, ask questions,
│                  │  evaluate approaches, validate design
└────────┬────────┘
         ▼
┌─────────────────┐
│  Writing Plans   │  Break into tasks, exact file paths,
│                  │  code samples, verification steps
└────────┬────────┘
         ▼
┌─────────────────┐
│    Autoplan      │  Parallel 4-angle plan review:
│  (optional but   │  strategy, architecture, design, DX.
│   recommended)   │  Single fix-gate before implementation.
└────────┬────────┘
         ▼
┌─────────────────┐
│ Executing Plans  │  Fresh subagent per task, code review
│                  │  between tasks, quality gates
└────────┬────────┘
         ▼
┌─────────────────┐
│  Verification    │  Run tests, verify builds,
│                  │  evidence before claims
└─────────────────┘

Phase 1: Brainstorming

Section titled “Phase 1: Brainstorming”

Triggers on: “brainstorm”, “design”, “explore”, “what if”, “how should we”, “trade-offs”

The brainstorming skill uses a three-phase process:

  1. Understanding — Asks one question at a time to clarify requirements. Prefers multiple-choice over open-ended questions.
  2. Exploration — Presents 2-3 approaches with trade-offs, leads with a recommendation.
  3. Design — Presents the validated design in digestible 200-300 word sections.

Example

Section titled “Example”
You: "Let's brainstorm adding real-time notifications"


Claude: "Which delivery mechanism fits your use case best?
  a) WebSockets — persistent connection, instant delivery
  b) Server-Sent Events — simpler, one-way push
  c) Polling — simplest, but higher latency"


You: "b) SSE"


Claude: "## Approach 1: SSE + Redis Pub/Sub (Recommended)
  Server pushes events via SSE, Redis coordinates across instances.
  - Pros: Simple, works with load balancers, auto-reconnect built in
  - Cons: One-way only (client can't push back)


  ## Approach 2: SSE + PostgreSQL LISTEN/NOTIFY
  ..."

Phase 2: Writing Plans

Section titled “Phase 2: Writing Plans”

Triggers on: “plan”, “break down”, “implementation steps”, “task list”

The writing-plans skill creates detailed implementation plans with:

  • Exact file paths for every change
  • Complete code samples (not descriptions)
  • Verification commands with expected output
  • 2-5 minute task granularity

Plan Structure

Section titled “Plan Structure”
## Task 1: Create User model with email field


**Files**:
- Create: `src/models/user.ts`
- Test: `src/models/user.test.ts`


**Steps**:
1. Write failing test
2. Verify test fails
3. Implement minimally
4. Verify test passes
5. Commit
Section titled “Phase 2.5: Plan Review (Optional but recommended)”

Triggers on: “autoplan”, “auto review”, “review my plan”, “think bigger”, “does this design make sense”, “DX review”

Before jumping into execution, pressure-test the plan from four complementary angles. Each reviewer returns a 0-10 scorecard per dimension and proposes concrete fixes. Fixes are presented in a single multi-select prompt — you pick which ones to apply, and they’re written directly into the plan file.

SkillDimensions scoredWhen to invoke
plan-ceo-reviewAmbition, problem clarity, wedge focus, demand reality, future-fitPlan scope / strategy pressure-test
plan-eng-reviewData flow, failure modes, edge cases, test matrix, rollbackArchitecture audit before coding
plan-design-reviewHierarchy, visual consistency, states, accessibility, AI-slop avoidancePlans with UI surfaces
plan-devex-reviewTime to Hello World, ergonomics, error copy, docs structure, magical momentsPlans shipping APIs / CLIs / SDKs
autoplanAll 4 above, fanned out in parallel, single consolidated fix gateFull gauntlet before handoff

Example

Section titled “Example”
You: "/claudekit:autoplan"


Claude: [dispatches 4 reviewers in parallel]


# Autoplan Review: 2026-04-24-feature-x-plan
Overall Scores:
  CEO:    6.2/10 (lowest: Wedge focus 4/10)
  ENG:    7.8/10 (lowest: Rollback 5/10)
  DESIGN: 8.4/10
  DEVEX:  5.6/10 (lowest: Time to Hello World 3/10)


Critical Issues (worst first):
  [DEVEX] Time to Hello World: no quickstart specified
  [CEO]   Wedge focus: covers 3 personas simultaneously
  [ENG]   Rollback: no undo path for Phase 2 migration
  ...


> Which fixes to apply? [multi-select]

Phase 3: Executing Plans

Section titled “Phase 3: Executing Plans”

Triggers on: “execute the plan”, “run the plan”, “implement the plan”

The executing-plans skill runs each task with:

  • Fresh subagent per task — Prevents context pollution
  • Code review between tasks — Catches issues early
  • Quality gates — Critical issues must be fixed before proceeding

Execution Flow

Section titled “Execution Flow”
Task 1 → Implement → Review → Fix issues → ✓
Task 2 → Implement → Review → Fix issues → ✓
Task 3 → Implement → Review → Fix issues → ✓
Final comprehensive review → ✓

Phase 4: Verification

Section titled “Phase 4: Verification”

Auto-triggers on: completion claims (“done”, “fixed”, “tests pass”)

The verification-before-completion skill requires evidence before any completion claim:

  • Run the actual test suite and read the output
  • Verify the build succeeds
  • Check that the feature works as intended

Supporting Skills

Section titled “Supporting Skills”

These skills activate automatically during planning and building:

SkillWhen It Helps
feature-workflowEnd-to-end feature development
sequential-thinkingComplex decisions needing step-by-step reasoning
subagent-driven-developmentFresh subagent per task with two-stage review
using-git-worktreesIsolated branch work for parallel development
dispatching-parallel-agentsLaunching independent parallel agents
refactoringImproving code structure before shipping

Supporting Agents

Section titled “Supporting Agents”
AgentRole
plannerResearch and create implementation plans
brainstormerExplore solutions and evaluate trade-offs
researcherResearch technologies and best practices
ceo-reviewerStrategic/scope pressure test on a written plan
eng-reviewerArchitecture review on a written plan
design-reviewerUX/visual review on a written plan
devex-reviewerDeveloper-experience review on a written plan
Section titled “Related Pages”