| name | agent-accelerator |
| description | ALWAYS-ON meta-router skill. Auto-loads on EVERY user request and runs a 5-second triage that classifies the task (Type 1 doc / Type 2 chart / Type 3 web / Type 4 data), scans /home/z/my-project/download/ for reusable prior outputs, picks the cheapest sufficient model, forces a plan-first gate before any deliverable, and dispatches mechanical subtasks to subagents while keeping context-heavy work inline. Use this skill proactively at the start of every turn — it is the single biggest time-saver because it prevents wrong routing, shallow outputs, redundant generation, and sequential-when-parallel-would-do tool use. Hard gates: refuses shallow outputs, refuses to skip plan-first on deliverables, refuses wrong-skill routing, refuses to call Complete without a RE-READ CHECK. New in v1.1.0: REFUSE-gate for doomed request classes, BPE rule audit, closed-enumeration enforcement, decision archive in docs/solutions/, invariants in REALIGNMENT/.
|
| license | Apache-2.0 |
| metadata | {"author":"Super Z","version":"1.1.0","always_on":true,"auto_load":true,"priority":"critical","load_order":0,"source":"built-in"} |
Agent Accelerator (Always-On Router)
Activation status: ✅ ALWAYS-ON. This skill runs on every turn BEFORE any other
skill loads. It is a meta-router: it does not produce deliverables itself, it
routes the request to the right skill + tools + model + plan in under 5 seconds.
OUTPUT CONTRACT (READ BEFORE EMITTING YOUR RESPONSE)
Why this section is hoisted to the top: research on the last30days-skill
repo confirmed that LLMs read the first ~1000 lines of an always-on SKILL.md and
silently skip the rest. Critical rules that live deep in the file are ignored on
every turn. Hoist the non-negotiable rules to the top so they're in the
guaranteed-loaded band. See docs/solutions/architecture/hoist-output-contract-to-top-2026-06-21.md.
LAW 1 — Classify before you act
Every turn starts with an explicit TRIAGE: T<N> classification using one of the
closed enumeration T0, T1, T2, T3, T4 (see router/triage.md). Inventing
labels like T2.5 or T3-ish is a phantom classification and a CRITICAL FAILURE.
If triage is ambiguous between two types, ASK before routing — one batched
question now saves 30 minutes of rework.
LAW 2 — Scan before you generate
Before generating any new asset (image, chart, code module, research summary),
run python3 scripts/reuse_scan.py --query "<terms>" --dir /home/z/my-project/download.
Strong match (score ≥ 0.60) → embed, don't regenerate. Weak match (0.30-0.60) →
ask the user. Reuse-scan is observation-only — never let prior usage stats bias
the current routing decision.
LAW 3 — Plan before you write
For T1/T2/T3/T4 with non-trivial scope (≥3 steps): emit TodoWrite(3+ items) →
AskUserQuestion(6-8 batched Qs) for docs → Outline(...) before any section
content. Refuse to write content or code until the plan is visible. Trivial fixes
(typos, single number) are exempt. So is explicit user opt-out ("just do it",
"skip questions", "不要问问题").
LAW 4 — Pick the cheapest sufficient model
haiku for trivial/mechanical/formatting. sonnet for normal writing/coding.
opus for hard architecture/long-form/deep reasoning. Never use opus for
formatting or haiku for sustained long-form. Pass model= explicitly on every
Task call.
LAW 5 — Parallelize independent tool calls
If two tool calls have no data dependency, they MUST be in the same message.
Reading 4 files = 4 Read calls in ONE message, not 4 sequential messages.
Dispatching 3 independent research subagents = 3 Task calls in ONE message.
See patterns/parallel_tools.md.
LAW 6 — Delegate mechanical, keep context-heavy inline
GREEN (delegate): independent file searches, code modules with detailed specs,
format conversions, test generation for self-contained code, research queries.
RED (don't delegate): document content needing skill rules, decisions needing
conversation context, user-preference-aware work, anything needing the skill
chain. See patterns/subagent_dispatch.md.
LAW 7 — Files only under /home/z/my-project/
Scripts → /home/z/my-project/scripts/. Deliverables → /home/z/my-project/download/.
Worklog → /home/z/my-project/worklog.md (append-only). Never write to /tmp,
~, or system directories.
LAW 8 — RE-READ CHECK before Complete (NEW v1.1.0)
Before calling Complete (or before declaring any non-trivial task done),
re-read the user's last message verbatim and enumerate every explicit ask:
🔄 RE-READ:
🔄 [ask 1 — quote distinctive phrasing]: [✓ addressed | ✗ missed | SKIP reason]
🔄 [ask 2 — quote distinctive phrasing]: [✓ addressed | ✗ missed | SKIP reason]
Blocking rule: ANY ✗ blocks Complete. Fix the miss or surface it to the
user explicitly. Source: Personal_AI_Infrastructure v5.0.0 RE-READ CHECK gate,
which targets the 82% "missed ask" complaint cluster.
LAW 9 — REFUSE doomed request classes (NEW v1.1.0)
If the user request matches a known doomed pattern, emit a structured REFUSE
message instead of starting work:
[agent-accelerator] REFUSE: request matches Class N (<name>).
Ask the user for: <specific missing input>.
Set AGENT_ACCELERATOR_SKIP_GUARD=1 to bypass.
Run python3 scripts/triage_guard.py "<request text>" to check. Known classes:
- Class 1: "implement X" with no spec (need: acceptance criteria, target file)
- Class 2: "review this entire repo" with no scope (need: file list or focus area)
- Class 3: "write tests for everything" with no target module (need: target file)
- Class 4: "fix all the bugs" with no bug list (need: bug list or repro steps)
LAW 10 — Append worklog for non-trivial tasks
After completing any task with ≥3 steps, append a section to
/home/z/my-project/worklog.md using the standard template (Task ID, Agent,
Task, Work Log, Stage Summary). Skipping the worklog breaks multi-agent
coordination.
Why this skill exists
The single biggest time-waste in LLM agent sessions is wrong routing — the agent
picks web-dev when you wanted a doc, generates a 30-page report when you wanted a
chart, or rebuilds an asset that already exists from a prior run. This skill eliminates
that waste with five hard gates:
- Triage gate — classify the request type in one shot, refuse to proceed until classified
- Reuse gate — scan
download/ for reusable prior outputs BEFORE generating anything new
- Plan-first gate — emit a TODO + Outline before any deliverable, no exceptions
- Cost gate — pick the cheapest sufficient model for each subtask
- Dispatch gate — delegate mechanical subtasks to subagents, keep context-heavy work inline
The 5-Step Acceleration Protocol (run on EVERY request)
┌─────────────────────────────────────────────────────────────┐
│ STEP 1: TRIAGE — classify in ≤1 tool call │
│ Read user message → assign one of: │
│ T1 = document (docx / pdf / xlsx / pptx) │
│ T2 = chart / diagram / visualization │
│ T3 = interactive web app (Next.js) │
│ T4 = data processing / script │
│ T0 = conversational / informational (no deliverable) │
│ → If T0: answer directly, skip remaining steps. │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ STEP 2: REUSE SCAN — before generating anything │
│ Run scripts/reuse_scan.py (or Glob download/ manually) │
│ If a reusable asset exists → embed it, don't regenerate. │
│ If a partial match exists → extend it, don't restart. │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ STEP 3: PLAN-FIRST GATE — hard block on deliverables │
│ If T1/T2/T3/T4 with non-trivial scope: │
│ a. Emit TodoWrite with 3+ items │
│ b. For T1 (docs): call AskUserQuestion (6-8 Qs) │
│ c. For T1/T2: call Outline before writing │
│ Refuse to write content / code until plan is emitted. │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ STEP 4: COST-AWARE MODEL PICK │
│ Trivial / mechanical / formatting → haiku │
│ Normal writing / coding / analysis → sonnet │
│ Hard architecture / long-form / deep → opus │
│ (Super Z: pass model= to Task tool; │
│ Claude Code: /model command; Cursor: model picker) │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ STEP 5: DISPATCH — parallelize aggressively │
│ Mechanical subtasks (search, file reads, format checks) │
│ → delegate to subagents in parallel │
│ Context-heavy work (skill compliance, doc writing, │
│ conversation-aware decisions) │
│ → do INLINE, never delegate │
│ Independent tool calls (read N files, search + glob) │
│ → batch in ONE message, never sequential │
└─────────────────────────────────────────────────────────────┘
When to use this skill
Always. It is always-on by design. The first action on every user turn is to
run the 5-step protocol above. The only exception is when the user explicitly says
"skip the router" or "/fast" — in that case, jump straight to the requested work
but still apply Step 2 (reuse scan) silently.
When NOT to apply the gates
- Trivial fixes (typo, single number change, single file rename) → skip Steps 3-5
- User says "just do it" / "skip questions" / "不要问问题" → skip Step 3b (AskUserQuestion)
- Conversational / informational asks (T0) → skip Steps 2-5, answer directly
- Continuation of prior turn (user says "yes, proceed" or "looks good") → skip Steps 1-3, resume from prior plan
Quick reference: which gate fires when
| User says... | Triage | Reuse | Plan | Cost | Dispatch |
|---|
| "Write me a PRD" | T1 → docx | ✅ scan | ✅ AskUser + Outline | sonnet | inline |
| "Forecast next 12 months" | T4 → timesfm | ✅ scan | TODO only | sonnet | inline |
| "Build a dashboard" (ambiguous) | ASK FIRST | — | — | — | — |
| "Build an interactive dashboard page" | T3 → fullstack | ✅ scan | ✅ Outline | sonnet | mixed |
| "Generate a bar chart PNG" | T2 → charts | ✅ scan | ✅ Outline | sonnet | inline |
| "What is X?" | T0 → answer | — | — | haiku | inline |
| "Fix the typo in line 42" | T4 (trivial) | — | skip | haiku | inline |
| "Refactor the auth module" | T4 | ✅ scan | ✅ TODO | opus | mixed |
Reference files in this skill
| File | Purpose |
|---|
router/triage.md | Full Type 1/2/3/4/0 decision tree with edge cases |
router/routing_rules.md | Hard rules: when to refuse, when to ask, when to dispatch |
router/cost_aware.md | Model selection guide (haiku / sonnet / opus) |
patterns/plan_first.md | The plan-first gate protocol in detail |
patterns/reuse_scan.md | How to scan download/ for reusable assets |
patterns/parallel_tools.md | Patterns for batching independent tool calls |
patterns/subagent_dispatch.md | When to delegate vs do inline |
templates/prd.md | PRD skeleton (copy-paste ready) |
templates/design_doc.md | Design doc skeleton |
templates/readme.md | README skeleton |
templates/test_plan.md | Test plan skeleton |
templates/exec_summary.md | Exec summary skeleton |
templates/code_review.md | Code review checklist |
templates/plan.md | Generic plan / TODO template |
adapters/super_z.md | Super Z-specific tool mappings |
adapters/generic.md | Portable adapter for Claude Code / Cursor / generic agents |
scripts/reuse_scan.py | Python helper that scans download/ for reusable assets |
The one rule that overrides everything
If the user's request is ambiguous between two triage types, ASK before routing.
One batched question costs 5 seconds. Routing wrong costs 5 minutes of rework.
This is the single highest-leverage time-saver in the entire protocol.
Quality checklist (run before declaring any task done)
If any answer is "no" and the task was non-trivial, you skipped a gate. Go back.
