playbooks

home / skills / chachamaru127 / claude-code-harness / planning

planning skill

/skills/planning

This skill helps convert ideas into executable Plans.md tasks, organize features, and prepare TDD-ready plans for efficient development.

npx playbooks add skill chachamaru127/claude-code-harness --skill planning

Review the files below or copy the command above to add this skill to your agents.

Files (4)
SKILL.md
3.4 KB
---
name: plan-with-agent
description: "アイデアをPlans.mdに落とし込む。夢を計画に変える魔法使い。Use when user mentions '/plan-with-agent', create a plan, organize tasks, feature planning, or TDD planning. Do NOT load for: implementation, reviews, or setup."
description-en: "Organize ideas into Plans.md. Wizard turning dreams into plans. Use when user mentions '/plan-with-agent', create a plan, organize tasks, feature planning, or TDD planning. Do NOT load for: implementation, reviews, or setup."
description-ja: "アイデアをPlans.mdに落とし込む。夢を計画に変える魔法使い。Use when user mentions '/plan-with-agent', create a plan, organize tasks, feature planning, or TDD planning. Do NOT load for: implementation, reviews, or setup."
allowed-tools: ["Read", "Write", "Edit", "Grep", "Glob", "Bash", "WebSearch", "Task"]
argument-hint: "[--ci]"
---

# Planning Skill

Organizes ideas and requirements, converting them into executable tasks in Plans.md.

## Quick Reference

- "**Create a plan**" → this skill
- "**Turn what we talked about into a plan**" → extract from conversation
- "**Want to organize what to build**" → start with hearing
- "**Plan with TDD**" → force TDD adoption
- "**CI/benchmark**" → `--ci` mode

## Deliverables

- **Plans.md** - Task list executable with `/work` (required)
- **Feature priority matrix** - Required/Recommended/Optional classification

## Usage

```bash
/plan-with-agent       # Interactive planning
/plan-with-agent --ci  # CI mode (non-interactive)
```

## Mode-specific Usage

| Mode | Command | Description |
|------|---------|-------------|
| **Solo mode** | `/plan-with-agent` | Claude Code alone: plan → execute → review |
| **2-agent mode** | `/plan-with-cc` (Cursor) | Plan with Cursor → Execute with Claude Code |

## Feature Details

| Feature | Reference |
|---------|-----------|
| **Execution Flow** | See [references/execution-flow.md](references/execution-flow.md) |
| **TDD Adoption** | See [references/tdd-adoption.md](references/tdd-adoption.md) |
| **Priority Matrix** | See [references/priority-matrix.md](references/priority-matrix.md) |

## Execution Flow Overview

1. **Step 0**: Check conversation context (extract from previous conversation or start fresh)
2. **Step 1**: Hearing what to build
3. **Step 2**: Increase resolution (max 3 questions)
4. **Step 3**: Technical research (WebSearch)
5. **Step 4**: Extract feature list
6. **Step 5**: Create priority matrix (Required/Recommended/Optional)
7. **Step 5.5**: TDD adoption judgment and test design
8. **Step 6**: Effort estimation (reference)
9. **Step 7**: Generate Plans.md with quality markers
10. **Step 8**: Guide next actions

## Auto-invoke Skills

| Skill | When to Call |
|-------|--------------|
| `setup` | **Call first** (executes adaptive setup) |
| `vibecoder-guide` | When user is non-technical |

## Quality Markers (Auto-assigned)

| Task Content | Marker | Effect |
|--------------|--------|--------|
| Auth/login feature | `[feature:security]` | Security checklist |
| UI component | `[feature:a11y]` | a11y check |
| Business logic | `[feature:tdd]` | TDD recommended |
| API endpoint | `[feature:security]` | Input validation |
| Bug fix | `[bugfix:reproduce-first]` | Reproduction test first |

## Next Actions

After planning:
- Start implementation with `/work`
- Or say "start from Phase 1"
- Adjust with "add {{feature}}" or "postpone {{feature}}"

Overview

This skill converts ideas and conversation into an executable Plans.md that drives development. It organizes requirements, prioritizes features, and produces task lists with quality markers and TDD guidance. Use it when you want a clear plan to hand off to the work cycle or to automate planning steps.

How this skill works

The skill inspects the current conversation context or prompts a short hearing to extract goals and constraints. It increases resolution with up to three clarifying questions, performs lightweight technical research when needed, extracts features, and builds a priority matrix (Required/Recommended/Optional). It then assigns quality markers, judges TDD adoption, estimates effort, and generates a Plans.md ready for execution with the work agent.

When to use it

  • You type or mention "/plan-with-agent" to start interactive planning.
  • You need feature breakdowns and an actionable Plans.md before coding.
  • You want TDD-oriented plans or explicit test-first tasks included.
  • You want prioritized features with Required/Recommended/Optional classification.
  • You need a CI-mode non-interactive plan (`--ci`) for automated pipelines.

Best practices

  • Start by summarizing the main goal in one sentence to focus the hearing phase.
  • Answer up to three clarifying questions concisely to keep planning efficient.
  • Indicate any non-negotiable constraints (security, compliance, tech stack) early.
  • Enable TDD adoption when business logic or complex features are present.
  • Use the generated Plans.md as the single source of truth for /work and subsequent review cycles.

Example use cases

  • Turn a product idea discussed in chat into a prioritized Plans.md with tasks and tests.
  • Generate a feature priority matrix and TDD test list for a new API endpoint.
  • Produce a CI-friendly plan (`/plan-with-agent --ci`) that automation can consume.
  • Create a small-scope plan for an MVP with Required vs Optional features and effort estimates.
  • Convert user stories into concrete tasks with quality markers like [feature:tdd] and [feature:security].

FAQ

What happens after the plan is generated?

You can start implementation with the work agent (`/work`), ask to modify or postpone features, or request additional research or estimates.

Can the skill force TDD?

Yes—during planning it will mark tasks for TDD adoption and generate test-first tasks when business logic or critical features are identified.