writing-plans

Create detailed implementation plans with file mapping and test commands.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/diegocondo10/sinai-intranet-backend --skill writing-plans-diegocondo10
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/diegocondo10/sinai-intranet-backend/tree/main/.agents/skills/writing-plans
Command: npx skills add https://github.com/diegocondo10/sinai-intranet-backend --skill writing-plans-diegocondo10

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill turns a spec or requirement into a clear, implementation-ready plan before code is changed, reducing ambiguity for engineers who need exact file targets, test strategy, and commit sequencing.

Core Features & Use Cases

  • File Structure Mapping: Identifies which files will be created or modified and what each file is responsible for.
  • Atomic Task Breakdown: Splits work into small, test-first steps with explicit verification and commit checkpoints.
  • Plan Review Workflow: Includes chunking guidance and a reviewer loop to keep plans complete and aligned with scope.
  • Use Case: Use it when a feature spans multiple files or subsystems and you need a handoff that another engineer can execute with minimal context.

Quick Start

Ask the writing-plans skill to produce a step-by-step implementation plan for your spec, including exact files, tests, and commit checkpoints.

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 from a feature spec?

Creating an implementation plan from a feature spec involves decomposing requirements into atomic tasks, mapping exact file paths for modifications, and defining test strategies with clear commit checkpoints before writing code.

What is task decomposition for multi-file engineering features?

Task decomposition for multi-file engineering features is the process of breaking down cross-file requirements into small, test-first steps with explicit verification, file mapping, and execution handoff for reliable agentic implementation.

How do I structure a code handoff for another engineer?

Structuring a code handoff requires providing exact file targets, atomic checklist steps, testing strategy, and chunked plan review so another engineer can execute the implementation with minimal context.

Does this approach work for planning test strategies before coding?

Yes, planning test strategies before coding is supported by generating step-by-step plans that include explicit verification steps and clear test commands alongside file structure mapping and commit checkpoints.

When do I need to map file structures for implementation planning?

You need to map file structures for implementation planning when a feature spans multiple files or subsystems, requiring you to identify which files will be created or modified and what each file is responsible for.

What is the best way to review an implementation plan for scope alignment?

The best way to review an implementation plan for scope alignment is to use chunking guidance and a reviewer loop, ensuring the plan remains complete and aligned with the original spec before any code changes occur.