harness-claude

Bug-fix fast lane — the entry point for fixing something already broken (a red test, a prod error, a reported defect), not building a new feature. Does the bug-specific part — reproduce as a failing test, find the root cause, write a minimal fix-plan — then hands off to the existing pipeline (/implement → /review → /security-review → /verify → /ship) so the fix rides the proven gates. The non-negotiable discipline: reproduce as a failing test FIRST, fix minimally. Opt-in; invoked explicitly. Use when something is broken and you want it fixed under the harness's gates without over-ceremonying it through /spec.

Execute a plan via test-driven development — write tests first, then minimal code, phase by phase. Use after /plan (and /architect if needed) to write the actual feature. Delegates to the harness-claude:tdd-guide agent.

Review changed code for quality, correctness, and maintainability before merge. Use immediately after implementing or modifying code. Delegates to the harness-claude:code-reviewer agent. First gate of the Verify phase.

Confirm the change actually works by running the app/feature and observing real behavior — not just that tests pass. Use late in the Verify phase, before ship. Closes the loop between "tests green" and "it works."

Orchestrate the entire IMPLEMENT phase — test-driven implementation of the approved plan, resolving build/type errors as they arise. Use after /harness-plan. Sequences /implement and /build-fix, delegates to subagents, and halts if reality diverges from the plan.

Orchestrate the entire PLAN phase in one command — spec, research, plan, plan-check, and (if warranted) architecture. Use at the start of any non-trivial feature/change. Sequences the atomic skills, delegates to subagents, and pauses for your input at each decision gate.

Run the FULL SDLC pipeline end-to-end — Plan → Implement → Verify → Maintain — with a checkpoint between every phase. Use for a complete feature from a one-line idea to merge-ready. Chains the four phase orchestrators; you approve each phase boundary.

Supervise a long-running, unattended agent run — an autonomous loop or a scheduled wake-up — that self-checkpoints against the repo's eval skills so it can't silently drift. Rides the platform's /loop + /schedule; adds halting guardrails (iteration cap, wall-clock budget, drift) and durable run state. Opt-in; not wired into the default pipeline. Use when a task needs many iterations or to run on a cadence without a human watching each step.

Decompose a multi-file task, fan out to parallel workers in dependency-ordered waves, and reconcile their results — with a one-writer-per-file guarantee. The third orchestration mode (parallel fan-out) alongside sequential and iterative-retrieval. Rides the platform Workflow tool as the engine; the skill is the lead — it splits the work, groups tasks into waves by their declared dependencies, assigns disjoint file-ownership within each wave, dispatches workers under explicit contracts, and merges their summaries. Opt-in; not wired into the default pipeline. Use when a task spans 3+ files that can be grouped into waves of independent, disjoint-write-set work.

Adversarially review a plan against its spec before implementation — check that every acceptance criterion is covered, no scope crept in, and parallel tasks have disjoint write-sets. Use after /plan, before /implement. Read-only gate; delegates to the harness-claude:planner agent in a check pass. Non-blocking except on Critical.

Produce a phased, risk-assessed implementation plan from a spec. Use after /spec and /research, before writing code. Delegates to the harness-claude:planner agent for non-trivial work.

Load the most recent session file and re-establish context at the start of a new session. Use when continuing multi-session work. Pairs with /save-session.

Final pre-merge step — sync docs, then prepare a clean commit/PR summary. Use after verify passes. Does NOT commit or push unless you explicitly ask; it prepares everything and stops.

Turn a vague request into a clear, written spec with acceptance criteria before any code. Use at the start of any non-trivial feature, change, or bugfix. First gate of the Plan phase.

Make and record an architecture/design decision for non-trivial work — new subsystems, interfaces, data models, or significant refactors. Use when /plan flags a load-bearing decision. Delegates to the harness-claude:architect agent.

Craft + UX review of a user-facing change before merge — visual hierarchy, accessibility floor, and AI-slop tells, against an approval bar. Use in the VERIFY phase for any change that touched a UI surface, parallel to /security-review. Judges by default; reports severity-tagged findings, does not rebuild unless asked.

Reuse-first research before writing new code. Search existing libraries, registries, and codebases for something that already solves the problem. Use after /spec, before /plan. Mandatory for non-trivial implementation.

Security scan of changed code before merge — OWASP Top-10, injection, secrets, access control. Use for any change touching auth, input, queries, file I/O, external calls, crypto, or secrets. Delegates to the harness-claude:security-reviewer agent.

