Compétences subagent-driven-development
📦

subagent-driven-development

Sûr

Execute Implementation Plans with Subagents

Également disponible depuis: ZhanlinCui,Cycleaddict,Doyajin174,davila7,obra,DYAI2025,CodingCossack,Cygnusfear

This skill automates implementation task execution by dispatching fresh subagents for each task, with automatic two-stage review (spec compliance then code quality) ensuring high-quality results without manual oversight.

Prend en charge: Claude Codex Code(CC)
🥉 75 Bronze
1

Télécharger le ZIP du skill

2

Importer dans Claude

Allez dans Paramètres → Capacités → Skills → Importer un skill

3

Activez et commencez Ă  utiliser

Tester

Utilisation de "subagent-driven-development". Execute this implementation plan for adding user authentication

RĂ©sultat attendu:

Task 1: Implement login endpoint
- Subagent implements, tests, commits
- Spec reviewer: All requirements met
- Code quality reviewer: Approved

Task 2: Add password reset flow
[continues with same pattern...]

Utilisation de "subagent-driven-development". What does this skill do differently from manual execution?

RĂ©sultat attendu:

Unlike manual execution, subagent-driven-development: (1) Uses fresh subagent per task to avoid context pollution, (2) Runs automatic two-stage review after each task, (3) Stays in same session for continuous progress, (4) Catches issues early before they compound.

Utilisation de "subagent-driven-development". Why use two-stage review (spec then quality)?

RĂ©sultat attendu:

Spec compliance review first ensures only requested features are built. Code quality review second ensures the implementation is well-built. This order prevents wasted effort on high-quality code that doesn't match requirements.

Audit de sécurité

Sûr
v1 • 2/25/2026

All 38 static findings are false positives. The skill is a meta-skill containing prompt templates only - no executable code, scripts, network calls, or file operations. Static scanner misinterpreted GraphViz DOT syntax as shell commands, YAML 'risk: unknown' as cryptographic weakness, and standard code review language as reconnaissance.

4
Fichiers analysés
405
Lignes analysées
0
résultats
1
Total des audits
Aucun problème de sécurité trouvé

Motifs détectés

GraphViz DOT Syntax Misidentified as Shell CommandsYAML Frontmatter Misidentified as Cryptographic WeaknessGit SHA References Misidentified as Cryptographic IssuesExample File Path Misidentified as File System AccessCode Review Language Misidentified as ReconnaissancePrompt Template Structure Misidentified as External Commands
Audité par: claude

Score de qualité

38
Architecture
100
Maintenabilité
87
Contenu
50
Communauté
100
Sécurité
100
Conformité aux spécifications

Ce que vous pouvez construire

Feature Implementation with Quality Gates

A development team lead uses this skill to execute a multi-task feature plan. Each task gets implemented by a fresh subagent, reviewed for spec compliance, then checked for code quality before moving to the next task.

Automated Refactoring Projects

A developer needs to refactor a large codebase across multiple files. They create a plan with independent refactoring tasks. The skill executes each task automatically with built-in quality verification.

Batch Implementation of Related Changes

A DevOps engineer uses this skill to implement a series of infrastructure changes from a plan. Each change goes through spec review and code quality checks automatically.

Essayez ces prompts

Basic Implementation Dispatch 
Use the implementer-prompt.md template to dispatch a subagent for the first task in my implementation plan. The task is: [paste task description here].
Spec Compliance Review Request 
After the implementer completes Task N, dispatch a spec reviewer using spec-reviewer-prompt.md to verify the implementation matches the requirements. Task requirements: [paste requirements]. Implementer report: [paste report].
Code Quality Gate Check 
After spec compliance passes, dispatch a code quality reviewer using code-quality-reviewer-prompt.md. Include the git base SHA and head SHA for the task. Review: [describe what was implemented].
Full Workflow Execution 
Execute my implementation plan using subagent-driven-development. Read the plan file at [path], extract all tasks, and process each one through implementer, spec reviewer, and code quality reviewer before marking complete.

Bonnes pratiques

  • Provide complete task context upfront - subagent should not need to read the plan file
  • Always answer subagent questions before letting them proceed with implementation
  • Never skip review loops - if reviewer finds issues, implementer must fix and re-review
  • Dispatch tasks sequentially, not in parallel, to avoid conflicts

Éviter

  • Starting code quality review before spec compliance is verified (wrong order)
  • Skipping spec compliance review and proceeding directly to code quality
  • Accepting 'close enough' from spec compliance - requirements must match exactly
  • Letting implementer skip self-review before reporting back

Foire aux questions

How is this different from the executing-plans skill?
executing-plans dispatches to a parallel session. subagent-driven-development stays in the same session, uses fresh subagents per task, and adds two-stage review after each task.
Why use fresh subagent per task instead of one subagent for all tasks?
Fresh subagent avoids context pollution. Each task is independent with clear boundaries. A single subagent might carry forward assumptions or confusion from previous tasks.
What happens if a subagent asks questions during implementation?
Answer questions clearly and completely before the subagent proceeds. Do not rush them into implementation. Clarifying upfront prevents rework later.
Can I skip the code quality review if spec compliance passes?
No. Both reviews are required. Spec compliance ensures you built what was requested. Code quality ensures it was built well. Skipping either defeats the purpose of the workflow.
What if the reviewer finds issues but the implementer disagrees?
The reviewer is authoritative on compliance and quality standards. If implementer disagrees, they should discuss with the reviewer and reach consensus. Do not proceed with unresolved issues.
How do I handle tightly coupled tasks in my plan?
This skill requires independent tasks. If tasks are tightly coupled, refactor the plan first to separate them, or use a different workflow skill like executing-plans.

Détails du développeur

Auteur

sickn33

Licence

MIT

DĂ©pĂ´t

https://github.com/sickn33/antigravity-awesome-skills/tree/main/skills/subagent-driven-development

RĂ©f

main

Structure de fichiers

đź“„ code-quality-reviewer-prompt.md

đź“„ implementer-prompt.md

đź“„ SKILL.md

đź“„ spec-reviewer-prompt.md