> workflow / implementation-planning
Implementation Planning
Break approved architecture into verifiable slices with tests, rollback, and evidence hooks — before any feature coding begins.
What should I do next?
Complete the steps and evidence below, clear the human gates, then continue to Human Review.
When to use
- ADRs and boundary freeze exist
- Work must be sliced for parallel humans/agents without scope thrash
- You need a plan file that pre-code hooks can enforce
- Test strategy and rollback must be explicit before coding
Step-by-step
- Derive slices from ADRs and contracts — each slice shippable with evidence.
- For each slice: files touched, tests, evals, rollback, and Definition of Done.
- Order the task graph by dependency and risk; put spike slices first when unknowns remain.
- Call out technical debt you will deliberately take and debt you refuse.
- Run implementation-plan.prompt; produce a plan file in-repo (not a chat transcript).
- Attach test strategy outline and eval gates for AI-touched paths.
- Stop at plan completion — do not code until human-review approves the plan.
Decisions to make
- Slice size: hours vs days — prefer slices that fit one PR
- What is spike vs committed delivery
- Which debt is accepted with an expiry date
- Which slices require pair programming vs solo AI-assisted work
Evidence to collect
- Committed implementation plan file with task graph
- Test/eval strategy linked per high-risk slice
- Rollback steps for each production-touching slice
- pre-planning.hook.sh pass on the plan artifact
Role-specific next actions
- PM: Validate slices still map to brief metrics; cut or reorder ruthlessly.
- Architect: Reject slices that violate ADR boundaries or invent new integrations.
- Engineer: Estimate and challenge missing tests, migrations, and observability work.
- QA: Own test strategy outline and risk-based coverage targets.
Inputs
- Approved ADRs and contracts
- Backlog / capacity
- Risk tier and DoR
Outputs
- Implementation plan file
- Task graph with owners
- Test and eval strategy outline
Required prompts
- Implementation plan
Produces the enforceable plan artifact coding agents must follow.
- Technical debt
Makes accepted debt explicit with expiry and owners.
- Test generation
Seeds the test strategy for high-risk slices.
Required skills
Required MCP servers
- Jira MCP
Optional: sync plan slices to tickets after plan approval.
- Linear MCP
Optional alternative PM sync — never invents scope.
Tooling & handbook
- How to set up planning
Harness for plan files and gates.
- pre-planning hook
Validates plan artifacts before coding.
- pre-code hook
Will block coding until plan approval exists.
- Planner pattern workflow
Operationalizes plan → approve → execute.
- Definition of Done
Per-slice exit bar.
Recommended agents & patterns
- Planner pattern
Primary agent pattern for this stage.
- Planner agent
Drafts the plan file; humans own sequencing and risk.
Human approval gates
- Plan file exists in-repo and passes pre-planning checks
- No coding until the human-review (plan approval) stage completes
Automation opportunities
- pre-planning.hook.sh on plan PRs
- Ticket creation from approved slices only
- Link each slice to ADR IDs in the plan file
Enterprise best practices
- Plans reference control IDs where regulated workloads apply
- Capacity and dependency risks explicit — no hidden platform work
- Retain plan versions for audit when AI executes slices
Common mistakes
- Monolithic plans that cannot be reviewed or rolled back
- Missing rollback and observability steps
- Coding from a chat plan that never landed in git