What does this skill do, and when should you use it?
This skill guides an AI agent to automate the implementation of pre-written plans by delegating each task to a fresh subagent and applying two-stage (spec compliance and code quality) reviews. It emphasizes using a fresh subagent per task to avoid context pollution and ensures spec adherence through structured checks. It integrates TDD practices and provides clear step-by-step instructions, task granularity guidelines, and red flags. The skill is part of the DojoAgents monorepo, licensed under MIT, and is available for Linux, macOS, and Windows.
Reads a plan file and extracts all tasks into a todo list. For each task, sequentially dispatches three subagents: an implementer (following TDD), a spec compliance reviewer, and a code quality reviewer. Handles questions from subagents and review feedback, looping as needed until passed. After all tasks, dispatches a final integration reviewer, runs the full test suite, and commits changes. It also provides guidance on task granularity and red flags.
- A developer has a feature plan (e.g., from the writing-plans skill) and wants to implement it systematically, ensuring each task meets spec.
- A team wants to automate code review and testing while parallelizing independent tasks.
- Working in a large codebase, you need clean contexts per task to avoid accumulated errors.
- You want to ensure both spec compliance and code quality are verified before merging code.
How do you install this skill?
- The skill may auto-commit changes to git, requiring user confirmation or rollback capability.
- The skill may rely on external services (e.g., data sources), confirm network reachability, especially for mainland-China users.
- Static review did not verify actual runnability; test in a controlled environment.
- Shell / CLI
- Local filesystem
Clone or download the entire DojoAgents collection from GitHub. The skill is located at dojoagents/skills/built_in/subagent-driven-development/SKILL.md. Copy it into your agent's skills directory.
tmp="$(mktemp -d)"
git clone --depth 1 https://github.com/Alpha-Dojo/DojoAgents.git "$tmp"
mkdir -p ~/.claude/skills
cp -R "$tmp/dojoagents/skills/built_in/subagent-driven-development" ~/.claude/skills/
rm -rf "$tmp"Generated from the source repository and skill path; it copies only this skill's folder. If the author's install steps above differ, follow those first. To scope it to one project, replace ~/.claude/skills with that project's .claude/skills.
How do you use this skill?
Once installed, send your agent any of these to trigger it:
- Execute the plan from docs/plans/feature-plan.md using the subagent-driven development process.
Ensure you have an implementation plan (from writing-plans or user requirements). Invoke the skill in a subagent-capable environment (like Claude Code) with the plan file path. The skill will guide you through delegating subagents, reviewing, and validating. Example prompt: 'Execute the plan from docs/plans/feature-plan.md using the subagent-driven development process.'
What are this skill's strengths and limitations?
- Fresh subagent per task prevents context pollution and keeps focus.
- Two-stage review (spec then quality) catches issues early.
- Includes explicit red flags and issue-handling guidance.
- Integrates TDD practices.
- Provides a repeatable workflow for team consistency.
- Requires a subagent-capable platform (like Claude Code); standard Agent Skills clients may not support it natively.
- Multiple subagent invocations per task increase latency and cost.
- Some details are unspecified: how to source the plan, exact delegation mechanics, and handling of subagent failures.
- No built-in test suite.
- Documentation assumes Claude Code's delegate_task; other platforms may need adaptation.
How does this skill compare with similar options?
Side by side with related skills; every score comes from the same FSRS standard.
| Skill | FS score | Stars | Last updated | License |
|---|---|---|---|---|
| Subagent-Driven Development this page | 46 · Use with care | ★ 3.2k | 17d ago | Apache-2.0 |
| Plan Execution Orchestrator | 51 · Use with care | ★ 98k | 3d ago | Apache-2.0 |
| Continuous Code Review | 53 · Use with care | ★ 297k | 16d ago | MIT |
| Two-Axis Code Review | 53 · Use with care | ★ 281k | 3d ago | MIT |
| Pull Request Code Review ✓ OpenAI · Official | 33 · Not recommended | ★ 128k | 3d ago | Apache-2.0 |
How did FollowSkills review this skill?
Evidence shows the skill requires subagents to execute in a sandboxed environment, use explicit toolsets, and includes safeguards like avoiding scope creep and not skipping reviews. However, user confirmation steps, data-flow disclosure, and rollback mechanisms are missing, and the skill may auto-commit changes. Deductions for these gaps, score 10.
The skill details step-by-step process with example code and error handling guidance, but lacks automated tests or execution verification, and static review cannot confirm runnability. Deductions for these gaps, score 8.
The skill clearly defines target audience and scenarios, including when to use and avoid, and integrates with other skills like writing-plans. However, it does not mention Chinese-language support or mainland-China network reachability, causing deductions, score 10.
The skill is well-structured with version, author, license, and changelog, but lacks installation/dependency notes and known-limitations section. Deductions for these, score 9.
The skill provides detailed example workflow and expected outputs, but no actual results verification and marginal value not compared to manual execution. Deductions for these, score 6.
The skill has only documentation and examples, no third-party execution evidence or test results, and static review cannot independently verify. Deductions for these, score 3.
Open a dimension to read why it scored that way
Evidence confidence：Low — Mostly static review, author material or a limited demo; useful for discovery, not high-risk decisions.
See the full review method →