cmd-plan

Create a decision-ready coding plan with risk-based TDD guidance.

1|Updated Jan 6, 2026
One-click install
npx skills add https://github.com/yanun0323/.codex --skill cmd-plan
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: cmd-plan
Source: https://github.com/yanun0323/.codex/tree/main/skills/cmd-plan
Command: npx skills add https://github.com/yanun0323/.codex --skill cmd-plan

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This skill helps teams create a concise, decision-ready plan for coding tasks by applying task-contract thinking, risk classification, and risk-based TDD with verification-first acceptance criteria to reduce ambiguity before implementation.

Core Features & Use Cases

  • Produces a concise, executable plan mapping objectives to concrete steps.
  • Records up to three explicit assumptions and identifies impacted files or modules.
  • Defines risk levels, TDD mode, and verification checks to guide development and validation.

Quick Start

Provide a concise, executable plan for a given coding task in one sentence.

Frequently Asked Questions about cmd-plan

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

FAQPage Schema
How do I create a concise coding plan before starting implementation?

To create a concise coding plan, capture a task-contract snapshot, define up to three explicit assumptions, map objectives to concrete steps, and set risk-based TDD verification criteria to reduce ambiguity before writing code.

What is task-contract planning for software engineering tasks?

Task-contract planning records a snapshot of objectives, assumptions, impacted files, and acceptance criteria to establish a decision-ready boundary and reduce ambiguity before coding begins.

How do I apply risk-based TDD to define verification criteria?

Apply risk-based TDD by classifying risk levels for the coding task, selecting a corresponding TDD mode, and defining measurable verification checks that validate acceptance criteria before implementation.

When do I need a decision-ready execution plan for coding tasks?

You need a decision-ready execution plan when coding tasks require upfront risk assessment, clear scope definition, and explicit verification criteria to prevent ambiguity during the development process.

What's the best way to define scope and assumptions for a development task?

The best way to define scope is to document up to three explicit assumptions and identify impacted files or modules within a task-contract snapshot, ensuring the execution plan remains focused and measurable.

Can I use this planning approach for tasks without upfront risk assessment?

This planning approach is designed for tasks requiring risk assessment and scope definition; without upfront risk classification, the risk-based TDD guidance and measurable acceptance criteria provide limited value.