Use when executing implementation plans with independent tasks in the current session - dispatches fresh subagent for each task with code review between tasks, enabling fast iteration with quality gates
Executes implementation plans by dispatching fresh subagents for each task with code review between tasks. Use when staying in the current session with independent tasks to enable fast iteration with quality gates.
/plugin marketplace add pproenca/dot-claude-old/plugin install workflow@dot-claudeThis skill is limited to using the following tools:
Execute plan by dispatching fresh subagent per task, with code review after each.
Core principle: Fresh subagent per task + review between tasks = high quality, fast iteration
vs. Executing Plans (parallel session):
When to use:
When NOT to use:
| Complexity | Target Tool Uses | Target Tokens |
|---|---|---|
| TRIVIAL | 2-3 | <3k |
| SIMPLE | 4-6 | <8k |
| MODERATE | 8-15 | <20k |
| COMPLEX | No hard limit | Reasonable |
Why this matters: A "Remove orphaned file" task should NOT use 11 tools and 27k tokens.
Before loading plan:
Check current git context:
git branch --show-current
git worktree list
If on main/master without worktree: Use AskUserQuestion:
Question: "You're on the main branch. Subagents should work in an isolated worktree to protect main."
Header: "Isolation"
Options:
- "Set up worktree": Create isolated workspace first (recommended)
- "Continue on main": I understand the risk, proceed anyway
If "Set up worktree": Use workflow:git-worktrees skill first
If "Continue on main": Proceed with warning logged
If already in worktree or feature branch: Proceed normally
Read plan file, create TodoWrite with:
Check task Complexity tag before dispatching:
Do NOT dispatch a subagent. Execute directly as parent agent:
git diffRationale: Subagent overhead (context loading, skill loading) exceeds task value.
Dispatch lightweight subagent:
Task tool (general-purpose):
model: haiku
description: "Implement Task N: [task name]"
prompt: |
You are implementing Task N from [plan-file]. This is a SIMPLE task.
Work efficiently:
1. Read the task
2. If modifying code: write a simple test first
3. Make the change
4. Verify tests pass
5. Commit
6. Report back briefly
EFFICIENCY TARGET: 4-6 tool uses maximum.
Skip skill loading unless absolutely necessary.
ANTI-PATTERNS TO AVOID:
- Reading files not mentioned in task
- Using Glob/Grep to "verify" obvious facts
- Loading skills you don't need
- Re-reading the plan file multiple times
Work from: [directory]
Dispatch standard subagent:
Task tool (general-purpose):
model: sonnet
description: "Implement Task N: [task name]"
prompt: |
You are implementing Task N from [plan-file].
Read that task carefully. Your job is to:
1. Use core:tdd skill - write failing test FIRST, then implement
2. Implement exactly what the task specifies
3. Use core:verification skill - verify all tests pass
4. Commit your work
5. Report back
EFFICIENCY TARGET: 8-15 tool uses.
ANTI-PATTERNS TO AVOID:
- Reading files not mentioned in task
- Using Glob/Grep to "verify" obvious facts
- Loading skills you don't need
- Re-reading the plan file multiple times
Work from: [directory]
Report: What you implemented, test results, files changed
Dispatch thorough subagent:
Task tool (general-purpose):
model: sonnet
description: "Implement Task N: [task name]"
prompt: |
You are implementing Task N from [plan-file]. This is a COMPLEX task.
Read that task carefully. Your job is to:
1. Use core:tdd skill - write failing test FIRST, then implement
2. Implement exactly what the task specifies
3. Use core:verification skill - verify all tests pass with actual output
4. Consider edge cases and error handling
5. Commit your work
6. Report back thoroughly
IMPORTANT:
- You MUST use core:tdd. Write the test first, see it fail.
- You MUST use core:verification before reporting completion.
Work from: [directory]
Report: What you implemented, what you tested, test results (with output),
files changed, any issues or concerns
Subagent reports back with summary of work.
Note: Subagents implement individual tasks only. The parent (you) handles finish-branch after ALL tasks complete.
Review strategy based on task complexity:
No review needed - parent already verified git diff during execution.
Parent reviews subagent report + git diff. No code-reviewer dispatch.
git diff --stat [BASE_SHA]..[HEAD_SHA]
Check: Does the change match the task? Any unintended changes?
Dispatch code-reviewer subagent:
Use template at plugins/methodology/review/templates/code-reviewer-dispatch.md.
Task tool (review:code-reviewer):
description: "Review Task N implementation"
prompt: |
Review the implementation against requirements.
## Context
- **What Was Implemented:** [from subagent's report]
- **Requirements/Plan:** Task N from [plan-file]
- **Description:** [task summary]
## Git Range
- **Base:** [commit before task]
- **Head:** [current commit]
First run: git diff --stat [BASE_SHA]..[HEAD_SHA]
Then review against plugins/methodology/review/references/code-review-standards.md
Dispatch thorough code-reviewer subagent with model: opus for critical analysis.
Code reviewer returns: Strengths, Issues (Critical/Important/Minor), Assessment
If issues found:
Dispatch follow-up subagent if needed:
"Fix issues from code review: [list issues]"
After all tasks complete, dispatch final code-reviewer:
After final review passes:
Skill("workflow:finish-branch")This step is NOT optional. The mandatory final todo ensures this step is visible throughout execution.
You: I'm using Subagent-Driven Development to execute this plan.
[Check git context: on main branch, no worktree]
[AskUserQuestion: "You're on the main branch. Subagents should work in an isolated worktree to protect main."]
User: "Set up worktree"
[Use workflow:git-worktrees skill to create feature/my-feature worktree]
[Load plan, create TodoWrite with tasks + "Complete development (finish-branch)"]
Task 1: Hook installation script
[Dispatch implementation subagent]
Subagent: Implemented install-hook with tests, 5/5 passing
[Get git SHAs, dispatch code-reviewer]
Reviewer: Strengths: Good test coverage. Issues: None. Ready.
[Mark Task 1 complete]
Task 2: Recovery modes
[Dispatch implementation subagent]
Subagent: Added verify/repair, 8/8 tests passing
[Dispatch code-reviewer]
Reviewer: Strengths: Solid. Issues (Important): Missing progress reporting
[Dispatch fix subagent]
Fix subagent: Added progress every 100 conversations
[Verify fix, mark Task 2 complete]
...
[After all tasks]
[Dispatch final code-reviewer]
Final reviewer: All requirements met, ready to merge
[Mark "Complete development (finish-branch)" as in_progress]
You: I'm using the finish-branch skill to complete this work.
[Use Skill("workflow:finish-branch")]
[Present 4 options: merge, PR, keep, discard]
[User chooses option, execute it]
[Mark "Complete development (finish-branch)" as completed]
Done!
vs. Manual execution:
vs. Executing Plans:
Cost:
Never:
If subagent fails task:
Required workflow skills:
Subagents must use:
Alternative workflow:
Templates:
plugins/methodology/review/templates/code-reviewer-dispatch.mdCreating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.
Applies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.
Create beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.