writing-plans

Convert approved specifications into executable implementation plans with ordered tasks.

139|7|Updated May 8, 2026
One-click install
npx skills add https://github.com/arbiterForge/codeArbiter --skill writing-plans-arbiterforge
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/arbiterForge/codeArbiter/tree/main/plugins/ca/skills/writing-plans
Command: npx skills add https://github.com/arbiterForge/codeArbiter --skill writing-plans-arbiterforge

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill turns an approved specification into a disciplined implementation plan so work can move from intent to execution without guesswork, missed criteria, or vague tasks.

Core Features & Use Cases

  • Acceptance Criterion Extraction: Captures every requirement from the approved spec and assigns stable IDs for coverage tracking.
  • Task Decomposition: Breaks work into small, path-specific tasks with concrete verification steps and dependency order.
  • Plan Governance: Enforces MVP slicing, bijective coverage proof, and clear handoff readiness before writing the plan file.
  • Use Case: A team approves a feature spec, then uses this Skill to produce a plan that is ready for implementation and resilient to mid-flight changes.

Quick Start

Use the writing-plans skill to convert the approved spec for this feature into a complete executable plan with ordered tasks and coverage proof.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I convert an approved specification into an executable implementation plan?

You can convert an approved specification by extracting acceptance criteria, decomposing work into path-specific tasks, ordering dependencies, and proving bijective coverage. This produces a disciplined implementation plan ready for execution without guesswork.

What is bijective coverage proof in task decomposition?

Bijective coverage proof in task decomposition ensures every extracted acceptance criterion maps to a specific task and vice versa. This mathematical validation prevents missed requirements and vague tasks before writing the final plan artifact.

How do I prepare a sprint plan from a feature specification?

To prepare a sprint plan from a feature specification, extract acceptance criteria with stable IDs, apply MVP slicing, and order task dependencies. This creates an executable plan resilient to mid-flight changes for team implementation.

Does task decomposition work with codeArbiter gate repositories?

Yes, task decomposition supports farm-enabled task orchestration in repositories using codeArbiter gates. The generated plan enforces clear handoff readiness and concrete verification steps compatible with these governance environments.

What is the best way to slice an MVP from a full feature specification?

The best way to slice an MVP from a feature specification is by extracting acceptance criteria, decomposing tasks path-specifically, and applying MVP slicing rules. This isolates the minimum viable subset while maintaining bijective coverage proof.

Why does my implementation plan have missing acceptance criteria?

Implementation plans miss acceptance criteria when they skip formal extraction with stable IDs or lack bijective coverage proof. Applying structured task decomposition ensures every requirement maps to a concrete, verifiable task before execution.