Converts vague or frozen requirements into precise, step-by-step implementation plans with file-level touchpoints, decision checkpoints, and verifiable acceptance criteria before any code is written. This bridges the gap between what stakeholders want and what engineers can actually ship, reducing mid-sprint surprises and wasted refactors.
Use cases
- Starting a new feature with ambiguous scope or conflicting stakeholder expectations
- Handing off a spec to a contractor or AI agent for execution
- Breaking down a large epic into sprint-sized tickets for the first time
- Reviving a stalled project that needs a clear path to delivery
- Preparing for an architecture review where reviewers need to see concrete milestones
Key features
- Read the full specification end-to-end and list every constraint, dependency, and assumption before touching any design
- Identify module boundaries and high-risk areas where requirements are thin or contradict each other
- Split work into tasks of 1-3 days each with explicit exit criteria that a reviewer can verify objectively
- Order tasks to surface blockers early—implement interfaces and types before their consumers
- Add a review checkpoint after each risky section to catch direction drift before it compounds
When to Use This Skill
- When requirements are frozen but the path from spec to code is unclear
- When handing off work to another engineer or an AI agent that needs explicit guidance
- When a project has multiple stakeholders with conflicting priorities that need explicit arbitration
Expected Output
A structured implementation plan with numbered steps, file touchpoints, and acceptance criteria that a developer can follow without requiring further clarification.
Frequently Asked Questions
- How detailed should the plan be?
- Each step should be actionable in a single coding session. If a step takes more than two days, it needs to be split further. The goal is verifiable progress, not exhaustive documentation.
- Should I include research tasks in the plan?
- Yes—separate them from implementation tasks and give research a clear output (a decision document, a prototype, or a short summary) so it does not become an open-ended tangent.
- What if requirements change while I am following the plan?
- Treat the plan as a living document. Log changes as plan amendments with a one-line rationale rather than silently diverging, so the end state is traceable to the original spec.
Related
Related
3 Indexed items
AI product requirement writing
Writes product requirements documents that AI agents can act on reliably, with explicit constraints, edge cases, and acceptance criteria that minimize the gap between what you mean and what the agent builds. This skill bridges the ambiguity of natural language product specs and the precision that AI agents require to produce consistent results.
Executing implementation plans
Executes a pre-written implementation plan in disciplined order, stopping at defined checkpoints to verify assumptions before moving forward. This skill prevents the common pattern of diverging from the plan silently when reality proves it wrong, and it creates natural opportunities to course-correct before small errors compound into large rework.
Structured AI meeting notes
Converts raw meeting transcripts into structured, actionable notes with decision logs, assigned action items, and key context preserved for future AI retrieval. This skill bridges the gap between what was discussed in a meeting and what AI agents need to know when acting on outcomes days or weeks later.