writing-plans

Generate step-by-step implementation plans with file mapping and test-driven development steps.

6|2|Updated Jan 6, 2026
One-click install
npx skills add https://github.com/acaprino/anvil-toolset --skill writing-plans-acaprino
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/acaprino/anvil-toolset/tree/main/plugins/ai-tooling/skills/writing-plans
Command: npx skills add https://github.com/acaprino/anvil-toolset --skill writing-plans-acaprino

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill tackles the challenge of translating complex requirements or brainstormed ideas into clear, step-by-step implementation plans, ensuring that even developers with no prior context can execute tasks efficiently and accurately.

Core Features & Use Cases

  • Detailed Task Decomposition: Breaks down large features into bite-sized, manageable tasks.
  • File Structure Guidance: Maps out file creation and modification with precise paths.
  • Test-Driven Development Integration: Includes steps for writing failing tests, verifying failures, implementing code, and verifying success.
  • Commit Strategy: Specifies commit messages and staging for each step.
  • Use Case: After brainstorming a new user authentication flow, use this Skill to generate a detailed plan outlining the creation of API endpoints, database schema changes, frontend components, and corresponding unit tests.

Quick Start

Use the writing-plans skill to generate an implementation plan for the new user profile editing feature.

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 step-by-step implementation plan for a complex software feature?

An implementation plan translates complex requirements into clear, step-by-step task breakdowns. It structures software development with detailed file mapping, test-driven development steps, and commit guidance to ensure developers can execute tasks efficiently without prior context.

How do I break down a large software development task into manageable units?

Task decomposition breaks down large features into bite-sized, manageable units. It maps out precise file creation and modification paths, ensuring developers with no prior context can execute complex software development tasks efficiently and accurately.

Can I integrate test-driven development steps directly into my task breakdown process?

Yes, you can integrate test-driven development directly into task breakdowns. The process includes specific steps for writing failing tests, verifying failures, implementing code, and verifying success to ensure precise task execution and context-rich instructions.

What is the best way to map out file structure changes for a new feature implementation?

The best way to map file structure changes is by generating detailed file creation and modification paths within an implementation plan. This ensures clarity in complex feature development by providing precise guidance on where code should be written or updated.

Does this implementation planning approach include guidance on commit strategies?

Yes, the implementation planning approach includes commit strategy guidance. It specifies exact commit messages and staging instructions for each step of the task breakdown, ensuring structured and logical version control throughout complex feature development.

How do I translate brainstormed ideas into actionable software development plans?

To translate brainstormed ideas into actionable plans, structure them with detailed task decomposition, file structure guidance, and test-driven development steps. This addresses the challenge of ensuring developers can execute tasks efficiently and accurately.