writing-plans

Plan multi-step software implementation strategies with atomic tasks and deterministic storage in docs/plans.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/victorqnguyen/victors-architecture --skill writing-plans-victorqnguyen
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/victorqnguyen/victors-architecture/tree/main/packages/core/skills/writing-plans
Command: npx skills add https://github.com/victorqnguyen/victors-architecture --skill writing-plans-victorqnguyen

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Plan and document comprehensive implementation strategies before coding to avoid scope creep, miscommunication, and rework.

Core Features & Use Cases

  • Map out files and interfaces before implementation.
  • Break tasks into atomic steps with clear boundaries and expected outcomes.
  • Ensure repeatable planning for complex features and multiple subsystems.

Quick Start

Create a comprehensive implementation plan for a feature by outlining tasks, files, tests, and docs, then save the plan to docs/plans/YYYY-MM-DD-<feature-name>.md.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I create an implementation plan for a multi-step software feature?

To create an implementation plan, outline files, tests, and atomic tasks with clear boundaries, then save the strategy to docs/plans/YYYY-MM-DD-feature-name.md. This ensures repeatable planning for complex features.

What is task decomposition and when do I need it for software development?

Task decomposition breaks requirements into atomic steps with expected outcomes before coding. It is needed for multi-step software tasks to avoid scope creep, miscommunication, and rework across subsystems.

How do I map out file structures and interfaces before coding?

Map out file structures and interfaces by planning comprehensive implementation strategies that coordinate files, tests, and docs across a single subsystem, storing the plan-first workflow deterministically in markdown.

Does a plan-first workflow work for coordinating multiple subsystems?

A plan-first workflow works for coordinating multiple subsystems by breaking tasks into atomic steps with standard headers and clear boundaries, ensuring repeatable planning for complex features and subsystem coordination.

What's the best way to document implementation strategies to avoid scope creep?

The best way to document implementation strategies is outlining tasks, files, tests, and docs into atomic steps, saving the comprehensive plan to a deterministic markdown storage path to prevent scope creep and rework.

Why should I not start coding before planning a complex feature?

Starting coding before planning risks scope creep, miscommunication, and rework. Planning comprehensive implementation strategies first ensures atomic tasks, clear boundaries, and expected outcomes are established.