writing-plans

Generates detailed multi-task implementation plans with exact file paths, code, and test steps.

Updated Apr 29, 2026
One-click install
npx skills add https://github.com/fred-meng/harness --skill writing-plans-fred-meng
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/fred-meng/harness/tree/main/.github/skills/writing-plans
Command: npx skills add https://github.com/fred-meng/harness --skill writing-plans-fred-meng

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Engineers and AI agents often start coding from a spec without a concrete plan, leading to missed requirements, vague tasks, and inconsistent implementations. This Skill turns a spec or requirements document into a complete, bite-sized implementation plan that an engineer with zero codebase context can follow. ## Core Features & Use Cases - Bite-Sized Task Decomposition: Breaks work into 2-5 minute steps following TDD: write failing test, verify failure, implement, verify pass, commit. - No-Placeholder Enforcement: Requires exact file paths, complete code blocks, exact commands with expected output, and forbids TODOs or vague instructions. - Self-Review and Handoff: Includes a spec-coverage and consistency self-review checklist, plus an execution handoff offering subagent-driven or inline execution. - Use Case: Given a feature spec for a new API endpoint, produce a dated plan file in docs/superpowers/plans/ with checkbox-tracked tasks covering tests, implementation, and commits. ## Quick Start Ask the agent 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?

Provide the spec or requirements and invoke the writing-plans skill before touching code. It produces a plan with a goal, architecture summary, file structure, and checkbox-tracked tasks containing exact file paths, code, and test commands.

How detailed should tasks in an implementation plan be?

Each step should be one action taking 2-5 minutes, such as writing a failing test, running it, implementing minimal code, verifying it passes, and committing. Every step must include actual code and exact commands with expected output.

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 scope reviewable and executable.

What are common mistakes in AI-generated implementation plans?

Common failures include placeholders like TODO or 'add error handling', missing code in steps, inconsistent function names across tasks, and requirements from the spec with no corresponding task. The self-review checklist catches these before execution.

How is a finished plan executed after writing it?

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