Create a Plan Skill
This skill runs a structured technical interview to turn a rough idea or an existing spec into a detailed, implementable plan. The output is organized for parallel execution: foundations first, then independent workstreams, then merge and integration.
Invocation
The user will provide one of:
- A path to a spec or plan file (for example:
SPEC.md, PLAN.md, RFC.md)
- A rough description of what they want to build
- A feature request or problem statement
Output is always written to PLAN.md in the repo root.
Process
Phase 0: Preflight
- If a file path is provided, read it first and note goals, non-goals, constraints, and gaps.
- Confirm you will produce
PLAN.md as the output in the repo root. If PLAN.md already exists, update it rather than creating a new file.
Phase 1: Discovery
Summarize what is known, then identify missing details. Focus on:
- Goals and non-goals
- Constraints (time, budget, platform, dependencies)
- Success metrics and acceptance criteria
Phase 2: Deep Interview
Use the AskUserQuestion (Claude) and/or request_user_input (Codex) tools in rounds. Ask 1-3 questions per round. Each round should go deeper and avoid repeating what is already known.
CRITICAL RULES:
- Never ask obvious questions. If the codebase or spec already answers it, do not ask it again.
- Ask about edge cases and failure modes.
- Probe for hidden complexity (state transitions, migrations, concurrency).
- Challenge assumptions when they create risk or ambiguity.
- Identify parallelization boundaries and serial dependencies.
- If the user is unsure, propose a default and ask for confirmation.
Question categories to cover as relevant:
- Technical architecture and data flow
- Data model and state management
- API contracts and versioning
- Caching and invalidation
- Background jobs, retries, and idempotency
- Error handling and recovery
- Observability and debugging
- Performance, scale, and SLAs
- Security, privacy, and compliance
- Integrations and external dependencies
- UX flows, accessibility, and responsiveness
- Rollout, migration, and rollback
- Testing strategy and validation
Phase 3: Dependency Analysis
Identify:
- Serial dependencies that must complete first
- Parallel workstreams that can run independently
- Merge points where work reconvenes
Phase 4: Plan Generation
Write the final plan to PLAN.md. Ensure the plan includes concrete verification steps the agent can run end to end. If the user only wants a plan in chat, provide it inline and mention that it would be written to PLAN.md.
Output Format
The generated plan MUST follow this structure:
# [Feature Name] Implementation Plan
## Overview
[2-3 sentence summary of what this implements and why]
## Goals
- [Explicit goal 1]
- [Explicit goal 2]
## Non-Goals
- [What this explicitly does NOT do]
## Assumptions and Constraints
- [Known constraints or assumptions]
## Requirements
### Functional
- [Requirement]
### Non-Functional
- [Performance, reliability, security, compliance]
## Technical Design
### Data Model
[Schema changes, new entities, relationships]
### API Design
[New endpoints, request/response shapes, versioning]
### Architecture
[System diagram in text or mermaid, component interactions]
### UX Flow (if applicable)
[Key screens, loading states, error recovery]
---
## Implementation Plan
### Serial Dependencies (Must Complete First)
These tasks create foundations that other work depends on. Complete in order.
#### Phase 0: [Foundation Name]
**Prerequisite for:** All subsequent phases
| Task | Description | Output |
| ---- | ------------------ | ---------------------- |
| 0.1 | [Task description] | [Concrete deliverable] |
| 0.2 | [Task description] | [Concrete deliverable] |
---
### Parallel Workstreams
These workstreams can be executed independently after Phase 0.
#### Workstream A: [Name]
**Dependencies:** Phase 0
**Can parallelize with:** Workstreams B, C
| Task | Description | Output |
| ---- | ------------------ | ---------------------- |
| A.1 | [Task description] | [Concrete deliverable] |
| A.2 | [Task description] | [Concrete deliverable] |
#### Workstream B: [Name]
**Dependencies:** Phase 0
**Can parallelize with:** Workstreams A, C
| Task | Description | Output |
| ---- | ------------------ | ---------------------- |
| B.1 | [Task description] | [Concrete deliverable] |
---
### Merge Phase
After parallel workstreams complete, these tasks integrate the work.
#### Phase N: Integration
**Dependencies:** Workstreams A, B, C
| Task | Description | Output |
| ---- | ------------------ | ---------------------- |
| N.1 | [Integration task] | [Concrete deliverable] |
---
## Testing and Validation
- [Unit, integration, end-to-end coverage]
- [Manual test plan if needed]
## Rollout and Migration
- [Feature flags, staged rollout, migration steps]
- [Rollback plan]
## Verification Checklist
- [Exact commands or manual steps the agent can run to verify correctness]
- [Expected outputs or success criteria]
## Risk Assessment
| Risk | Likelihood | Impact | Mitigation |
| ------------------ | ------------ | ------------ | ---------- |
| [Risk description] | Low/Med/High | Low/Med/High | [Strategy] |
## Open Questions
- [ ] [Question that still needs resolution]
## Decision Log
| Decision | Rationale | Alternatives Considered |
| --------------- | --------- | -------------------------- |
| [Decision made] | [Why] | [What else was considered] |
Interview Flow Example
Round 1: High-Level Architecture
- "The spec mentions a sync engine. Is this push-based (webhooks), pull-based (polling), or event-driven (queue)?"
- "What is the expected data volume and throughput?"
Round 2: Edge Cases
- "If a batch fails mid-run, do we retry the whole batch or resume from a checkpoint?"
- "What happens when source data is deleted but still referenced downstream?"
Round 3: Parallelization
- "Can we process different categories independently, or are there cross-category dependencies?"
- "Is there a natural partition key that allows sharding?"
Round 4: Operational
- "What is the acceptable latency for sync or processing?"
- "How will operators debug failures and what visibility do they need?"
Key Behaviors
- Persist until the plan is implementable and verifiable by the agent, but avoid user fatigue by batching questions.
- Challenge vague answers when they affect design decisions.
- Identify hidden work and operational overhead.
- Think about the merge and integration steps early.
- Summarize understanding and confirm before writing the final plan.
Completing the Interview
After sufficient rounds of questions:
- Summarize your understanding back to the user
- Confirm the parallelization strategy
- Write the complete plan to the target file
- Ask if any sections need refinement
1---2name: create-a-plan-23description: Conduct a focused technical planning interview to produce an implementable, parallelizable plan or spec with clear dependencies, risks, and open questions.4---56# Create a Plan Skill78This skill runs a structured technical interview to turn a rough idea or an existing spec into a detailed, implementable plan. The output is organized for parallel execution: foundations first, then independent workstreams, then merge and integration.910## Invocation1112The user will provide one of:1314- A path to a spec or plan file (for example: `SPEC.md`, `PLAN.md`, `RFC.md`)15- A rough description of what they want to build16- A feature request or problem statement1718Output is always written to `PLAN.md` in the repo root.1920## Process2122### Phase 0: Preflight23241. If a file path is provided, read it first and note goals, non-goals, constraints, and gaps.252. Confirm you will produce `PLAN.md` as the output in the repo root. If `PLAN.md` already exists, update it rather than creating a new file.2627### Phase 1: Discovery2829Summarize what is known, then identify missing details. Focus on:3031- Goals and non-goals32- Constraints (time, budget, platform, dependencies)33- Success metrics and acceptance criteria3435### Phase 2: Deep Interview3637Use the `AskUserQuestion` (Claude) and/or `request_user_input` (Codex) tools in rounds. Ask 1-3 questions per round. Each round should go deeper and avoid repeating what is already known.3839CRITICAL RULES:40411. Never ask obvious questions. If the codebase or spec already answers it, do not ask it again.422. Ask about edge cases and failure modes.433. Probe for hidden complexity (state transitions, migrations, concurrency).444. Challenge assumptions when they create risk or ambiguity.455. Identify parallelization boundaries and serial dependencies.466. If the user is unsure, propose a default and ask for confirmation.4748Question categories to cover as relevant:4950- Technical architecture and data flow51- Data model and state management52- API contracts and versioning53- Caching and invalidation54- Background jobs, retries, and idempotency55- Error handling and recovery56- Observability and debugging57- Performance, scale, and SLAs58- Security, privacy, and compliance59- Integrations and external dependencies60- UX flows, accessibility, and responsiveness61- Rollout, migration, and rollback62- Testing strategy and validation6364### Phase 3: Dependency Analysis6566Identify:67681. Serial dependencies that must complete first692. Parallel workstreams that can run independently703. Merge points where work reconvenes7172### Phase 4: Plan Generation7374Write the final plan to `PLAN.md`. Ensure the plan includes concrete verification steps the agent can run end to end. If the user only wants a plan in chat, provide it inline and mention that it would be written to `PLAN.md`.7576## Output Format7778The generated plan MUST follow this structure:7980```markdown81# [Feature Name] Implementation Plan8283## Overview8485[2-3 sentence summary of what this implements and why]8687## Goals8889- [Explicit goal 1]90- [Explicit goal 2]9192## Non-Goals9394- [What this explicitly does NOT do]9596## Assumptions and Constraints9798- [Known constraints or assumptions]99100## Requirements101102### Functional103104- [Requirement]105106### Non-Functional107108- [Performance, reliability, security, compliance]109110## Technical Design111112### Data Model113114[Schema changes, new entities, relationships]115116### API Design117118[New endpoints, request/response shapes, versioning]119120### Architecture121122[System diagram in text or mermaid, component interactions]123124### UX Flow (if applicable)125126[Key screens, loading states, error recovery]127128---129130## Implementation Plan131132### Serial Dependencies (Must Complete First)133134These tasks create foundations that other work depends on. Complete in order.135136#### Phase 0: [Foundation Name]137138**Prerequisite for:** All subsequent phases139140| Task | Description | Output |141| ---- | ------------------ | ---------------------- |142| 0.1 | [Task description] | [Concrete deliverable] |143| 0.2 | [Task description] | [Concrete deliverable] |144145---146147### Parallel Workstreams148149These workstreams can be executed independently after Phase 0.150151#### Workstream A: [Name]152153**Dependencies:** Phase 0154**Can parallelize with:** Workstreams B, C155156| Task | Description | Output |157| ---- | ------------------ | ---------------------- |158| A.1 | [Task description] | [Concrete deliverable] |159| A.2 | [Task description] | [Concrete deliverable] |160161#### Workstream B: [Name]162163**Dependencies:** Phase 0164**Can parallelize with:** Workstreams A, C165166| Task | Description | Output |167| ---- | ------------------ | ---------------------- |168| B.1 | [Task description] | [Concrete deliverable] |169170---171172### Merge Phase173174After parallel workstreams complete, these tasks integrate the work.175176#### Phase N: Integration177178**Dependencies:** Workstreams A, B, C179180| Task | Description | Output |181| ---- | ------------------ | ---------------------- |182| N.1 | [Integration task] | [Concrete deliverable] |183184---185186## Testing and Validation187188- [Unit, integration, end-to-end coverage]189- [Manual test plan if needed]190191## Rollout and Migration192193- [Feature flags, staged rollout, migration steps]194- [Rollback plan]195196## Verification Checklist197198- [Exact commands or manual steps the agent can run to verify correctness]199- [Expected outputs or success criteria]200201## Risk Assessment202203| Risk | Likelihood | Impact | Mitigation |204| ------------------ | ------------ | ------------ | ---------- |205| [Risk description] | Low/Med/High | Low/Med/High | [Strategy] |206207## Open Questions208209- [ ] [Question that still needs resolution]210211## Decision Log212213| Decision | Rationale | Alternatives Considered |214| --------------- | --------- | -------------------------- |215| [Decision made] | [Why] | [What else was considered] |216```217218## Interview Flow Example219220Round 1: High-Level Architecture221222- "The spec mentions a sync engine. Is this push-based (webhooks), pull-based (polling), or event-driven (queue)?"223- "What is the expected data volume and throughput?"224225Round 2: Edge Cases226227- "If a batch fails mid-run, do we retry the whole batch or resume from a checkpoint?"228- "What happens when source data is deleted but still referenced downstream?"229230Round 3: Parallelization231232- "Can we process different categories independently, or are there cross-category dependencies?"233- "Is there a natural partition key that allows sharding?"234235Round 4: Operational236237- "What is the acceptable latency for sync or processing?"238- "How will operators debug failures and what visibility do they need?"239240## Key Behaviors2412421. Persist until the plan is implementable and verifiable by the agent, but avoid user fatigue by batching questions.2432. Challenge vague answers when they affect design decisions.2443. Identify hidden work and operational overhead.2454. Think about the merge and integration steps early.2465. Summarize understanding and confirm before writing the final plan.247248## Completing the Interview249250After sufficient rounds of questions:2512521. Summarize your understanding back to the user2532. Confirm the parallelization strategy2543. Write the complete plan to the target file2554. Ask if any sections need refinement