big-task

Files (1)

• SKILL.md

SKILL.md (first lines)

# /big-task

One skill to route engineering work. Hides `/gsd-*`, `/audit-fix-loop`, `/pr-fix-loop`, `/codebase-sweep`, `/think-ultra`, etc. under a single memorable name.

**Auto-trigger:** User describes a task touching 3+ files or creating new functionality. See `rules/workflow.md` → Big Task Auto-Trigger.

**Override:** User says "skip workflow", "just do it directly", "quick and dirty" → drop to direct execution.

**Default bias: LIGHTER process.** GSD's multi-agent ceremony (plan-checker, CONTEXT/PLAN/SUMMARY docs, revision loops) only pays off when it catches real bugs that direct implementation would ship. For locked-design UI work, well-understood patterns, and single-responsibility additions, full GSD is pure overhead. Use risk, not file count, as the primary decision axis.

**Tier 4 engine routing — match the engine to the work shape, don't pick a single default:**

| Work shape | Engine | Why |
|---|---|---|
| Multi-phase implementation, 10+ tasks, clear dependency graph, expected runtime hours | `gsd-autonomous` (wave-based GSD) | Orchestrator stays ~15% budget, subagents self-load plan from disk, waves run parallel where deps allow. Built for long autonomous runs. |
| Pattern N+1 at scale (20-screen locked-design migration, API rename across 50 files) | `gsd-autonomous` | Mechanical parallel work across disjoint files is GSD's home turf. |
| Exploratory feature, novel pattern, architecture decisions required, spec unclear | superpowers (`brainstorming` → `writing-plans` → `subagent-driven-development` → `requesting-code-review` → `verification-before-completion`) | Strong on judgment and two-stage review gates. Serial per-task but catches spec drift before ship. |
| User says "brainstorm this" / "not sure where to start" | superpowers | Its strength. |

If unclear, **silently pick `superpowers`** (judgment-strong, two-stage review gates — safer default for ambiguous engine choice). Log the choice in the PR's `## Autonomous decisions` section. Do NOT ask the user — see Phase -1.

The `/gsd-*` **planning** overhead (CONTEXT / PATTERNS / RESEARCH / REVIEW / VALIDATION / VERIFICATION meta-artifacts per phase) is real — don't pay it for small Tier 4 work. But the **execute-phase engine itself is lean** (~15% orchestrator), so don't penalize GSD for the planning-phase overhead when long autonomous runs are the actual need.

---

## Phase -1 — Autonomous-by-default mode (DEFAULT ON — overrides every "ask once" elsewhere in this skill)

Once `/big-task` is invoked, the entire flow runs autonomously through to PR-merged. **Do NOT pause for confirmation between phases, between fix loops, between commits, between detection routings, or between audit rounds** unless one of the **Critical Decision Triggers** below is hit.

The user already opted into autonomous execution by invoking this skill — every additional checkpoint is friction they explicitly do not want. If the skill's wording elsewhere says "ask once" / "surface to user" / "wait for confirmation", **this section overrides it** unless the situation matches a Critical Decision Trigger.

### Critical Decision Triggers (the ONLY 4 reasons to pause)

Pause and ask the user ONLY if the next action falls into one of these classes:

1. **Irreversible architectural choice** — picking a database engine, ORM, primary framework, monorepo tool, deployment target, auth provider, or anything else that future code will copy and that costs >1 day to undo.
2. **Money / secrets / PII boundary** — code that moves money (charges, refunds, credits), introduces or rotates secrets, exfiltrates PII, or alters access boundaries (auth scopes, RBAC, row-level security, payment paths).
3. **Requirements ambiguity that would invalidate already-shipped work** — the user's prompt has multiple readings AND picking the wrong reading would mean reverting a meaningful chunk of already-committed code. Surface ONLY when re-reading the prompt twice still doesn't disambiguate AND there's no safer "do both / do neither" middle path.
4. **User-facing breaking change** — public API contract change, data migration that requires user action, removal of a documented feature, force-push to a shared branch.

If the next action is NOT in one of those 4 classes, **proceed without asking.** Pick the more conservative path silently and log the choice in a `## Autonomous decisions` section of the final PR description so the user can audit after-the-fact.

### Auto-resolutions (replace every "ask once" prompt with these silent defaults)