Discovery phase — the entry point ABOVE /spec, for when the user has a vague intent but doesn't yet know the shape of the answer or what's even possible ("make this better", "what could I build with X"). Turns vague intent into a framed problem + ONE chosen direction that /spec can consume. Divergent→convergent: interrogate the real goal, map a bounded set of options, then FORCE convergence to a single recommendation. Conditional — an already-clear request skips straight to /spec without ceremony. It frames the problem and picks a direction; it does NOT write acceptance criteria (that is /spec's job). Opt-in; invoked explicitly. Use at the very start when you know you want *something* but can't yet state *what*.

Release step that closes the loop after /ship — drive a change out to a running environment using the PROJECT'S OWN deploy mechanism (detect, never prescribe a stack), then smoke-test the deployed artifact and keep a guarded rollback path. Deploy is more outward-facing than git push, so it is arm-to-fire — plan and pre-check, then HALT and require an explicit `arm deploy` before any real outward action. Opt-in; invoked explicitly. Use after /ship to push a verified change to staging/prod under the harness's boundary discipline.

Feedback step that closes the loop from production back into the harness — take a signal you BRING to it (a pasted stack trace, log snippet, error text, or an issue/monitoring URL), triage it into a located, reproducible failure, and route it into the existing /fix lane. Bring-a-signal only — no polling, no credentials, no new MCP. It locates the failing area and shapes a repro SEED; it does NOT write the finished failing test — that is /fix's job. Opt-in; invoked explicitly. Use when production surfaced something and you want it fixed under the harness's gates.

Produce a product/UX/UI design brief before building a user-facing surface. Use in the PLAN phase after /plan, alongside /architect, when a change has a UI (dashboard, app, marketing page, mobile screen). Routes to the right craft rubric, overlays the accessibility/UX floor, and emits a brief that guides implementation. Self-skips when there is no user-facing surface.

Orchestrate the entire VERIFY phase — code review, security review, tests, run-the-app verification, and ship-prep. Use after /harness-implement. Sequences the Verify skills, runs reviewers in parallel when sensible, halts on Critical/High findings, and stops at the git boundary.

Build the minimum that actually works — question whether the task needs to exist (YAGNI), reach for stdlib before custom code, native platform features before dependencies, one line before fifty. A persistent generation-reduction bias for the Implement phase. Use when the user says "be lazy", "lazy mode", "minimal", "simplest solution", "do less", "yagni", or complains about over-engineering, bloat, boilerplate, or needless dependencies. Levels: lite, full (default), ultra. Off: "stop lazy" / "normal mode".

Take the target repo's health pulse on demand — run its test/lint/typecheck (and any extra) checks and emit one pass/fail summary. Auto-detects the repo's checks (package.json scripts or Makefile) with explicit --cmd override. Opt-in; not wired into the default pipeline. Output streams live but is never captured (secret-safe). Use to answer "is the repo green right now?" before shipping or after a major change.

Measure whether a harness component (a skill, agent, or rule) actually earns its keep — run the same task k times with and without it, in isolated git worktrees, and report pass@k (works once) and pass^k (works consistently). Opt-in; not wired into the default pipeline. Use to decide keep-vs-cut on evidence, or to fill the R5 benchmark for a /extract proposal.

Turn a repeatable workflow observed this session into a PROPOSED reusable skill — draft it, evaluate it against the rubric, and stage it for your approval. Never writes into skills/. Opt-in; not wired into the default pipeline. Use when a Stop candidate appears or a workflow felt worth keeping.

Checkpoint a change against its spec's acceptance criteria — run the machine-checks, adjudicate the prose ones, and gate ship until every criterion passes. Opt-in; not wired into the default pipeline. Use late in Verify, alongside /test and /verify.

Resolve build failures and type/compile errors fast, with minimal diffs. Use when a build or typecheck fails during implementation. Delegates to the harness-claude:build-error-resolver agent.

Orchestrate the MAINTAIN phase — understand the codebase (if unfamiliar) then safely remove dead code, duplication, and tech debt. Use after shipping or on an accumulating codebase. Sequences /onboard and /refactor-clean, delegates to the harness-claude:refactor-cleaner agent, and halts before ambiguous deletions.

Build a fast mental map of an unfamiliar codebase — structure, entry points, data flow, conventions, and where things live. Use when starting work in a new/unfamiliar repo, or to refresh context after time away. Supports maintenance.

Remove dead code, duplication, and tech debt safely during the Maintain phase. Use after shipping, or when a codebase has accumulated cruft. Delegates to the harness-claude:refactor-cleaner agent. Behavior-preserving only.

Run the full test suite and confirm coverage meets the floor before shipping. Use in the Verify phase after review. Adds missing tests for uncovered acceptance criteria.

Summarize current progress and persist it to a dated session file so work resumes cleanly in a future session. Use before /compact, before ending a session, or at major milestones. Pairs with /resume-session.