---
name: ca-feature
description: "Start a feature: brainstorm a spec, get it approved, then drive it test-first through the pipeline. The one entry to implementation."
argument-hint: "<what you want to build>"
---

# $ca-feature — spec-driven feature

The single permitted entry to implementation work. No feature code is written before a spec is approved and `tdd` Phase 1 clears. A one-line idea is not a spec — `brainstorming` makes it one.

**Orientation:** if `.codearbiter/code-map.md` is present, read it first — a coarse concern→path→role map that orients task authoring. Absent is fine; it is read-on-demand, populated by context-creation or commit-gate heal.

## Resume — an interrupted pipeline is re-entered, never restarted

Before triage, scan `<project-root>/.codearbiter/specs/` and `plans/` for an existing slug
matching `$ARGUMENTS` (invoked bare, list every resumable pipeline and ask which). A crash,
compaction, or closed session mid-pipeline loses nothing — the spec, the plan, and each task's
`status` cell are on disk. On a match, confirm the resume with the user in one line
("resume `<slug>` at <point>?") and re-enter at the furthest checkpoint reached:

1. **Plan exists with non-`ACCEPTED` tasks** → `executing-plans` (its Phase 1 batches only the
   remaining tasks).
2. **Plan exists, every task `ACCEPTED`** → `commit-gate` (the work is done and verified; it was the
   commit that never happened).
3. **Spec approved, no plan** → `writing-plans`.
4. **Spec exists but never approved** → `brainstorming`, at its approval gate — not from scratch.

Re-running `brainstorming` against an already-approved spec is the failure mode this section exists
to prevent: it discards approved decisions and re-asks answered questions. Only an explicit user
request ("start over") restarts an existing slug — and that is logged to `triage.log` like any
classification.

## Step 0 — change-class triage (logged)

Before routing, classify the request. The **small lane** applies only when ALL of these hold —
judged against `$ARGUMENTS` and a quick look at the code, never assumed:

- the change touches ≤ 2 implementation files (plus their tests);
- no §4 reference-map scope-touch: auth/crypto/secrets, dependencies, migrations/schema, telemetry,
  public API surface, domain vocabulary;
- no new dependency, endpoint, command, or configuration surface;
- the behavior change is expressible as 1–3 concrete, individually testable acceptance criteria.

**Small lane:** state the mini-spec inline (the 1–3 criteria) and STOP for the user's one-reply
confirmation. On confirmation, append one line to `<project-root>/.codearbiter/triage.log`
(append-only, `>>`):

```
[ISO-8601 timestamp] | BY: <git user.email> | LANE: small | SCOPE: <one-line> | BASIS: <criteria met>
```

Then route directly to `tdd` — the confirmed criteria are its Phase 1 obligations; Phases 2–6 run
unchanged — and exit through the full `commit-gate` and `finishing-a-development-branch` exactly as
the full lane does. The lane trims ceremony, never gates.

Any criterion violated, or uncertain → **full lane** (below). Uncertainty is full-lane; the triage
never guesses.

## Flow — full lane

Route through the pipeline in order; each step gates the next:

1. **`brainstorming`** — refine `$ARGUMENTS` into a concrete spec by Socratic questioning: challenge
   vague language, surface hidden complexity, force trade-offs. Writes the spec to
   `<project-root>/.codearbiter/specs/<slug>.md`. **Hard gate: no plan and no code until the
   user approves the spec.** Genuinely-unresolved unknowns become `[CONFIRM-NN]` in
   `open-questions.md`, never guesses.
2. **`writing-plans`** — decompose the approved spec into small tasks, each with an exact path and a
   verification that maps to a `tdd` obligation (it does not replace one). Writes
   `<project-root>/.codearbiter/plans/<slug>.md` with bijective criterion↔task coverage.
3. **`executing-plans`** — coordinates the plan in small batches with human checkpoints. Each batch is
   delegated to `subagent-driven-development` (fresh author agent per task, spec-compliance review,
   quality review, fresh verification). The user acknowledges between batches; nothing advances until
   they do.
4. **`commit-gate`** — the only path to a commit; nine gates, including behavioral proof.
5. **`finishing-a-development-branch`** — terminal step: open-PR / merge-via-PR / discard. Every
   change lands through a PR; never a direct write to the default branch.

The autonomous counterpart (`$ca-sprint`) runs the same spec→plan but passes the full plan to
`subagent-driven-development` directly, without per-batch checkpoints. That path is its own entry,
not `/feature`.

## Scope routing

Scope determines which author agent `subagent-driven-development` dispatches per task:
`backend-author`, `frontend-author`, or `infra-author` — per the mapping in `tech-stack.md`. A
multi-area feature runs the appropriate agent per task; the full suite must be green before
transitioning between scope areas.

## When NOT to use

- A known defect with a reproduction → `/fix`.
- A behavior-preserving restructure → `/refactor`.
- A question or quick discussion → `/btw`.
- Persisting work already written → `/commit`.

## Hard gate

MUST NOT write feature code before a spec is approved AND `tdd` Phase 1 clears — the brainstormed
spec in the full lane, the user-confirmed mini-spec in the small lane. MUST NOT take the small lane
unless every Step 0 criterion holds, and MUST log the classification to
`.codearbiter/triage.log` before `tdd` begins. MUST NOT skip `writing-plans` in the full lane.
MUST NOT resolve a `[CONFIRM-NN]` in the spec by guessing — surface it.
MUST NOT restart an interrupted pipeline whose artifacts exist on disk — resume at the furthest
checkpoint per the Resume ladder, unless the user explicitly asks to start over.