Skip to content
Skills Library
AI & agents · Learning & explanation

clear-command-driven-dev

/clear-command-driven-dev

Explains a development workflow methodology: plan with Plan Mode, copy the plan to clipboard, execute TODOs one at a time with /clear between each task, and update the plan when new information emerges. Use this skill when the user asks about "clear command driven development", "clear-driven workflow", "how to structure Claude Code sessions", or wants an overview of the plan-clear-execute cycle. For creating a new plan, see /create-plan. For updating an existing plan, see /update-plan.

Licence
MIT
Last repository change
14.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 14.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Explains a development workflow methodology: plan with Plan Mode, copy the plan to clipboard, execute TODOs one at a time with /clear between each task, and update the plan when new information emerges. Use this skill when the user asks about "clear command driven development", "clear-driven workflow", "how to structure Claude Code sessions", or wants an overview of the plan-clear-execute cycle. For creating a new plan, see /create-plan. For updating an existing plan, see /update-plan.

Triggers from the description

clear command driven developmentclear-driven workflowhow to structure Claude Code sessions
Original author description

Explains a development workflow methodology: plan with Plan Mode, copy the plan to clipboard, execute TODOs one at a time with /clear between each task, and update the plan when new information emerges. Use this skill when the user asks about "clear command driven development", "clear-driven workflow", "how to structure Claude Code sessions", or wants an overview of the plan-clear-execute cycle. For creating a new plan, see /create-plan. For updating an existing plan, see /update-plan.

How it works

  1. Core Principles
  2. The Cycle
  3. Related Skills
  4. Execution Tips
  5. Anti-Patterns
Original SKILL.md headings · 68 lines, 429 words
SKILL.md preview
---
name: clear-command-driven-dev
description: >
  Explains a development workflow methodology: plan with Plan Mode, copy the
  plan to clipboard, execute TODOs one at a time with /clear between each task,
  and update the plan when new information emerges. Use this skill when the user
  asks about "clear command driven development", "clear-driven workflow",
  "how to structure Claude Code sessions", or wants an overview of the
  plan-clear-execute cycle. For creating a new plan, see /create-plan.
  For updating an existing plan, see /update-plan.
---

# Clear Command Driven Development

A workflow methodology: persist Plan Mode output externally, execute TODOs
one at a time with `/clear` between each, and continuously update the plan
as new information emerges. The 1M token context window is irrelevant —
small, focused context produces better results.

## Core Principles

1. **Plan first, code later** — Always start in Plan Mode to design before implementing
2. **Externalize memory** — Your note app is the persistent store; Claude's context is ephemeral
3. **One TODO, one session** — Each `/clear` resets context; each task gets full attention
4. **Living plans** — Plans are updated as implementation reveals new information

## The Cycle

```
Plan Mode ──→ Copy to clipboard ──→ Paste into your notes
                                          │
                ┌─────────────────────────┘
                ▼
         Pick a TODO item
                │
                ▼
         /clear ──→ Paste TODO + minimal context ──→ Implement
                │                                        │
                │              ┌─────────────────────────┘
                │              ▼
                │       Discovered something new?
                │         Yes ──→ /update-plan ──→ Update notes ──→ Commit ──→ /clear
                │          No ──→ Commit ──→ Mark TODO [x] ──→ /clear
                │              │
                └──────────────┘
```

## Related Skills

| Skill | When to use |
|-------|-------------|
| `/create-plan` | Start a new plan for a feature or task |
| `/update-plan` | Revise an existing plan based on new findings |

## Execution Tips

- **Context loading**: When starting a TODO, provide only what Claude needs —
  the specific task (including its "Done when" and "Verify"), its target files,
  relevant references, and any shared decision table rows it cites. Do not paste the entire plan.
- **CLAUDE.md synergy**: Project-wide conventions belong in CLAUDE.md; task-level
  planning lives in your external notes. Do not duplicate.
- **Verify before commit**: Run the TODO's "Verify" step and confirm each
  "Done when" item holds before committing. Reviewers check the change against
  the same list.
- **Commit cadence**: Commit after each TODO completion, before `/clear`.
- **Update before clear**: If you discover something unexpected, run `/update-plan`
  while the context is still available, then `/clear` after committing.
- **Granularity**: Each TODO item should be completable in a single Claude Code
  session (roughly 10–30 minutes of implementation).

## Anti-Patterns

- Pasting the entire plan into every session (defeats the purpose of `/clear`)
- Skipping the plan update phase when encountering surprises
- Mixing layers in one TODO (DDL and application code together are hard to review)
- PRs with more than one purpose (if the heading needs "and", split the PR)
- Making TODO items too large (split a big layer change by feature within that layer)
- Keeping stale plans — always reflect reality in your notes

Versions

The database has no other skills named clear-command-driven-dev.

Database snapshot: 13.11.2026 · package version 2e9471852c3e (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90plan-loop
    Plan work with the user in a PLAN.md, then implement it step by step, with /clear once the context fills up. Use before creating a plan, when the user mentions a PLAN.md, or when resuming work after /clear.
  • 100plan-execute
    Use when the user says "/plan-execute", "plan execute", "implement plan", or "execute plan" and provides a finalized plan file path to carry out. Claude orchestrates, Codex writes code, Claude reviews, and Codex fixes issues until the quality bar is met.
  • 90deep-plan
    The enforced plan → clear → execute flow — think with full context, write the plan to a file, then execute from a fresh session that reads only the plan. Use when the user says "/deep-plan", "plan this properly", "let's not burn context", "execute PLAN-<anything>.md" (that…
  • 95meta-command-development
    Use when the user asks to ”create a slash command”, ”add a command”, or ”write a custom command” for Claude Code.
  • 98exec
    Execute plan tasks sequentially using subagents. Use when user says 'exec', 'execute plan', 'run plan', or wants to implement a plan file task by task with isolated subagents.
  • 95command-dev
    Use this skill when creating or refining custom Claude Code slash commands. Slash commands are user-invoked reusable prompts that can accept arguments, reference files, and execute bash operations. Helps design command syntax, argument handling, file references, bash execution,…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.