Command: SDLC Fast (Override)

This is an override entry point, not the primary path. The primary, autonomous path is Phase 0: Triage inside skills/develop-feature/SKILL.md — read it first if you have not already — which classifies every request into fast/quick/full on its own, with no human involvement. /sdlc-fast exists only so a developer can explicitly overrule that verdict and assert fast tier directly. It is never invoked by the pipeline itself, and no run needs it in order to complete (NFR-2) — it is a human-typed escape hatch, not a step in the normal flow.

Arguments

The change to make is $feature (also available as $ARGUMENTS). When it is empty, ask the user what to change before doing anything else — do NOT infer a change from surrounding context.

Literal-token activation only (FR-6.3)

This skill activates ONLY because it was literally invoked as /sdlc-fast <description> — an actually-invoked slash command, the same literal-token discipline already governing no-changelog and every other documented flag in this harness. A request's prose containing a word like "quick," "fast," "small," or "trivial," submitted as ordinary conversational text rather than this literal command, does NOT activate this skill and MUST still be classified by Phase 0 Triage in skills/develop-feature/SKILL.md unmodified — including being forced to full by one of its full-forcing signals if applicable. Nothing in this file infers activation from vocabulary; only the literal token does.

What this bypasses, and what it does not (FR-6.2)

Invoking this skill skips Phase 0 Triage entirely: no estimated file set is stated as a classification input, no full-forcing/fast-tier/quick-tier signal check runs, and no tier: ... reasoning is produced or considered. The human asserts the tier; the pipeline does not compute it. The override skips classification, never the safety rails — FR-2's escalation rules (restated in full below, self-sufficiently, so this file never depends on skills/develop-feature/SKILL.md being read first for its own execution) still apply once this skill is running.

Fast Tier Execution (FR-3) — run this directly against $feature

1. State the estimated file set. Before editing, state in your own response the specific file you expect this change to touch — exactly one file. This is required output: the escalation check below compares what actually happens against it.
2. Direct edits, no subagents, no documentation (FR-3.1): make the Edit/Write call directly to that one file. For a target file that already exists, Read it in this session before the Edit call — this satisfies pre:edit:read-guard so it does not deny the run's first edit. A Write creating a brand-new file requires no prior Read. Create or modify no docs/PRD.md, docs/use-cases/*, or docs/qa/* file for this change, and write no plan to .claude/scratchpad.md's ## Plan section.
3. Verify with the project's own declared command (FR-3.2): after editing, run the project's declared build/typecheck command directly via a Bash call — read the command from the project's CLAUDE.md, and no-op visibly when none is declared.
4. Commit unchanged (FR-3.3): follow src/rules/git.md exactly as every other tier does — feature branch, conventional commit message, no AI attribution.
5. Changelog — mandatory, sole owner (FR-3.4): after a successful commit, write ONE CHANGELOG.md entry directly, following the standalone-fix procedure skills/implement-slice/SKILL.md Step 6 already defines (real date -u +'%Y-%m-%d %H:%M' timestamp, idempotency guard, Summary + Details capped at 500 characters). No /merge-ready run occurs for fast tier, so this write is never suppressed by a no-changelog flag and is owned by nothing downstream — skipping it is not an option.
6. No scratchpad write (FR-3.5): a fast-tier run that does not escalate does not write to .claude/scratchpad.md at all — there is no multi-step state to persist.

The Agent grant is deliberate — the no-subagent rule is instruction-enforced, not structural (C2, binding — never tighten)

allowed-tools above grants Agent, deliberately. This is load-bearing, not an oversight: FR-2.1's mandated fast → quick escalation requires invoking planner, test-writer, and build-runner — all Agent calls. An earlier draft withheld Agent to enforce step 2's "no subagent" rule structurally — but that would dead-end the run at the exact moment an /sdlc-fast edit needed a second file: there would be no tool left capable of invoking planner to escalate, an unrecoverable stall that directly violates the autonomy contract (NFR-1(b)) this override skill must still honor. Withholding Agent is therefore not an option — the grant stays, and it is not a mistake to fix.

Because of that, the "no subagent" rule for the ordinary, non-escalated fast path (step 2 above, FR-3.1) is enforced by instruction in this file's body, not by the tool grant — this is explicitly NOT a structural guarantee, the same model-discipline posture the rest of this feature's tier-boundary enforcement already accepts (FR-2.7). Follow it exactly: make zero Agent/Task tool calls while genuinely operating under fast-tier discipline. The only thing permitted to issue an Agent call from this skill is the escalation mechanics below, and only once one of their triggers actually fires.

Escalation: One-Way Tier Changes (FR-2) — restated self-sufficiently

FR-2's escalation rules still apply once this skill is running — the override skips Phase 0 Triage's classification, never these rules. Both transitions below share three properties: every trigger is checked BEFORE the Edit/Write call that would fire it, never after that call has already been made; escalation moves in exactly one direction, fast → quick → full, never sideways and never back down; and at full — the escalation ceiling — the pipeline's existing Rule 4 stop-and-ask behavior from src/rules/error-recovery.md is preserved unmodified rather than redirected.

