writing-plans

Draft implementation plans with tasks, file changes, tests, and milestones.

Updated Apr 14, 2026
One-click install
npx skills add https://github.com/gerald-ica/opencode-config-snapshot --skill writing-plans-gerald-ica
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/gerald-ica/opencode-config-snapshot/tree/main/opencode/skills/writing-plans
Command: npx skills add https://github.com/gerald-ica/opencode-config-snapshot --skill writing-plans-gerald-ica

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill helps teams convert vague feature specs into thorough, step-by-step implementation plans, reducing ambiguity and rework before coding begins.

Core Features & Use Cases

  • Structured planning: generate end-to-end task lists with explicit file touches, tests, and documentation.
  • TDD-aligned planning: ensures tests drive the plan and verify progress.
  • DRY/YAGNI guidance: promotes minimal, reusable plans with clear milestones.
  • Use Case: imagine you need to implement a user authentication flow; the plan would specify the necessary modules, tests, and docs, and map them to concrete file changes.

Quick Start

Provide a feature name and a high-level spec to generate a complete implementation plan.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I turn a feature spec into an implementation plan with exact file paths and tests?

Task planning for multi-step features breaks work into end-to-end task lists with explicit file touches, tests, and documentation. It generates comprehensive implementation plans that specify necessary modules, tests, and docs mapped to concrete file changes and milestones.

How does TDD-aligned planning work for new feature implementation?

TDD-aligned planning ensures tests drive the implementation plan and verify progress. It structures feature development by defining test requirements upfront, promoting minimal, reusable plans with clear milestones while adhering to DRY and YAGNI principles.

What's the best way to structure multi-step software features across code, tests, and documentation?

The best way to structure multi-step features is generating a comprehensive implementation plan that details tasks, file changes, tests, and milestones. This approach satisfies plan structure requirements with exact file paths, concrete steps, and named commits while adhering to DRY, YAGNI, and TDD principles.

Does implementation planning work for typical engineering tasks like user authentication flows?

Implementation planning works for typical engineering tasks including user authentication flows. Providing a feature name and high-level spec generates a complete plan specifying necessary modules, tests, and docs mapped to concrete file changes and deployment considerations.

When do I need detailed task planning with named commits and milestones?

Detailed task planning with named commits and milestones is needed when converting vague feature specs into thorough, step-by-step implementation plans. It reduces ambiguity and rework before coding begins by satisfying plan structure requirements with exact file paths and concrete steps.