sdd openspec planner

When complex features fail during implementation, the root cause is often ambiguous requirements or lack of human oversight. This skill enforces a strict, spec-driven development (SDD) workflow using the OpenSpec framework. It prevents "autopilot" errors by requiring architectural research and human approval at every phase.

What it does

• Multi-artifact generation creates a complete set of planning files including proposals, technical designs, and task checklists.
• Automated research inventories existing features, dependencies, and data flows before proposing any changes.
• Execution guardrails embed non-negotiable human-in-the-loop gates directly into the task files for the implementation agent.
• Delta specifications define precise behavior changes using Given, When, and Then scenarios.
• Architecture assessment evaluates SOLID principles, design patterns, and TDD feasibility for every change.

How it works

1. Discovery: The agent researches the codebase and classifies the request as a bug fix, refactor, or new feature.
2. Artifact Creation: It writes the proposal.md, design.md, specs/, and tasks.md files to the openspec/ directory.
3. Guardrail Embedding: A verbatim set of execution rules is injected into the checklist to ensure the next agent pauses for approval.
4. Human Review: You review the generated artifacts and provide feedback or approval before any code is touched.

Frameworks & tools

This skill implements the OpenSpec SDD framework. It is designed to work with any language or framework, specifically targeting environments where an implementation agent (like Claude Code or Cursor) will execute the resulting Markdown-based tasks.

Why this beats prompting it yourself

Generic prompts often lead to agents jumping straight into code, missing edge cases or breaking existing patterns. This skill forces a professional SDD workflow that produces permanent documentation and prevents autonomous agents from bypassing your approval gates.

Use cases

• Planning complex feature additions in large, unfamiliar codebases.
• Managing safe refactoring projects that must preserve observable behavior.
• Documenting technical debt and migration paths with clear success criteria.
• Orchestrating multi-agent handoffs between a planner and an implementer.

Known limitations

This skill only produces plans and artifacts; it never writes or modifies application code. It requires an environment that supports file-writing tools.