writing-plans

Generate implementation plans with file paths, code examples, and TDD tasks.

6|Updated Aug 19, 2025
One-click install
npx skills add https://github.com/lv416e/dotfiles --skill writing-plans-lv416e
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/lv416e/dotfiles/tree/main/dot_claude/skills/writing-plans
Command: npx skills add https://github.com/lv416e/dotfiles --skill writing-plans-lv416e

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Handing off complex development tasks to engineers, especially those unfamiliar with the codebase, can lead to misunderstandings and rework. This skill creates comprehensive, bite-sized implementation plans with zero-context assumptions, ensuring smooth execution.

Core Features & Use Cases

  • Zero-Context Planning: Crafts plans assuming the engineer has minimal domain knowledge and codebase context.
  • Bite-Sized Tasks: Breaks down implementation into small, actionable steps (2-5 minutes each) for clarity and manageability.
  • Complete Code Examples: Provides exact file paths, full code snippets, and precise verification commands.
  • TDD & Commit Guidance: Integrates Test-Driven Development (TDD) and frequent commit instructions directly into the plan.

Quick Start

The design for the new 'user-profile' feature is complete. Use the writing-plans skill to create a detailed implementation plan for the engineering team.

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 an engineering task?

Implementation plans break down finalized designs into bite-sized, actionable tasks with explicit file paths, complete code examples, and verification steps. Start with your design document, then structure each task as a 2–5 minute unit with test-driven development guidance and commit instructions for smooth handoff to engineers unfamiliar with the codebase.

What should I include in a task breakdown for engineers?

Task breakdowns require exact file locations, full code snippets, precise verification commands, and test-first instructions. Each step should be independently executable, reference relevant documentation, and include commit-ready guidance so engineers can verify work at each stage without domain knowledge or codebase context.

Can I use implementation plans for features with minimal codebase documentation?

Yes. Implementation plans assume zero-context knowledge and minimal domain familiarity, making them ideal for handing off complex features to engineers new to the project. Complete code examples and explicit file paths eliminate ambiguity and reduce rework.

How do implementation plans integrate testing and version control?

Test-driven development and commit instructions are embedded directly into each task step. Engineers write tests first, verify functionality using provided commands, then commit at natural boundaries, creating a clear audit trail and reducing integration friction.

What's the best way to structure a plan for a large feature rollout?

Decompose the feature into small, testable units ordered by dependency. Each unit gets its own task with code samples, test assertions, and commit scope. This approach enables parallel work, frequent verification, and incremental integration without blocking other engineers.