subagent-driven-development
Execute plans via delegate_to_subagent subagents (2-stage review).
- License 许可
- MIT
- 最近更新
- 2026-11-13
- Stars
- ★ 0
- Forks
- 0
01 前言 Front Matter
- name
- subagent-driven-development
- author
- Hermes Agent (adapted from obra/superpowers), ported for CrusorAI
- license
- MIT
- version
- 1.2.0
- metadata
- { "hermes": { "tags": [ "delegation", "subagent", "implementation", "workflow", "parallel" ], "related_skills": [ "requesting-code-review", "test-driven-development" ] } }
- platforms
- [ "linux", "macos", "windows" ]
- description
- Execute plans via delegate_to_subagent subagents (2-stage review).
03 SKILL.md 正文
Triggers: subagent, sub-agent, delegate, parallel agents, spawn agents, batch agents, delegate_to_subagent, fan out, startup, platform, ecommerce, e-commerce, amazon, fullstack, multi-tier, complex project
Subagent-Driven Development
Overview
Execute an implementation plan by dispatching a fresh Crusor subagent per task with systematic two-stage review.
Core principle: fresh subagent per task + two-stage review (spec, then quality) = high quality, fast iteration. Crusor already ships delegate_to_subagent (single) and delegate_to_subagent_batch (parallel) — this skill is about driving them well.
When to Use
- You have an implementation plan (Plan mode output or user requirements)
- Tasks are mostly independent
- Quality and spec compliance matter
vs. manual execution: fresh context per task (no confusion from accumulated state), automated review catches issues early, consistent quality checks. Child runs are isolated (parentMap), depth-guarded by CRUSORAI_SUBAGENT_DEPTH, and surface as clickable taskToolCards — tell the user they can click through to each child.
The Process
1. Read and Parse the Plan ONCE
Extract ALL tasks with their full text and context upfront. Do not make subagents read the plan file — paste the full task text into each subagent's context.
2. Per-Task Workflow
Step 1 — dispatch the implementer
Use delegate_to_subagent with complete, self-sufficient context:
delegate_to_subagent(
goal="Implement Task 1: Create User model with email and password_hash fields",
context="""
TASK FROM PLAN:
- Create: src/models/user.py
- User class with email (str) and password_hash (str); bcrypt hashing
FOLLOW TDD (test-driven-development skill):
1. Write failing test in tests/models/test_user.py
2. Run: pytest tests/models/test_user.py -v (verify FAIL)
3. Minimal implementation
4. Run: pytest tests/models/test_user.py -v (verify PASS)
5. Run: pytest tests/ -q (no regressions)
PROJECT CONTEXT: Python 3.12, app in src/, pytest from project root.
""",
)
Step 2 — spec-compliance reviewer
After the implementer completes, dispatch a fresh subagent that checks ONLY against the original spec:
CHECK: all spec requirements implemented? file paths/signatures match?
behavior matches? nothing extra added (no scope creep)?
OUTPUT: PASS, or a list of specific spec gaps to fix.
If gaps: fix, then re-run the spec review. Continue only when spec-compliant.
Step 3 — code-quality reviewer
CHECK: project conventions? error handling? clear names? test coverage?
obvious bugs/edge cases? security issues?
OUTPUT: Critical / Important / Minor issues + verdict APPROVED or REQUEST_CHANGES.
If issues: fix, re-review. Continue only when approved.
Step 4 — mark the task complete and move to the next
3. Parallelize Independent Tasks
Independent tasks (different files, no interface coupling) go through delegate_to_subagent_batch in ONE call. Dependencies stay serial: never dispatch a task whose inputs another subagent is still producing.
4. Final Integration Review
After ALL tasks complete, dispatch one final reviewer: do the components work together? inconsistencies between tasks? all tests passing? ready for hand-off?
Invariants
- Fresh subagent per task and per review — never ask the implementer to review itself.
- Reviews read files only; fixes go back through an implementer dispatch.
- Never commit without the user's approval flow (Crusor mutation gates).
- If a subagent fails twice on the same task, stop and escalate to the user instead of retrying blindly.
04 同仓库更多 Skills
interaction-patterns-architect
Architect-level interaction design in code — choosing established patterns over invented ones, feedback and latency behaviour, destructive-action safeguards, navigation and overlay conventions, and the state model behind every interactive surface. Use when a screen has to behave, not just look.
design-system-ops-architect
Architect-level operation of a design system in code — token pipelines and versioning, component API and variant policy, the catalogue as the contract, adoption metrics, and the governance that stops a system from forking into three. Use when a component library must survive several teams.
design-handoff-architect
Architect-level design handoff — what must be specified before implementation starts, tokens over raw values, responsive and content-limit contracts, state matrices, and the review loop that catches drift between design and code. Use when a design is about to become code.
content-microcopy-architect
Architect-level UI content — where strings live, voice and terminology consistency, error and empty-state copy as part of the interface, translation-ready authoring, and the content model a product needs before it multiplies screens. Use when the words in the interface matter as much as the pixels.
ui-ux-implementation-architect
Architect-level direction for turning a design into working UI — the handoff contract, component ownership versus screen-level layout, interaction and state conventions, design QA gates, and the review habits that keep an implementation faithful without frozen pixels. Use before any specific UI implementation skill.
test-strategy-architect
Architect-level test strategy — allocating assertions across unit, integration, contract and end-to-end layers, designing for testability through dependency boundaries, fixture and data strategy, and the flake and coverage policies that keep a suite trustworthy. Use when defining how a codebase is tested.