| name | insight-devloopfast |
| description | Speed mode build loop. Same crew, same Monkey, less ceremony. Auto-triages (no approval gate for small/medium), confidence-filters findings (80+ only). The Monkey never sleeps — she just doesn't block. Use when you trust the plan and want to ship fast. Trigger on: 'fast build', 'quick build', 'devloopfast', 'speed mode', 'just build it'. |
| model | opus |
| disable-model-invocation | true |
| allowed-tools | Read, Write, Edit, Glob, Grep, Bash(npx jest*), Bash(npx tsc*), Bash(git *), Agent, Skill(frontend-design), AskUserQuestion |
DevLoopFast — Speed Mode
Same crew, same values, same Monkey, less ceremony. This is /insight-devloop with two changes:
- Auto-triage — Frame runs but doesn't wait for approval on small/medium changes. Only architectural changes gate on human approval.
- Confidence filtering — Storm, Cartographer, and Monkey findings filtered at 80+ confidence. Below that, logged to
.insightsLoop/current/filtered-findings.md (never discarded — just not in your face).
The Monkey runs at Frame (all verticals against the plan) and Build (all verticals against the merged diff). Storm handles TDD review. The only difference from /insight-devloop: findings don't block the loop — they get confidence-filtered like everything else, and the crew keeps moving.
What's Different from /insight-devloop
| Aspect | /insight-devloop | /insight-devloopfast |
|---|
| Frame approval | Always waits | Auto-approves small/medium, gates architectural |
| Monkey | Real agent at Frame + Build, blocks on Survived: no | Real agent at Frame + Build, logs finding, moves on |
| Storm output | All findings | 80+ confidence only |
| Cartographer output | All findings | 80+ confidence only |
| Filtered findings | N/A | filtered-findings.md |
What's NOT Different
- Phase 0: Values still load and get pasted into briefs. Non-negotiable.
- Brief construction: paste SKILL.md verbatim, write context to brief files, present output as-is.
- Greenfield detection: two-pass (existence + wiring), user gate even in speed mode.
- The Monkey launches at Frame and Build. Storm reviews TDD. Non-negotiable.
- Sentinel writes acceptance contracts (ATDD) before per-task contracts.
- Sentinel is still a separate agent from Shipwright.
- Fix pipeline: Storm specs → Sentinel tests → Shipwright patches (finder never fixes).
- Consolidated findings report with
[concept] location contract.
- Worktree isolation stays.
- Plan is still a hard gate. No plan = no build.
- Tests still run. Code still passes before shipping.
- Error handling is the same — merge conflicts, test failures, and typecheck errors still stop the loop.
- Run archiving is the same —
current/ → run-NNNN-feature-name/ on completion.
Step 0: Load Project Values
Same as /insight-devloop Step 0. Read VALUES.md and TDD-MATRIX.md. Paste content into agent briefs. If they don't exist, omit values-related lines from briefs. The Monkey reads VALUES.md herself.
Read each crew SKILL.md right before briefing that crew member (same progressive loading as devloop). Same crew, same identities, same methods. Speed mode changes ceremony, not crew definitions.
Briefing
Same as devloop: Fill template from brief-templates/. Write brief to .insightsLoop/current/brief-<crew>.md. Pass to agent. Present crew output as-is. All brief-*.md files are on the archive discard list.
Also read .insightsLoop/config.md for engine tunables if it exists. Defaults:
monkey_findings_per_step (default: 3) — per verticalconfidence_threshold (default: 80) — filtering cutoff
Step 0.5: Resume Check
Same as devloop: If .insightsLoop/current/ has artifacts, ask: Resume (skip steps whose output exists) / Start fresh (archive, begin new) / Abort. Gates always re-run on resume.
Lean Crew (Small triage)
Same as devloop — Small triage skips Cartographer and Build Monkey. Gate: Triage: Small. Lean crew. Approve / Full crew / Adjust / Abort. In speed mode, lean crew is auto-approved for small/medium — only architectural gates on human.
Artifact Directory
Same as /insight-devloop — all artifacts in .insightsLoop/current/ during the run, archived to run-NNNN-feature-name/ on completion. One additional artifact:
filtered-findings.md — findings below 80 confidence, kept in archive for retro evaluation
Prerequisites
Same as /insight-devloop — plan.md with ## Challenge section must exist.
Step 1: Frame (Auto-Triage)
Goal: Decompose the plan into atomic buildable tasks, then stress-test. Same as devloop — the Quartermaster decomposes, the orchestrator routes.
1a: The Quartermaster (Opus)
Same as /insight-devloop Step 1a. Read Quartermaster SKILL.md, fill template (brief-templates/quartermaster.md), write to .insightsLoop/current/brief-quartermaster.md. The Quartermaster handles:
- Codebase survey, greenfield detection, scaffolding checklist
- Task decomposition into atomic worktree-level tasks
- Worktree assignments with parallelization plan
- Test file mapping
- Acceptance criteria sharpening
Output: .insightsLoop/current/frame.md — written by the Quartermaster directly.
If greenfield/partially-scaffolded: use AskUserQuestion even in speed mode — scaffolding correctness is not auto-approvable.
Triage (from frame.md)
Read the Quartermaster's frame.md. Confirm triage:
| Size | Criteria | What runs | Approval |
|---|
| Small | 1 file, no new interfaces, existing patterns | Build → Ship (skip normalize) | Auto |
| Medium | Multi-file, existing patterns | Build → Ship (skip normalize) | Auto |
| Architectural | New interfaces, schema changes, public API | Full loop | Wait for human |
For small/medium: log the triage decision and proceed immediately.
For architectural: use the AskUserQuestion tool to present the frame and get approval. Options: "Approve — start building", "Adjust — change triage or scope", "Abort — back to plan".
1b: The Monkey at Frame (All Verticals)
Launch the Monkey agent. Fill template (brief-templates/monkey-frame.md). Covers all relevant verticals against the plan. monkey_findings_per_step findings per selected vertical (default: 3). See devloop for vertical selection rules and plan-level scope rules (no implementation-level findings).
Context includes both plan.md and the Quartermaster's frame.md.
Output: .insightsLoop/current/monkey-frame.md
IMPORTANT: Write monkey-frame.md immediately after the Monkey agent returns. Agent output alone is not persistent — if you don't write the file, the archive loses the artifact.
If any finding has Survived: no:
- For architectural: stop and discuss (same as /insight-devloop)
- For small/medium: if the finding would change the triage, re-triage even in speed mode (triage correctness is not optional). Otherwise log to
filtered-findings.md and proceed.
Sentinel Gate
Same as devloop — three checks before Step 2a, every run (including resume):
Manifest exists? Lock file exists? Test framework installed? Any fail (non-greenfield): stop. Greenfield: Task 0 must have run.
Step 2: Build
Same as /insight-devloop. No shortcuts at Build — this is where correctness lives.
2a: TDD — The Sentinel (Opus)
Same as /insight-devloop. Read Sentinel SKILL.md, fill template (brief-templates/sentinel.md), write to .insightsLoop/current/brief-sentinel.md.
Storm — TDD Review (Opus)
Same as /insight-devloop — Storm reviews the Sentinel's test contracts for gaps. Fill template (brief-templates/storm-tdd.md), write to .insightsLoop/current/brief-storm-tdd.md.
Output: .insightsLoop/current/storm-tdd.md
IMPORTANT: Write storm-tdd.md immediately after the Storm agent returns. Agent output alone is not persistent — if you don't write the file, the archive loses the artifact.
If any finding is critical/high (missing acceptance criteria coverage): dispatch to the Sentinel — re-invoke her to write the missing contracts. In speed mode, Sentinel dispatch happens without a user gate — the contracts get added automatically. Lower-severity findings log to filtered-findings.md.
2b: Implement — The Shipwright (Sonnet, parallel worktrees)
Same as /insight-devloop. Fill template (brief-templates/shipwright.md), write to .insightsLoop/current/brief-shipwright.md.
Note: The Build Monkey runs after Storm + Cartographer in Step 3b, with full analysis context. See "Build Monkey (all verticals)" below.
Step 3: Ship (Filtered)
3a: Merge
Same as /insight-devloop. Conflicts still stop the loop and go to the user.
3b: Verify + Converge (confidence-filtered)
Three agents run on the merged diff. Storm and Cartographer run in parallel first, then the Build Monkey runs after both return. Then converge and present.
Storm + Cartographer (parallel)
The Storm (Opus): Fill template (brief-templates/storm-verify.md), write to .insightsLoop/current/brief-storm-verify.md. Add to brief: "For each finding, assign a confidence score (0-100). Add a Confidence column to all tables." Both passes in one invocation.
The Cartographer (Sonnet): Fill template (brief-templates/cartographer.md), write to brief-cartographer.md. Add to brief: "For each finding, add a Confidence column (0-100)." Skip condition same as devloop.
Skip condition: If the story is visual-only (layout, CSS, copy changes) with no new code paths, skip the Cartographer entirely. Mechanical path enumeration adds nothing when no branches exist to enumerate — Storm carries verification alone. Write an empty edge-cases.md (header only) for the archive and note "Skipped: visual-only change" at the top.
IMPORTANT: Write both storm-report.md and edge-cases.md immediately after each agent returns. Agent output alone is not persistent.
Storm output: .insightsLoop/current/storm-report.md:
# Storm Report
| Location | Issue | Severity | Confidence | Suggestion |
|----------|-------|----------|------------|------------|
| `src/lib/auth.ts:45` | Token skips issuer check | critical | 90 | Add issuer verification |
Cartographer output: .insightsLoop/current/edge-cases.md — same format with Confidence column.
Filtering (applied during convergence, not here):
- Findings with confidence 80+ → shown to user, fixed if critical/high
- Findings with confidence <80 → appended to
.insightsLoop/current/filtered-findings.md
- Empty reports remain valid
- Borderline (threshold-5 to threshold-1): round up, show it. Better to over-surface than to miss.
Build Monkey (all verticals — after Storm + Cartographer)
Same as /insight-devloop — fill template (brief-templates/monkey-build.md). Single Monkey covers all relevant verticals in one pass.
Output: .insightsLoop/current/monkey-build.md
IMPORTANT: Write monkey-build.md immediately after the Monkey agent returns.
Vertical selection: Same as devloop — skip irrelevant verticals based on plan. Always run Architecture and Integration.
Confidence filter applies per finding: 80+ surfaced, below-threshold → filtered-findings.md. Findings with Survived: no, high confidence, and actionable file:line enter consolidated findings for fix pipeline.
Converge and Present
This is a hard gate even in speed mode. Do not proceed to 3c without completing this.
After all agents return (Storm, Cartographer, Build Monkey) and their artifacts are written to disk:
- Apply confidence filtering: 80+ findings surfaced, below-threshold →
filtered-findings.md
- Present a summary of ALL surfaced findings to the user:
- Storm: [N] findings above threshold ([severity breakdown])
- Cartographer: [N] findings above threshold (or "skipped — visual only")
- Build Monkey: [N] findings across [M] verticals, [X] surfaced, [Y] filtered
- Filtered: [N] total findings sent to filtered-findings.md
- Use
AskUserQuestion: "Verify step complete. [N] findings surfaced, [M] filtered. Proceed to consolidate and fix?" Options: "Proceed to fix pipeline / Discuss findings first / Stop — need to rethink"
3c: Consolidate + Fix Pipeline (Confidence-Filtered)
Step 1: Consolidate all findings into .insightsLoop/current/findings-consolidated.md — same format as devloop (Source, Phase, Location, Issue, Severity, Status columns). Include Confidence column from Storm/Cartographer. Monkey findings use their own confidence scale.
Location column contract: Same as devloop — file.ts:33 for actionable, [concept] prefix for conceptual (straight to Backlog).
Step 2: Triage using the fix dispatch matrix (same as devloop). Additional filter for speed mode: only 80+ confidence findings enter the pipeline. Below-threshold → filtered-findings.md.
Findings Dispatch Matrix (Monkey + Storm TDD)
Same as devloop — findings are dispatched to the right crew member, not handled by the orchestrator. In speed mode, Storm TDD dispatch (Sentinel) skips the user gate.
| Source | Step | Finding Type | Dispatched To | Speed Mode Behavior |
|---|
| Monkey | Frame | Scope/triage challenge | Orchestrator (frame.md is not code) | Auto if doesn't change triage, gate if it does |
| Monkey | Frame | Conceptual finding | Backlog | Logged in monkey-frame.md |
| Storm | TDD | Missing test contract | Sentinel (re-invoke) | Auto-dispatch, no user gate |
| Storm | TDD | Over-testing / wrong abstraction | filtered-findings.md | Logged, not auto-fixed in speed mode |
| Monkey | Build | Any finding with file:line, 80+ confidence | Enters consolidated findings | Goes through fix dispatch matrix below |
| Monkey | Build | Below 80 confidence or conceptual | filtered-findings.md / Backlog | Logged, not auto-fixed |
Fix Dispatch Matrix
The orchestrator NEVER writes, edits, or patches code. All fixes go through crew agents.
Same matrix as /insight-devloop:
| Finding Type | Route | Who Specs | Who Tests | Who Fixes |
|---|
| Storm critical/high (has file:line, 80+ confidence) | Full pipeline | Storm (Fix Spec) | Sentinel (regression test) | Shipwright (patch) |
| Storm consistency — assumption mismatch (80+) | Full pipeline | Storm (Fix Spec) | Sentinel (regression test) | Shipwright (patch) |
| Storm consistency — naming only (80+) | Shipwright-direct | N/A | N/A | Shipwright (rename) |
| Cartographer — data corruption/crash (80+) | Full pipeline | Storm (Fix Spec) | Sentinel (regression test) | Shipwright (patch) |
Monkey Survived: no, high confidence, has file:line | Full pipeline | Storm (Fix Spec) | Sentinel (regression test) | Shipwright (patch) |
| Below 80 confidence | filtered-findings.md | — | — | — |
[concept] or low severity | Backlog | — | — | — |
Step 3: Fix pipeline — same two routes as devloop:
Full pipeline (3 agents, sequential):
- Storm Fix Spec Mode — paste Storm SKILL.md verbatim, write context to
brief-storm-fixspec.md with triaged findings
- Sentinel regression tests — paste Sentinel SKILL.md verbatim, write context to
brief-sentinel-fix.md with fix specs
- Shipwright patches — paste Shipwright SKILL.md verbatim, write context to
brief-shipwright-fix.md with fix specs + failing tests
Shipwright-direct (naming/renames):
- Shipwright receives Storm consistency table with canonical forms, applies renames, runs existing tests
User gate: "Fix pipeline patched N findings. Approve?" Max 2 attempts per finding.
Step 4: Update consolidated report status column.
3d: Verify clean
Run full test suite + typecheck.
Step 4: Done
Same as /insight-devloop — write summary.md, archive the run. One addition to summary:
## Filtering
- Surfaced: [X findings]
- Filtered: [Y findings → filtered-findings.md]
- Monkey: [X challenges across 2 steps (Frame + Build), Y survived, Z didn't]
- Storm TDD: [X test gaps found]
Archive keeps extra files: filtered-findings.md, findings-consolidated.md, fix-specs.md, scaffolding-checklist.md, storm-plan.md, storm-tdd.md, and mockup.html (all if exists) are preserved in the run directory alongside the standard archive set (summary, plan, monkey-frame, monkey-build, storm-report). Discard: frame.md, edge-cases.md, brief-*.md.
Model Assignment
Same as /insight-devloop. Monkey is Opus.
User Gates
Every decision point that requires user input MUST use the AskUserQuestion tool. Never present a decision as plain text — the user may not realize you're waiting. Plain text looks like the agent is still working. AskUserQuestion makes it unmistakable.
Speed mode reduces gates but doesn't eliminate them. The ones that remain are non-negotiable.
Mandatory gates (always use AskUserQuestion):
| When | Gate | Options |
|---|
| Step 1: Frame (architectural only) | Approve triage and scope | Approve / Adjust / Abort |
| Step 1: Monkey would change triage | Monkey says the size is wrong | Re-triage / Override / Abort |
| Step 3a: Merge conflict | Files overlap between worktrees | Show both versions, user picks |
| Step 3b: Converge (after Storm + Cartographer + Build Monkey) | Present all surfaced findings before fix pipeline | Proceed to fix pipeline / Discuss findings first / Stop |
| Step 3d: After fixes + verify clean | Confirm shippable before archive | Ship / Fix more / Abort |
Not gated in speed mode (auto-proceed, logged):
- Frame approval for small/medium (auto-approved, logged)
- Monkey
Survived: no below confidence threshold (logged to filtered-findings.md)
- Storm TDD findings below critical/high (auto-dispatch to Sentinel or logged)
Rules
- Every user gate uses
AskUserQuestion. This is how the user knows you need them. No exceptions. If you're waiting for input, use the tool.
- The Monkey runs at Frame and Build. Storm handles TDD review. Each agent at its strength.
- Monkey and Storm TDD findings use the same filter. 80+ confidence or it goes to filtered-findings.md.
- One exception: triage correction. If the Monkey's Frame finding would change the triage size, act on it even if confidence is below 80. Getting the triage wrong cascades through every step.
- Sentinel and Shipwright are never the same agent.
- The orchestrator NEVER writes code. Not one line. Not a rename. Not a "quick fix." All code changes go through crew agents via the fix dispatch matrix. The orchestrator triages, dispatches, and presents — it does not edit files.
- Always use worktree isolation.
- Plan is a hard gate.
- Filtered findings are never deleted.
filtered-findings.md survives into the archived run. The user and /insight-retro can review it.
- Architectural changes always gate. If triage says architectural, this skill behaves exactly like
/insight-devloop.
- Archive runs, don't delete. Same as devloop.
- Same error handling as /insight-devloop. Merge conflicts, test failures, and typecheck errors still stop the loop. Speed mode doesn't mean reckless mode.
