AGENT SKILL

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

SriAkhilSJ
SriAkhilSJ/PulseAIRepo

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.

★ 0
SriAkhilSJ
SriAkhilSJ/PulseAIRepo

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.

★ 0
SriAkhilSJ
SriAkhilSJ/PulseAIRepo

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.

★ 0
SriAkhilSJ
SriAkhilSJ/PulseAIRepo

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.

★ 0
SriAkhilSJ
SriAkhilSJ/PulseAIRepo

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.

★ 0
SriAkhilSJ
SriAkhilSJ/PulseAIRepo

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.

★ 0