writing-plans

Generate detailed implementation plans with exact file paths and code examples.

4|Updated Dec 7, 2020
One-click install
npx skills add https://github.com/charly3pins/dotfiles --skill writing-plans-charly3pins
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/charly3pins/dotfiles/tree/main/.config/opencode/skills/writing-plans
Command: npx skills add https://github.com/charly3pins/dotfiles --skill writing-plans-charly3pins

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Incomplete or vague implementation plans lead to confusion, errors, and delays, especially for engineers unfamiliar with the codebase or domain, hindering efficient development.

Core Features & Use Cases

  • Bite-Sized Task Granularity: Breaks down implementation into small, actionable steps (2-5 minutes each) with exact commands and expected outputs.
  • Zero-Context Assumption: Creates comprehensive plans with exact file paths and complete code examples, assuming minimal domain knowledge.
  • Structured Handoff: Offers clear execution options (subagent-driven or parallel session) after plan completion.
  • Use Case: After a design is finalized, use this skill to generate a detailed, step-by-step implementation plan that any engineer, even with zero codebase context, can follow to build the feature correctly.

Quick Start

I have a complete design for a new feature. Help me write a detailed implementation plan for it.

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 new feature?

An implementation plan breaks down feature development into small, actionable steps with exact file paths, complete code examples, and verification procedures. This Skill generates comprehensive, step-by-step plans that engineers with zero codebase context can follow to execute features correctly, ensuring clarity and reducing errors.

What should a task breakdown include for seamless execution?

Task breakdowns should specify exact file references, runnable code samples, explicit test instructions, and expected outputs for each step. This Skill structures plans into 2-5 minute tasks aligned with DRY, YAGNI, and TDD principles, making workflows repeatable and commit-friendly across team handoffs.

Can I use implementation planning for features I'm designing from scratch?

Yes. After finalizing a design, this Skill generates detailed implementation plans assuming minimal domain knowledge, providing complete code examples and exact commands so any engineer can build the feature correctly without codebase familiarity or extensive guidance.

Why do vague implementation plans cause delays in development?

Vague plans leave engineers guessing about file structure, code patterns, and testing strategy, leading to rework, inconsistency, and context-switching overhead. Detailed plans with precise file paths, runnable samples, and verification steps eliminate ambiguity and accelerate execution.

How does task granularity improve feature delivery?

Breaking features into small, bounded tasks with explicit commands and expected outputs reduces cognitive load and decision paralysis. Engineers execute predictable steps, verify progress immediately, and maintain momentum, turning complex implementations into manageable workflows.

What happens after an implementation plan is complete?

After plan generation, execution options include subagent-driven implementation or parallel session handoff. The structured plan with exact file references and code samples becomes a repeatable, commit-friendly workflow any team member can execute independently.