writing-plans

Generates detailed multi-task implementation plans with TDD steps from a spec.

Updated Jul 23, 2026
One-click install
npx skills add https://github.com/shrek-abaper/sap-nexus-agent --skill writing-plans-shrek-abaper
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/shrek-abaper/sap-nexus-agent/tree/main/.comet/skills/skills/writing-plans
Command: npx skills add https://github.com/shrek-abaper/sap-nexus-agent --skill writing-plans-shrek-abaper

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning a spec or requirements document into an actionable implementation plan is error-prone: tasks end up too vague, steps lack actual code, and engineers without codebase context get stuck. This Skill produces a complete, bite-sized implementation plan that an engineer with zero project context can execute task by task. ## Core Features & Use Cases - Structured Plan Generation: Produces a plan document with a required header, global constraints, per-task file lists, interface contracts, and checkbox-tracked steps saved to docs/superpowers/plans/. - TDD Bite-Sized Steps: Each task is decomposed into 2-5 minute steps following a write-failing-test, verify-failure, implement, verify-pass, commit cycle with exact commands and expected output. - No-Placeholder Enforcement and Self-Review: Bans TBDs and vague steps, then runs a self-review checklist covering spec coverage, placeholder scans, and type consistency across tasks. - Use Case: Given a feature spec for a new API endpoint, produce a dated plan file where each task lists exact files to create or modify, full test and implementation code, and commit commands, then hand off to subagent-driven or inline execution. ## Quick Start Ask the AI to use the writing-plans skill to create an implementation plan from your spec before writing any code.

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?▼

Invoke the writing-plans skill with your spec or requirements. It produces a plan document with a goal, architecture summary, global constraints, and tasks broken into bite-sized TDD steps with exact file paths, code, and commands.

How to break a large feature spec into implementation tasks?▼

The skill first checks scope: if the spec spans multiple independent subsystems, it recommends splitting into separate plans. Within a plan, tasks are right-sized so each ends with an independently testable deliverable a reviewer could approve or reject on its own.

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

Each step should be one action taking 2-5 minutes, such as writing a failing test, running it to confirm failure, implementing minimal code, verifying the pass, and committing. Setup and documentation steps fold into the task whose deliverable needs them.

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

Yes. After saving the plan to docs/superpowers/plans/, the skill offers two execution modes: subagent-driven development with a fresh subagent per task and review between tasks, or inline execution with batched checkpoints.

What are common failure modes when writing implementation plans?▼

Plan failures include placeholders like TBD or 'add appropriate error handling', steps without actual code, references to undefined types or functions, and inconsistent naming across tasks. The skill's self-review checklist catches spec gaps, placeholders, and type mismatches.