writing-plans

Generate implementation plans with file paths, code examples, and testing steps.

3|Updated Nov 19, 2025
One-click install
npx skills add https://github.com/seanGSISG/crispy-claude --skill writing-plans-seangsisg
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/seanGSISG/crispy-claude/tree/main/.claude/skills/writing-plans
Command: npx skills add https://github.com/seanGSISG/crispy-claude --skill writing-plans-seangsisg

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Vague or incomplete implementation plans lead to confusion, rework, and delays, especially for engineers unfamiliar with the codebase. This skill ensures comprehensive, bite-sized plans for efficient execution.

Core Features & Use Cases

  • Bite-Sized Task Granularity: Breaks down implementation into small, actionable steps (2-5 minutes each), including TDD cycles and commit instructions.
  • Zero-Context Documentation: Provides exact file paths, complete code examples, and precise commands with expected outputs, assuming minimal domain knowledge.
  • Execution Handoff: Offers clear next steps, recommending plan decomposition for parallel execution or sequential execution for simpler plans.

Quick Start

Use the writing-plans skill to create an implementation plan for the 'user-profile-management' feature based on the approved design.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I create a detailed implementation plan for a feature with no codebase context?

Implementation plans break down features into bite-sized tasks (2-5 minutes each) with exact file paths, complete code examples, precise commands, and testing steps. This Skill generates comprehensive plans assuming zero domain knowledge, saving output to docs/plans/YYYY-MM-DD-<feature-name>.md for seamless handoff to engineers.

What should a development plan include for TDD and complex integrations?

A development plan for TDD and integrations must include concrete file changes, unit and integration tests, documentation updates, DRY and YAGNI principles, exact commands with expected outputs, commit guidance, and verification criteria. This ensures consistent execution across architectural changes and feature scoping.

Can I use implementation plans for architectural changes across multiple files?

Yes. Implementation plans handle architectural changes by decomposing them into granular, sequential tasks with file paths, code examples, and testing cycles. Plans recommend parallel execution tracks when appropriate and provide clear handoff points for complex integrations.

How do I break down a large feature into executable tasks?

Task breakdown uses bite-sized granularity (2-5 minute cycles) with TDD workflows, exact file modifications, and commit instructions. Each step includes expected outputs and verification criteria, enabling both sequential execution for simpler features and parallel decomposition for larger efforts.

What's the difference between vague plans and executable implementation documentation?

Executable plans eliminate confusion and rework by providing zero-context documentation: exact file paths, complete code examples, precise terminal commands, testing steps, and verification criteria. Vague plans lack this specificity, causing delays for engineers unfamiliar with the codebase.

Do implementation plans work for project management and workflow documentation?

Yes. Plans satisfy project management workflows by documenting implementation steps, dependencies, and testing phases with concrete examples and commit guidance. They serve as reference documentation for design approval and team handoff, supporting both planning and execution phases.