subagent-driven-development skill
Decomposes complex tasks into atomic units and dispatches them to isolated subagents with fresh context windows for high-quality code implementation.
- GitHub stars
- 44
- Files
- 1
- Last commit
- Apr 12, 2026
- License
- MIT
- Allowed tools
- —
What does the subagent-driven-development skill do?
subagent-driven-development decomposes complex tasks into atomic units and dispatches them to isolated subagents with fresh context windows for high-quality code implementation.
Summary generated from the skill's SKILL.md.
About the subagent-driven-development skill
Breaking down complex programming tasks into small, manageable pieces is what this skill enables for developers working with AI agents. It works by using an orchestrator to decompose a large goal into atomic units, each with its own precise specification. Instead of one agent struggling with a massive, cluttered conversation, this method spawns isolated subagents that receive only the necessary files and instructions within a fresh context window.
To ensure high quality, the system implements a two-stage review process. The first stage checks if the subagent met the specific requirements and acceptance criteria, while the second stage evaluates the code for structure, testing, and maintainability. Each subagent operates within an isolated git worktree to prevent file conflicts during parallel execution. This approach is ideal when a task involves multiple modules or when a conversation has become too long and risks losing coherence due to context contamination.
What an agent can do with it
- 1Manage large-scale refactoring projectsAn agent can split a massive codebase update into several independent subtasks that run in parallel without interfering with each other.
- 2Prevent context window degradationUse this when a long coding session starts producing errors because the agent is losing track of early instructions.
- 3Enforce strict code quality standardsDevelopers can ensure every piece of generated code passes both functional requirements and architectural linting before it is merged.
- 4Execute complex multi-step implementationsA developer can hand over a large feature request that requires several distinct, testable components to be built.
Written from the skill's SKILL.md. Every use case is checked against a quote from it.
How to install the subagent-driven-development skill
Each command copies the skill folder into the client's skills directory. Restart the client or start a new session to load it.Install the subagent-driven-development skill in Plugin
/plugin marketplace add itallstartedwithaidea/agent-skills /plugin install software-dev-skills@googleadsagent-skills
Install the subagent-driven-development skill in Claude Code
~/.claude/skills/subagent-driven-development/SKILL.md
$ npx degit itallstartedwithaidea/agent-skills/skills/software-dev/subagent-driven-development ~/.claude/skills/subagent-driven-developmentInstall the subagent-driven-development skill in Claude Code (project)
.claude/skills/subagent-driven-development/SKILL.md
$ npx degit itallstartedwithaidea/agent-skills/skills/software-dev/subagent-driven-development .claude/skills/subagent-driven-developmentInstall the subagent-driven-development skill in Codex
~/.agents/skills/subagent-driven-development/SKILL.md
$ npx degit itallstartedwithaidea/agent-skills/skills/software-dev/subagent-driven-development ~/.agents/skills/subagent-driven-developmentInstall the subagent-driven-development skill in Gemini CLI
~/.gemini/skills/subagent-driven-development/SKILL.md
$ npx degit itallstartedwithaidea/agent-skills/skills/software-dev/subagent-driven-development ~/.gemini/skills/subagent-driven-developmentInstall the subagent-driven-development skill in Claude.ai
npx degit itallstartedwithaidea/agent-skills/skills/software-dev/subagent-driven-development subagent-driven-development && zip -r subagent-driven-development.zip subagent-driven-development # claude.ai → Customize → Skills → + → Create skill → Upload a skill → subagent-driven-development.zip
SKILL.md
View on GitHubSubagent-Driven Development
Part of Agent Skills™ by googleadsagent.ai™
Description
Subagent-Driven Development dispatches each discrete task to a fresh subagent with a clean context window, then subjects the output to a two-stage review before merging. The orchestrating agent decomposes work into atomic units, writes precise specifications for each, and spawns isolated subagents that cannot pollute each other's context or carry forward stale assumptions.
Context window contamination is the silent killer of agent code quality. As a conversation grows, early instructions fade, variable names blur, and the agent begins referencing code that has since been refactored. By giving each task a fresh subagent, every implementation starts from a clean slate with only the relevant specification and referenced files. The result is consistently high-quality output regardless of session length.
The two-stage review process catches defects at different abstraction levels. Stage 1 verifies spec compliance: does the output do what was asked? Stage 2 evaluates code quality: is it well-structured, tested, and maintainable? Only code that passes both gates is accepted into the codebase.
Use When
- A task can be decomposed into 3+ independent subtasks
- The conversation context has grown large enough to risk coherence loss
- Multiple files or modules must be modified in parallel
- You need best-of-N attempts for a complex implementation
- Quality gates must be enforced consistently across all outputs
- The user requests parallel or isolated task execution
How It Works
graph TD
A[Orchestrator: Decompose Task] --> B[Write Spec for Subtask 1]
A --> C[Write Spec for Subtask 2]
A --> D[Write Spec for Subtask N]
B --> E[Spawn Subagent 1]
C --> F[Spawn Subagent 2]
D --> G[Spawn Subagent N]
E --> H[Stage 1: Spec Compliance Review]
F --> H
G --> H
H --> I{Passes?}
I -->|No| J[Return to Subagent with Feedback]
J --> H
I -->|Yes| K[Stage 2: Code Quality Review]
K --> L{Passes?}
L -->|No| J
L -->|Yes| M[Merge to Main Branch]
The orchestrator never writes implementation code directly. Its role is to decompose, specify, dispatch, and review. Each subagent operates in an isolated git worktree, preventing conflicts between parallel implementations.
Implementation
orchestrator:
decompose:
- analyze_task_for_independent_subtasks
- ensure_each_subtask_has: [clear_input, clear_output, testable_criteria]
- max_subtask_size: "completable_in_one_session"
spec_template: |
## Subtask: {name}
**Input**: {files_to_read}
**Output**: {files_to_create_or_modify}
**Acceptance Criteria**:
- {criterion_1}
- {criterion_2}
**Constraints**: {architectural_boundaries}
**Tests**: {required_test_cases}
dispatch:
method: "fresh_subagent_per_task"
isolation: "git_worktree"
context: "spec_only" # No conversation history
review_stage_1_spec_compliance:
checks:
- all_acceptance_criteria_met
- all_required_tests_present_and_passing
- output_files_match_specification
- no_unspecified_side_effects
review_stage_2_code_quality:
checks:
- no_linter_errors
- no_type_errors
- naming_conventions_followed
- no_dead_code_or_debug_artifacts
- error_handling_present
- documentation_for_public_apis
merge:
strategy: "squash_per_subtask"
commit_message: "feat({subtask_name}): {one_line_summary}"
Best Practices
- Keep subtask specs self-contained—a subagent should need no context beyond the spec
- Include file paths and relevant type signatures in every spec
- Run both review stages even if the code "looks correct" at first glance
- Limit subagent retry attempts to 2 before escalating to the orchestrator
- Use git worktrees for true filesystem isolation between parallel subagents
- Squash-merge each subtask to maintain a clean commit history
Platform Compatibility
| Platform | Support | Notes |
|---|---|---|
| Cursor | Full | Native Task tool for subagent dispatch |
| VS Code | Partial | Requires manual subprocess management |
| Windsurf | Full | Cascade supports subagent spawning |
| Claude Code | Full | Built-in subagent support |
| Cline | Partial | Plugin-based subagent support |
| aider | Limited | No native subagent capability |
Related Skills
- Git Worktrees - Isolated filesystem workspaces that prevent subagents from clobbering each other's changes
- Writing Plans - Plan authoring that produces the subtask specifications subagents execute against
- Code Review - Two-stage review process that validates subagent outputs before merge
- Sandbox Hardening - Execution isolation that constrains subagent permissions and resource usage
Keywords
subagent task-decomposition parallel-development two-stage-review context-isolation orchestrator spec-driven fresh-context
© 2026 googleadsagent.ai™ | Agent Skills™ | MIT License
Files in this skill
1subagent-driven-development skill questions
How do I install the subagent-driven-development skill in Claude Code?
Run npx degit itallstartedwithaidea/agent-skills/skills/software-dev/subagent-driven-development ~/.claude/skills/subagent-driven-development. Claude Code loads skills from ~/.claude/skills (all projects) or .claude/skills (one project) and uses a skill when its description matches the task.
Which clients can use the subagent-driven-development skill?
Any client that reads the Agent Skills format: Claude Code, Codex, Gemini CLI and claude.ai (upload as a ZIP). Scripts in the skill run only where the client allows code execution.
How does the review process work?
The process uses two stages: Stage 1 verifies if the output complies with the original specification, and Stage 2 evaluates the code quality, structure, and maintainability.