writing-plans

Generates bite-sized TDD implementation plans from specs with exact file paths and code.

Updated Jun 5, 2026
One-click install
npx skills add https://github.com/zMynxx/bifrost-with-opencode --skill writing-plans-zmynxx
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/zMynxx/bifrost-with-opencode/tree/main/agent/skills/writing-plans
Command: npx skills add https://github.com/zMynxx/bifrost-with-opencode --skill writing-plans-zmynxx

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Engineers and AI agents often jump from a spec straight into code, producing unstructured work with missing tests, vague tasks, and placeholder content. This Skill turns a spec or requirements document into a complete, step-by-step implementation plan that a developer with zero codebase context can execute. ## Core Features & Use Cases - Bite-Sized TDD Tasks: Breaks work into 2-5 minute steps following the write-failing-test, implement, verify, commit cycle. - No-Placeholder Enforcement: Requires exact file paths, complete code blocks, exact commands with expected output, and explicit interface contracts between tasks. - Self-Review and Handoff: Includes a spec-coverage, placeholder, and type-consistency checklist, plus an execution handoff to subagent-driven or inline execution workflows. - Use Case: Given a feature spec for a new API endpoint, produce a dated plan document in docs/superpowers/plans/ with checkboxed tasks covering tests, implementation, and commits, ready for task-by-task execution. ## Quick Start Ask the agent to use the writing-plans skill to turn your spec into a step-by-step TDD implementation plan saved under docs/superpowers/plans.

Frequently Asked Questions about writing-plans

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I write an implementation plan from a spec before coding?▼

Provide the spec and invoke the writing-plans skill before touching code. It produces a plan document with a goal, architecture summary, global constraints, and checkboxed TDD tasks saved to docs/superpowers/plans with a dated filename.

What makes a good task breakdown in an implementation plan?▼

Each task should be the smallest unit carrying its own test cycle, with steps of 2-5 minutes each: write the failing test, verify it fails, implement minimally, verify it passes, then commit. Tasks must list exact files and the interfaces they consume and produce.

Can the plan be executed by subagents after it is written?▼

Yes. After saving the plan, the skill offers two execution modes: subagent-driven development, which dispatches a fresh subagent per task with review between tasks, or inline execution with batched checkpoints.

Why does my implementation plan get rejected during review?▼

Plans fail review when they contain placeholders like TODO or vague steps such as add error handling, reference undefined types or functions, or miss spec requirements. The self-review checklist catches spec gaps, placeholders, and type inconsistencies.

When should a spec be split into multiple implementation plans?▼

Split when the spec covers multiple independent subsystems. Each plan should produce working, testable software on its own, so one plan per subsystem keeps tasks focused and independently reviewable.