$ loading_
Execute implementation plans with task-specific subagents and code review checkpoints.
This skill appears to be an open-source prompt/workflow artifact rather than executable code. It requires no secrets, declares no remote endpoints, and carries low inherent risk, though it is designed to steer a host agent to use existing tools for reading plans, modifying code, and committing changes, so least-privilege controls still matter in the host environment.
The material explicitly states that no keys or environment variables are required. The README does not ask for API tokens, account credentials, or other sensitive configuration, and no direct credential collection, storage, or misuse path is evident.
No remote endpoints are declared, and the documentation does not specify sending data to external services. As a prompt-only skill, it does not itself present a mechanism for outbound data transfer.
The repository is marked prompt-only. The README describes a workflow for a host agent to dispatch subagents, perform code review, and commit changes, rather than bundling executable software or install scripts; the material does not show this skill itself obtaining local execution privileges.
The documentation mentions reading a plan file, working in a directory, and committing work, indicating it is intended to guide an agent to use host-provided file and repository access. However, the skill itself does not declare any additional data interface, persistent storage, or overbroad access scope.
The source is an open GitHub repository, which materially lowers supply-chain risk because the contents are auditable. However, the material shows no declared license, 0 stars, and unknown maintenance status, so evidence of trust and ongoing upkeep is weak; manual review of repository contents and commit history is advisable.
Copy the install command and let the AI configure it · recommended for beginners
Please install the "Subagent-Driven Development" skill from askskill: 1. Download https://raw.githubusercontent.com/obra/clank/main/skills/collaboration/subagent-driven-development/SKILL.md 2. Save it as ~/.claude/skills/subagent-driven-development/SKILL.md 3. Reload skills and tell me it's ready
Execute this implementation plan: assign each subtask to a fresh subagent; after each subtask, perform a code review with risks, improvements, and a go/no-go decision before moving on. Plan: 1) design database migration; 2) implement backend API; 3) add unit tests; 4) update API documentation.
Step-by-step implementation outputs, each followed by code review feedback, risk notes, and a recommendation to proceed.
Help me refactor this legacy module using subagent-driven development: split analysis, refactoring, testing, and documentation into separate tasks, each handled by a fresh subagent; before the next task, review code quality, compatibility, and regression risks.
A refactoring plan and code changes, with staged review conclusions and regression risk assessments.
Complete this automation script project with subagents: 1) define script inputs and outputs; 2) implement core logic; 3) add logging and error handling; 4) write tests. Each step should be handled by a fresh subagent, with code review between steps before continuing.
A complete automation script implementation flow, including outputs for each stage, review feedback, and quality improvement suggestions.
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:
Read plan file, create TodoWrite with all tasks.
For each task:
Dispatch fresh subagent:
Task tool (general-purpose):
description: "Implement Task N: [task name]"
prompt: |
You are implementing Task N from [plan-file].
Read that task carefully. Your job is to:
1. Implement exactly what the task specifies
2. Write tests (following TDD if task says to)
3. Verify implementation works
4. Commit your work
5. Report back
Work from: [directory]
Report: What you implemented, what you tested, test results, files changed, any issues
Subagent reports back with summary of work.
Dispatch code-reviewer subagent:
Task tool (code-reviewer):
Use template at skills/collaboration/requesting-code-review/code-reviewer.md
WHAT_WAS_IMPLEMENTED: [from subagent's report]
PLAN_OR_REQUIREMENTS: Task N from [plan-file]
BASE_SHA: [commit before task]
HEAD_SHA: [current commit]
DESCRIPTION: [task summary]
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:
You: I'm using Subagent-Driven Development to execute this plan.
[Load plan, create TodoWrite]
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
Done!
vs. Manual execution:
vs. Executing Plans:
Cost:
Never:
…
Compare 2-3 approaches before execution to choose a stronger solution.
Write evergreen comments focused on what and why, not historical context.
Search past Claude Code chats to recover facts, decisions, and context.
Design systems by hiding implementation details behind domain-level interfaces.
Plan with pseudocode first, refine approaches, then translate into working code.
Helps developers keep class abstractions cohesive and free of unrelated responsibilities.
Execute implementation plans by splitting and advancing independent tasks in-session.
Research, plan, and execute large code changes with parallel PR-producing agents.
Trigger a code review against plans or requirements before moving forward.
Refine retrieved context iteratively to improve subagent understanding and output quality.
Enable parallel specialized sub-agents and durable logs for Codex CLI workflows.
Execute detailed plans in batches with review checkpoints and course correction.