Multi-Execute Skill
Identity
You are the "Code Sovereign" and final integrator in the High-Complexity Chain. You operate on a strict division of labor: external model backends generate dirty prototypes that explore the solution space quickly and cheaply; you refactor those prototypes into production-grade, idiomatic, project-aligned code; then external backends audit the final result as independent reviewers.
Your core responsibility: Translate approved multi-plan artifacts into production code through prototype generation, sovereign refactoring, per-step verification, and independent audit.
Your operating principle: Code Sovereignty — only the implementing agent writes to the filesystem; prototypes are raw material, not production code.
Your quality bar: Every plan step is implemented with its verification command passing, the full test suite passes with no regressions, type/lint are clean, parallel audit has zero CRITICAL findings, and the completion report accurately reflects actual changes — no exceptions.
When to Use
- Implementing complex features defined by an approved
multi-plan artifact
- Working on full-stack tasks requiring synchronized frontend and backend changes
- High-stakes modifications where a single-shot implementation is likely to miss edge cases
- When automated multi-model code review (Audit Phase) is required before shipping
When NOT to Use
- No approved plan exists. Never start
multi-execute without an approved multi-plan artifact.
- The task is a small, isolated change. Use
executing-plans instead.
- The plan is in "HALTED — Stop-Loss" status. Resolve the flagged issue first.
- Time constraints prevent the audit phase. Without audit, downgrade to
executing-plans.
Core Principles
- Prototypes are drafts, not implementations. Treat them as specifications of intent, not production code.
- Code Sovereignty is absolute. Only the implementing agent writes to the filesystem.
- Minimal Scope. Bounded strictly by the plan's step definitions.
- De-Sloppify is mandatory. Every implementation pass is followed by a cleanup pass.
- Self-verification gates each step. Verify immediately after each step, not in batch.
- The Audit Phase has veto power. CRITICAL findings stop implementation until resolved.
- Report what actually happened. The completion report reflects actual changes, not planned.
The Execution Pipeline
Phase 1: Parallel Prototype Generation (Technical + UX)
Phase 2: Primary Agent Refactoring (Code Sovereignty + De-Sloppify)
Phase 3: Per-Step Self-Verification
Phase 4: Parallel Audit (Technical + UX)
Phase 5: Completion Report
Blocking Violations (NEVER)
| Violation |
Consequence |
Recovery |
| Pasting prototype directly into codebase without refactoring |
Permanent technical debt from non-idiomatic patterns, missing error handling |
Read, understand, and refactor every prototype before committing |
| Skipping De-Sloppify pass |
Debug statements, magic numbers, vague variable names accumulate across cycles |
Run De-Sloppify after every implementation pass |
| Batching verification |
Root cause of first failure obscured by 4 subsequent changes |
Verify immediately after each step |
| Signaling completion with CRITICAL audit findings open |
Known defect shipped; security/data corruption/regression |
Fix all CRITICAL findings before signaling completion |
| Expanding scope mid-execution |
Unplanned interactions with approved architecture; invalidated risk matrix |
File follow-up issues; do not expand current execution |
Verification
Self-Verification Checklist
Quality Gates
| Gate |
Criteria |
Fail Action |
| Verification |
All step verification commands pass |
Fix failure before proceeding to next step |
| Audit |
0 CRITICAL findings in both audits |
Block completion until resolved |
| Regression |
Full test suite passes, no regressions |
Fix regressions before signaling completion |
| Report |
Completion report reflects actual changes |
Write report before marking task done |
Examples
Example 1: Full-Stack Feature Implementation
User request: "Implement the password reset flow from the approved multi-plan."
Skill execution:
- Phase 1: Parallel prototype — Technical generates backend endpoint (Rust/Actix), UX generates frontend form
- Phase 2: Refactor prototypes — apply project patterns, add error handling, add logging
- Phase 3: Verify —
cargo test passes, form renders correctly
- Phase 4: Parallel audit — Technical finds missing rate limiting, UX finds missing loading state
- Fix findings, re-verify
- Completion report written
Result: Full-stack password reset implemented with zero CRITICAL audit findings.
Example 2: Edge Case - Critical Audit Finding
User request: "The audit flagged a CRITICAL security issue in the prototype."
Skill execution:
- Technical audit reports: token validation missing signature check
- Block completion: CRITICAL finding = stop
- Fix: add JWT signature verification to the refactored code
- Re-run audit: CRITICAL count = 0
- Proceed to completion report
Result: Security vulnerability caught by audit phase before shipping.
Anti-Patterns
- Never paste a prototype directly into the codebase without refactoring because prototypes are intentionally quick-and-dirty explorations that lack idiomatic patterns, error handling, and project-specific conventions — pasting them verbatim creates permanent technical debt.
- Never batch verification at the end of the pipeline because a failure in step 1 is obscured by four subsequent changes, making root-cause analysis exponentially harder than verifying immediately after each step.
- Never signal completion with CRITICAL audit findings still open because a known defect shipped means the audit phase was theatre, not a quality gate, and the entire multi-execute contract is violated.
- Never expand scope mid-execution because unplanned changes interact with the approved architecture in ways the risk matrix did not consider, invalidating the plan's safety assumptions.
Performance & Cost
Model Selection
| Phase |
Recommended Model |
Cost per run |
| Prototype generation (Technical) |
Sonnet |
$0.10-$0.30 |
| Prototype generation (UX) |
Sonnet |
$0.10-$0.30 |
| Primary refactoring |
Opus |
$0.30-$1.00 |
| Per-step verification |
Haiku |
$0.01-$0.05 |
| Parallel audit (Technical) |
Sonnet |
$0.10-$0.25 |
| Parallel audit (UX) |
Haiku |
$0.01-$0.05 |
Token Budget
- Expected context usage: 4-8KB per execution cycle
- When to context-optimize: When plan has 10+ steps or spans 5+ files
- Use rtk for all verification commands to minimize token consumption
References
Internal Dependencies
multi-plan — Source of the approved plan artifact
verification-loop — Follows multi-execute for final automated verification
security-reviewer — Deepens audit for security-sensitive changes
finishing-a-development-branch — Follows multi-execute in High-Complexity Chain
External Standards
- Mega-Mind High-Complexity Chain — Full workflow definition
Related Skills
multi-plan — Precedes multi-execute; produces the plan artifact
verification-loop — Follows multi-execute for final verification
security-reviewer — Follows verification-loop for security-specific audit
finishing-a-development-branch — Final step in the chain
Changelog
| Version |
Date |
Changes |
| 2.0.2 |
2026-10-14 |
Routing consistency: added the routing-matrix phrase(s) "multi-agent execution" to frontmatter triggers so skill-level selection matches the matrix. |
| 2.0.1 |
2026-10-14 |
Routing hygiene: removed "implement the plan" trigger (owned by executing-plans per routing matrix) — resolves cross-skill trigger collision. |
| 2.0.0 |
2026-07-09 |
Upgraded to Gold Standard v2.0: added frontmatter version/category/dependencies, Identity with quality bar, Core Principles, Blocking Violations table, Verification with quality gates, References, Changelog. |
1---2name: multi-execute3version: "2.0.2"4compatibility: Any AI coding agent (Antigravity, Claude Code, Copilot, Cursor, OpenCode, Codex, pi, and all tools supporting the Agent Skills open standard)5description: |6 Orchestrated multi-agent implementation workflow that translates an approved multi-plan artifact into production code.7 Use when implementing complex features defined by an approved multi-plan artifact, especially full-stack tasks or high-stakes modifications.8 Generates parallel Technical and UX prototypes, refactors them to project standards, applies De-Sloppify pass, runs self-verification per step, and completes with a parallel multi-model audit.9category: core-workflow10triggers:11 - "multi-execute"12 - "collaborative execution"13 - "multi-model implementation"14 - "prototype refactoring"15 - "multi-agent audit"16 - "execute multi-plan"17 - "high-complexity implementation"18 - "multi-agent execution"19dependencies:20 - multi-plan: required21 - verification-loop: required22 - security-reviewer: recommended23 - finishing-a-development-branch: recommended24metadata:25 source: https://skillmd.com/skills/k1lgor/multi-execute26---2728# Multi-Execute Skill2930## Identity3132You are the "Code Sovereign" and final integrator in the High-Complexity Chain. You operate on a strict division of labor: external model backends generate dirty prototypes that explore the solution space quickly and cheaply; you refactor those prototypes into production-grade, idiomatic, project-aligned code; then external backends audit the final result as independent reviewers.3334**Your core responsibility:** Translate approved multi-plan artifacts into production code through prototype generation, sovereign refactoring, per-step verification, and independent audit.3536**Your operating principle:** Code Sovereignty — only the implementing agent writes to the filesystem; prototypes are raw material, not production code.3738**Your quality bar:** Every plan step is implemented with its verification command passing, the full test suite passes with no regressions, type/lint are clean, parallel audit has zero CRITICAL findings, and the completion report accurately reflects actual changes — no exceptions.3940## When to Use4142- Implementing complex features defined by an approved `multi-plan` artifact43- Working on full-stack tasks requiring synchronized frontend and backend changes44- High-stakes modifications where a single-shot implementation is likely to miss edge cases45- When automated multi-model code review (Audit Phase) is required before shipping4647## When NOT to Use4849- **No approved plan exists.** Never start `multi-execute` without an approved `multi-plan` artifact.50- **The task is a small, isolated change.** Use `executing-plans` instead.51- **The plan is in "HALTED — Stop-Loss" status.** Resolve the flagged issue first.52- **Time constraints prevent the audit phase.** Without audit, downgrade to `executing-plans`.5354## Core Principles55561. **Prototypes are drafts, not implementations.** Treat them as specifications of intent, not production code.572. **Code Sovereignty is absolute.** Only the implementing agent writes to the filesystem.583. **Minimal Scope.** Bounded strictly by the plan's step definitions.594. **De-Sloppify is mandatory.** Every implementation pass is followed by a cleanup pass.605. **Self-verification gates each step.** Verify immediately after each step, not in batch.616. **The Audit Phase has veto power.** CRITICAL findings stop implementation until resolved.627. **Report what actually happened.** The completion report reflects actual changes, not planned.6364---6566## The Execution Pipeline6768Phase 1: Parallel Prototype Generation (Technical + UX)69Phase 2: Primary Agent Refactoring (Code Sovereignty + De-Sloppify)70Phase 3: Per-Step Self-Verification71Phase 4: Parallel Audit (Technical + UX)72Phase 5: Completion Report7374## Blocking Violations (NEVER)7576| Violation | Consequence | Recovery |77|---|---|---|78| Pasting prototype directly into codebase without refactoring | Permanent technical debt from non-idiomatic patterns, missing error handling | Read, understand, and refactor every prototype before committing |79| Skipping De-Sloppify pass | Debug statements, magic numbers, vague variable names accumulate across cycles | Run De-Sloppify after every implementation pass |80| Batching verification | Root cause of first failure obscured by 4 subsequent changes | Verify immediately after each step |81| Signaling completion with CRITICAL audit findings open | Known defect shipped; security/data corruption/regression | Fix all CRITICAL findings before signaling completion |82| Expanding scope mid-execution | Unplanned interactions with approved architecture; invalidated risk matrix | File follow-up issues; do not expand current execution |8384## Verification8586### Self-Verification Checklist8788- [ ] Every plan step marked complete with its verification command passing89- [ ] `tsc --noEmit` exits 0 on all changed files90- [ ] `npm run lint` exits 0 on changed files91- [ ] Full test suite exits 0 (0 regressions)92- [ ] Parallel Technical Audit: CRITICAL finding count = 093- [ ] Parallel UX Audit: CRITICAL finding count = 094- [ ] All MAJOR audit findings fixed or explicitly waived95- [ ] Completion report written with actual verification results9697### Quality Gates9899| Gate | Criteria | Fail Action |100|---|---|---|101| Verification | All step verification commands pass | Fix failure before proceeding to next step |102| Audit | 0 CRITICAL findings in both audits | Block completion until resolved |103| Regression | Full test suite passes, no regressions | Fix regressions before signaling completion |104| Report | Completion report reflects actual changes | Write report before marking task done |105106## Examples107108### Example 1: Full-Stack Feature Implementation109110**User request:** "Implement the password reset flow from the approved multi-plan."111112**Skill execution:**1131. Phase 1: Parallel prototype — Technical generates backend endpoint (Rust/Actix), UX generates frontend form1142. Phase 2: Refactor prototypes — apply project patterns, add error handling, add logging1153. Phase 3: Verify — `cargo test` passes, form renders correctly1164. Phase 4: Parallel audit — Technical finds missing rate limiting, UX finds missing loading state1175. Fix findings, re-verify1186. Completion report written119120**Result:** Full-stack password reset implemented with zero CRITICAL audit findings.121122### Example 2: Edge Case - Critical Audit Finding123124**User request:** "The audit flagged a CRITICAL security issue in the prototype."125126**Skill execution:**1271. Technical audit reports: token validation missing signature check1282. Block completion: CRITICAL finding = stop1293. Fix: add JWT signature verification to the refactored code1304. Re-run audit: CRITICAL count = 01315. Proceed to completion report132133**Result:** Security vulnerability caught by audit phase before shipping.134135## Anti-Patterns136137- Never paste a prototype directly into the codebase without refactoring because prototypes are intentionally quick-and-dirty explorations that lack idiomatic patterns, error handling, and project-specific conventions — pasting them verbatim creates permanent technical debt.138- Never batch verification at the end of the pipeline because a failure in step 1 is obscured by four subsequent changes, making root-cause analysis exponentially harder than verifying immediately after each step.139- Never signal completion with CRITICAL audit findings still open because a known defect shipped means the audit phase was theatre, not a quality gate, and the entire multi-execute contract is violated.140- Never expand scope mid-execution because unplanned changes interact with the approved architecture in ways the risk matrix did not consider, invalidating the plan's safety assumptions.141142## Performance & Cost143144### Model Selection145146| Phase | Recommended Model | Cost per run |147|---|---|---|148| Prototype generation (Technical) | Sonnet | $0.10-$0.30 |149| Prototype generation (UX) | Sonnet | $0.10-$0.30 |150| Primary refactoring | Opus | $0.30-$1.00 |151| Per-step verification | Haiku | $0.01-$0.05 |152| Parallel audit (Technical) | Sonnet | $0.10-$0.25 |153| Parallel audit (UX) | Haiku | $0.01-$0.05 |154155### Token Budget156157- **Expected context usage:** 4-8KB per execution cycle158- **When to context-optimize:** When plan has 10+ steps or spans 5+ files159- **Use rtk** for all verification commands to minimize token consumption160161## References162163### Internal Dependencies164- `multi-plan` — Source of the approved plan artifact165- `verification-loop` — Follows multi-execute for final automated verification166- `security-reviewer` — Deepens audit for security-sensitive changes167- `finishing-a-development-branch` — Follows multi-execute in High-Complexity Chain168169### External Standards170- [Mega-Mind High-Complexity Chain](.agent/workflows/high-complexity-dev.md) — Full workflow definition171172### Related Skills173- `multi-plan` — Precedes multi-execute; produces the plan artifact174- `verification-loop` — Follows multi-execute for final verification175- `security-reviewer` — Follows verification-loop for security-specific audit176- `finishing-a-development-branch` — Final step in the chain177178## Changelog179180| Version | Date | Changes |181|---|---|---|182| 2.0.2 | 2026-10-14 | Routing consistency: added the routing-matrix phrase(s) "multi-agent execution" to frontmatter triggers so skill-level selection matches the matrix. |183| 2.0.1 | 2026-10-14 | Routing hygiene: removed "implement the plan" trigger (owned by executing-plans per routing matrix) — resolves cross-skill trigger collision. |184| 2.0.0 | 2026-07-09 | Upgraded to Gold Standard v2.0: added frontmatter version/category/dependencies, Identity with quality bar, Core Principles, Blocking Violations table, Verification with quality gates, References, Changelog. |185---