ct-writing-plans

Generates detailed implementation plans with bite-sized TDD tasks from a specification.

1|Updated Sep 8, 2026
One-click install
npx skills add https://github.com/mercadona/control-tower --skill ct-writing-plans-mercadona
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ct-writing-plans
Source: https://github.com/mercadona/control-tower/tree/main/plugin/skills/ct-writing-plans
Command: npx skills add https://github.com/mercadona/control-tower --skill ct-writing-plans-mercadona

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning a specification into code without a plan leads to missed requirements, vague tasks, and inconsistent execution. This Skill converts a spec into a complete implementation plan with exact file paths, real code, and testable steps that an engineer with zero codebase context can follow. ## Core Features & Use Cases - Spec-to-Plan Conversion: Transforms a written specification into a structured plan with a header, global constraints, and numbered tasks. - Bite-Sized TDD Tasks: Breaks each task into 2-5 minute steps following the write-failing-test, implement, verify, commit cycle. - No-Placeholder Enforcement: Requires exact file paths, complete code blocks, and exact commands with expected output in every step. - Self-Review Checklist: Verifies spec coverage, scans for placeholder patterns, and checks type consistency across tasks before handoff. - Use Case: Given a spec for a new API endpoint, produce a plan saved to docs/superpowers/plans/ with tasks an isolated subagent can execute independently. ## Quick Start Ask the agent to use the writing-plans skill to turn your specification document into a step-by-step implementation plan.

Frequently Asked Questions about ct-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 specification?

Start with a header stating the goal, architecture, and tech stack, then decompose the spec into tasks with exact file paths and interfaces. Each task contains bite-sized TDD steps: write the failing test, verify it fails, implement minimally, verify it passes, and commit.

What makes a good task breakdown for coding agents?

Each task should be the smallest unit carrying its own test cycle, with steps of 2-5 minutes each. Include exact file paths, complete code blocks, exact commands with expected output, and an Interfaces block describing what the task consumes and produces.

When should a spec be split into multiple 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 executable.

Why do implementation plans fail during execution?

Plans fail when they contain placeholders like TODO or vague steps such as add error handling, when code is referenced but never shown, or when type and function names are inconsistent across tasks. A self-review pass for coverage, placeholders, and type consistency catches these.

How are completed plans executed after writing?

After saving the plan, choose subagent-driven execution, which dispatches a fresh subagent per task with review between tasks, or inline execution, which runs tasks in the current session with batch checkpoints.