Fast → Quick (FR-2.1)

Check BEFORE issuing each Edit/Write call — never after it has already been made — whether that call would target:

• a file outside the estimated file set stated in step 1 above, OR
• a path the sensitive-path defaults mark sensitive: any path containing auth, payment, billing, secret, or migration as a path segment (case-insensitive); any path under .github/workflows/; install.sh; .claude/settings.json; docs/PRD.md; plus any additional glob a project's .claude/rules/security.md declares under a ## Sensitive Paths section — union, never a replacement of the fixed defaults, and never capable of narrowing them.

If either is true, do NOT make that call under fast-tier discipline. Escalate to quick first:

1. State the escalation, verbatim, naming the second file or the sensitive path.
2. Keep the edits already made. Never revert an already-made edit solely because of the escalation.
3. Record the done work. Set .claude/scratchpad.md's ## Tier: quick and a ## Feature: name, recording the already-touched file as already-completed context — using Edit if the scratchpad already exists, Write only if it does not (see the scratchpad-mutation idiom below).
4. Proceed under Quick Tier Execution (FR-4) for the remainder of the work: invoke planner exactly once under its Quick-Tier Contract mode, write the returned slice into .claude/scratchpad.md's ## Plan section as a single un-waved slice — with the already-touched file included in its Files:/Changes: fields as work already done — run /implement-slice against it with the literal no-changelog token, then run /merge-ready under its tier-aware gate subset.

Quick → Full (FR-2.2)

Once escalated to quick above, escalate again to full — overriding whatever default behavior the triggering condition would otherwise have — when EITHER:

• (a) a Rule 4 condition (src/rules/error-recovery.md — an architectural decision, a new dependency, an API contract change, a schema migration) is encountered during the TDD cycle. Do NOT stop and ask at quick tier — redirect to full instead; OR
• (b) an Edit/Write call about to be made — checked BEFORE issuing it, exactly as the fast→quick trigger above requires — would target a path the sensitive-path defaults above mark sensitive, or would bring the count of distinct files touched by this run's own Edit/Write calls above 3.

Mechanics, once either condition fires:

1. State the escalation, verbatim, naming the specific condition that fired.
2. Keep the quick-tier commit(s). Any already-committed quick-tier slice commit remains in place, never reverted.
3. Rewrite the tier field — the very first tool call after the escalation statement. Use Edit (never a whole-file Write) to change .claude/scratchpad.md's ## Tier: field from quick to full, immediately, before any further gate or agent invocation. This ordering is load-bearing: without it, /merge-ready's Tier Check preamble would read the stale quick value and silently run the reduced gate subset — skipping Gates 1, 5, 6, 7, and 8 — on a feature this escalation requires to get all 9 gates.
4. Invoke /bootstrap-feature for the full, now-larger scope, supplying the already-completed work as context, so prd-writer/ba-analyst/architect/qa-planner document it accurately rather than purely prospectively.
5. planner marks the already-satisfied slice DONE with its existing commit hash in the resulting plan — never re-implemented.
6. Proceed through the remaining slices and an unmodified, full 9-gate /merge-ready — indistinguishable at completion from a request classified full from the start.

full is the escalation ceiling (FR-2.5)

A Rule 4 condition encountered while already at full tier retains today's unmodified behavior: stop implementation, present to the user, and count against the retry budget. There is no higher tier to redirect to.

No automatic downgrade, ever (FR-2.6)

Once a tier is assigned — by this skill's own override, or by either escalation above — it MUST NOT be automatically lowered for the remainder of that run, regardless of what later evaluation of actual scope suggests.

The scratchpad-mutation idiom: Edit, never a whole-file Write

Every mutation of an existing .claude/scratchpad.md — the fast→quick tier/plan initialization above, the quick→full tier rewrite above, and planner's DONE-with-commit-hash recording — MUST use Edit, never a whole-file Write. pre:write:shrink-guard fires on Write only and denies a short new file replacing a long, pre-existing one, with no mid-session escape (SDLC_ALLOW_SHRINK=1 is an environment variable, unavailable mid-session). This idiom applies only when .claude/scratchpad.md already exists — a genuinely nonexistent scratchpad (the first-ever-feature case) legitimately uses Write, since that targets a file that does not yet exist and is therefore outside the guard's scope.

Rules

• NEVER add "Co-Authored-By" or AI attribution to commits.
• NEVER infer this skill's activation from a request's prose — only the literal /sdlc-fast token activates it (FR-6.3).
• NEVER issue an Agent/Task tool call while genuinely operating under non-escalated fast-tier discipline — the grant above exists solely to make the FR-2.1 escalation possible, not to invite subagent use in the ordinary case.
• ALWAYS state the tier's escalation trigger, verbatim, before making the triggering call — never after.