| Previously asked | Now silently picks |
|---|---|
| Tier 4 engine routing unclear (GSD vs superpowers) | **superpowers** (judgment-strong, two-stage review) |
| `light-project` task looks tier-4 (escalation exception) | **escalate to tier 4 silently**, note in PR `## Autonomous decisions` |
| Auto-detected profile looks wrong | **trust the auto-detect**; only re-route if 2+ phases produce FLAG verdicts pointing at the wrong profile |
| Tier rubric ambiguous | **pick the lighter tier** (per existing "bias toward lighter tier" rule) |
| Phase 2g visual verification: FLAG items | **open a TodoWrite follow-up**, continue to next phase. Surface ALL flagged items as a batch at end-of-milestone — never one-at-a-time mid-flight |
| Phase 2g visual verification: BLOCK items | **open a fix task and execute it inline** before declaring phase verified. NO confirmation needed — BLOCK = ship-blocking by definition, fix it |
| audit-fix-loop convergence | **run to convergence — fix every issue found, regardless of severity.** If it was worth flagging at confidence ≥80, it's worth fixing. Cap at 5 rounds. If still not converged, route remaining issues to a fresh opus subagent (one per cluster) rather than deferring. |
| pr-fix-loop "ready to merge?" | **DO ask before final merge** if no auto-merge configured (merging is itself a critical action — class 4). Otherwise proceed |
| Between-phase progression | **NEVER ask** when context usage < 40%. Proceed automatically once current phase verification is GREEN + multipass review clean. At ≥40% context, MAY surface ONE concise checkpoint: "Phase X complete (Y% used). Continue / compact / split?" — capacity decision, not review approval. See `rules/workflow.md` → Review Discipline → After review + fix |
| Between commits within a phase | **NEVER ask.** Commit per logical unit per `rules/workflow.md` `## Git` |
| Round 1 audit produced findings | **fix them and continue to Round 2 silently.** No "should I fix these?" prompt |
| Code review findings (any severity — CRITICAL / HIGH / MEDIUM / LOW / NIT / INFORMATIONAL) | **fix all of them.** Severity controls *how* (inline vs subagent), not *whether*. See "Fix routing" below. Never defer based on severity alone — including review-bot "non-blocking" findings. The audit already paid to find it. AX does not review — agent runs the multipass chain autonomously per `rules/workflow.md` → Review Discipline. |
| Plan / spec / design artifact produced (PLAN.md, ROADMAP.md, UI-SPEC.md, AI-SPEC.md, etc.) | **NEVER ask AX to review long-form artifacts.** Run `gsd-plan-checker` / `plan-design-review` / `gsd-ui-checker` autonomously and fix every finding (per severity rule). AX reviews ONLY if a sign-off gate is set (then surface a ≤10-line summary — objective, scope, risks, acceptance criteria — NOT the full doc) OR a Critical Decision Trigger fires. |
| End-of-phase commit needed | **commit autonomously** with conventional-commit message + HEREDOC body. Per `rules/workflow.md` `## Git` |
| Phase verification GREEN → next phase | **always invoke `neat-freak` first** (Phase 2f knowledge sync), then commit code + doc edits together. Skill is idempotent — safe to run every phase. No ask. |
| Open PR after final phase | **open it autonomously** (per Phase 6a). Don't ask "ready to PR?" |

### Fix routing — inline vs subagent (severity-agnostic)

Once an issue is flagged, it WILL be fixed. The only question is who fixes it. Pick by **cost to main thread**, not by severity:

| Route to | When (any one trigger) |
|---|---|
| **Inline (main thread)** | Touches ≤2 files · mechanical change (rename, add type, remove dead code, fix typo) · well-understood domain · estimated ≤500 lines of code to read · no new tests needed |
| **Opus subagent** (`feature-dev:code-reviewer` for review-fix, or task-scoped agent for new-code fixes) | Touches 3+ files · requires deep refactor · unfamiliar domain (new lib, new pattern) · estimated 500+ lines to read · touches concurrency / race / security / payment / auth / data-mutation logic (regardless of size — these always go to opus for the extra reasoning budget) · requires test scaffolding for new behavior |

Subagent contract: receives `{issue_id, file_paths, severity, finding_text}`, loads context from disk, applies fix, runs build+typecheck+lint+tests, returns `{status: FIXED|BLOCKED, files_touched: [...], commit_sha}` ≤200 tokens. Main thread aggregates, never sees raw fix output.

**Anti-pattern to avoid:** flagging an issue at confidence ≥80 and then "deferring as MINOR follow-up" because it's tedious. That's the exact failure mode the user called out — the audit found it, so fix it. If the fix is expensive, that's what subagents are for.

### How to ask when a Critical Decision Trigger IS hit

Format (≤ 3 sentences total):

```
[CRITICAL DECISION] <one sentence: what's at stake and why this is class N>
A) <option> — <consequence>
B) <option> — <consequence>
Pick A / B / or describe a third path.
```

No essay. Just the decision. Then **wait** — do not proceed until user answers.

### Mid-flight escape hatch (user-initiated)

User can interrupt at ANY point with: "stop", "pause", "wait", "let me look", or by hitting Ctrl-C. Respect interruption immediately. Resume on user's explicit "continue" / "go" / "proceed" / "moveon".

### Status updates while autonomous

While running autonomously, emit ONE short progress line per phase boundary (≤ 80 chars):

```
▸ Phase 2b · parallel-worktree (4 tasks) · running
✓ Phase 2b · 4/4 green · committed (a1b2c3d) · → Phase 2c
✓ Phase 2c · review clean · → Phase 2g
✓ Phase 2g · 6/6 PASS · → Phase 6a
```

NOT a multi-paragraph essay per phase. The user will read commits + PR description for detail; mid-flight chatter steals their attention without informing them.

### Final report (at PR-opened or PR-merged)

ONE summary block (per existing Exit section, augmented):

```
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 /big-task ▸ COMPLETE  (autonomous run)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 Phases shipped: N
 Commits: N      LOC: +A / -B
 Tests: unit X / integ Y / e2e Z
 Autonomous decisions made:
   • <decision 1 — what was silently picked and why>

From xingfanxia/ax-claude-config-public, MIT.

More from xingfanxia/ax-claude-config-public