compose:plan

Generates detailed implementation plans with bite-sized TDD tasks from feature specifications.

Updated Jun 27, 2026
One-click install
npx skills add https://github.com/HKUST-QUANT-SOCIETY/quantcode --skill compose-plan-hkust-quant-society
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: compose:plan
Source: https://github.com/HKUST-QUANT-SOCIETY/quantcode/tree/main/.opencode/meta-skills/plan
Command: npx skills add https://github.com/HKUST-QUANT-SOCIETY/quantcode --skill compose-plan-hkust-quant-society

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning a feature spec into code without a plan leads to missed requirements, inconsistent types across tasks, and vague steps that stall implementation. This Skill converts a spec or requirements document into a complete, self-contained implementation plan that an engineer with zero codebase context can execute task by task. ## Core Features & Use Cases - Structured Plan Generation: Produces a plan document with a mandatory header (goal, architecture, tech stack, global constraints) and tasks broken into 2-5 minute steps following TDD: failing test, verify failure, minimal implementation, verify pass, commit. - Spec Coverage Enforcement: Each task declares which spec sections it covers, and a self-review checklist verifies every spec section maps to a task, no placeholders remain, and type signatures stay consistent across tasks. - Execution Handoff: After saving the plan to the plans directory, it routes execution to a subagent-per-task workflow or inline execution based on a saved user preference. - Use Case: Given a spec for a new API endpoint, generate a dated plan file where each task lists exact file paths, complete code blocks, test commands with expected output, and commit commands. ## Quick Start Ask the agent to use the compose:plan skill to turn your feature spec into a step-by-step TDD implementation plan saved in the plans directory.

Frequently Asked Questions about compose:plan

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

FAQPage Schema
How do I write an implementation plan from a feature spec?

Provide the spec and invoke the plan skill before touching code. It produces a markdown plan with a header covering goal, architecture, and tech stack, followed by tasks with exact file paths, complete code blocks, and TDD steps.

How to break a large feature into small coding tasks?

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. Fold setup and scaffolding into the task that needs them.

What makes an implementation plan fail during execution?

Plans fail when they contain placeholders like TBD or vague steps such as add error handling, reference undefined types, or omit exact file paths and commands. The self-review checklist scans for these issues and verifies spec coverage before handoff.

Should I execute a plan with subagents or inline?

Subagent execution gives each task a fresh context with two-stage review and suits plans with more than three independent tasks. Inline execution batches tasks with checkpoints and fits plans of three or fewer or tightly coupled tasks.

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 reviewable and independently deliverable.