claude_harness_eng_v5

Autonomous build loop with Karpathy ratcheting, GAN evaluator, and session chaining. Iterates story groups until all features pass or stopping criteria met.

Change the behavior of existing code — story-driven by default, or --issue N for a GitHub bug fix. Test-first, full verification, code review.

Code generation quality principles — TDD, typing, error handling, logging, API integration, LLM integration.

Brownfield change route — take an existing-code feature request from intent to a reviewed PR, scaling from a single /change to an epic via /spec→/design→/auto. Linear-tracked, backed by a committed DeepWiki.

[Internal pipeline stage — run by /auto self-heal and /implement validation when lint/type error volume is high; invoke directly only as a power user.] Turn compiler/linter output into a sharded work queue; fix per package with optional adversarial review — no full monorepo suite mid-shard.

[Internal pipeline stage — run by /auto (follow with /gate); invoke directly only as a power user.] Generate production code and tests for a story group using agent teams for parallel execution.

Refactor existing code for quality, performance, or maintainability. Enforces core quality principles with ratchet gate.

Use when creating or editing .claude/agents/*.md, .claude/skills/*/SKILL.md, or .claude/commands/* — apply docs/prompting-standards.md (trigger conditions, model-agnostic bodies, no reasoning-as-text, effort floors).

Full SDLC pipeline. Runs all phases end-to-end with human gates on phases 1-3.

Run the adaptive pre-merge quality gate: deterministic checks, evaluator, diff review, and security review only when the diff crosses a security/data/API boundary. (Renamed from /review to avoid colliding with Claude Code's native /review PR-review command.)

Invoke the frontier advisor for a structural re-rank / unblock / design pivot. Compact brief only.

Discover and map an existing codebase before planning or changing it. Add --seams "<goal>" to also rank the safest cut-points for that goal.

[Internal pipeline stage — run by /brownfield and /seam-finder; invoke directly only as a power user.] Build a deterministic dependency graph of an existing codebase. AST-first for Python, React/JS/TS, and Java/C#/Go (stdlib ast + tree-sitter wheels — symbols with line ranges, routes, components, hooks, call/render edges, package-aware import resolution, god-file skeletons, incremental --files patching); regex fallback when python3 or the wheels are unavailable. Outputs JSON + ranked symbol map + Mermaid + metrics for downstream brownfield, refactor, and seam-finder skills.

Build a bounded, cited context pack from the living DeepWiki/code-map before broad source reads. Use in brownfield lanes and whenever source orientation could otherwise require large file reads.

Controlled small-change lane for low-risk fixes, docs, tests, and narrowly scoped edits without running the full SDLC pipeline.

Upgrade harness control-plane files (hooks, scripts, git-hooks, agents) in a previously scaffolded project without wiping project-manifest or state. Dry-run by default.

[Internal pipeline stage — run by /build (use --doc-only standalone for an ARB narrative); invoke directly only as a power user.] Generate system architecture, machine-readable schemas, and UI mockups. Spawns planner + generator concurrently.

Use when bumping a dependency version — package.json, pyproject.toml, requirements, or lockfile changes — in an existing codebase. Classifies the bump, audits the usage surface from the code graph, and isolates the upgrade in its own proven commit.

Use when a symbol that must change is UNCOVERED and unpinnable (seam score < 0.5, or a skeletons/-flagged god file with no clean boundary) — adds behavior in a new fully-tested unit instead of editing legacy code in place. [Internal discipline — applied automatically by pipeline agents mid-task; direct use is a power-user path.]

Show how mature/safe this codebase is for heavy AI-agent use — a synthesis dashboard across 8 pillars, aggregating signals the harness already collects. Read-only report; aggregates state already on disk.

Use when about to edit any existing (non-greenfield) symbol — before the first Edit/Write to production code in /refactor, /change, or /vibe — to learn which tests cover it and route uncovered code to pinning or sprouting. [Internal discipline — applied automatically by pipeline agents mid-task; direct use is a power-user path.]

Use when checking-coverage-before-change reports an UNCOVERED symbol you must edit — writes characterization (pin-down) tests at the nearest observable seam and verifies they bite before any production edit. [Internal discipline — applied automatically by pipeline agents mid-task; direct use is a power-user path.]

[Internal pipeline stage — run by /build and /auto; invoke directly only as a power user.] Generate test plan, test cases, test data fixtures, and Playwright E2E tests mapped to acceptance criteria.

Use when a story is about to move from acceptance criteria to implementation — in /test's plan-phase deliverable or /change Step S4, before any production code is written — to write a business-readable acceptance test against a Ports-and-Adapters seam with a test-double adapter, and confirm it fails for the right reason before implementation proceeds. [Internal discipline — applied automatically by pipeline agents mid-task; direct use is a power-user path.]

[Internal pipeline stage — run by /build; invoke directly only as a power user.] Create a Business Requirements Document — from a Socratic interview, or grounded in a Functional Requirements Document via --frd (with a deterministic net-new/dropped gate). First step in the SDLC pipeline.

[Internal pipeline stage — run by /scaffold; invoke directly only as a power user.] Verify agent-framework skill packs declared in project-manifest.json#framework_skill_packs and print normal-terminal install commands for missing packs. Use after /scaffold reports PENDING MANUAL INSTALL, after manually adding a pack to the manifest, or to verify all configured packs are present.

Build client-side React apps with Vite — useEffect cleanup and stale-closure bugs, dependency-array gotchas, Context vs. server-state libraries for API data, Vite environment variables, and testing with Vitest. Scoped to Vite+React client-side apps — NOT Next.js (App Router/Server Components/Server Actions need different guidance). Triggers on "useEffect", "React hook", "stale closure", "dependency array", "Vite env variable", "React Vitest testing".

Build FastAPI backends — dependency injection with Depends(), Pydantic v2 request/response validation, async vs sync route rules, background tasks, and testing with TestClient. Use for any FastAPI route, dependency, or Pydantic model. Not for database/ORM design (no SQLAlchemy content here) or non-FastAPI Python web frameworks. Triggers on "FastAPI route", "Depends()", "Pydantic model", "FastAPI dependency", "FastAPI testing", "TestClient", "async def vs def FastAPI".

Build long-running, production-ready agents with DeepAgents — the opinionated harness on top of LangGraph/LangChain providing filesystem access, task planning, subagent delegation, and context management out of the box. Use for long-running coding/research/multi-step tasks where you'd otherwise hand-assemble that middleware stack yourself; use langchain-code's plain create_agent instead for a simple single-tool-call loop with no need for planning or filesystem access. Triggers on "DeepAgents", "create_deep_agent", "agent harness", "long-running agent", "coding agent with filesystem", "subagent spawning".

Build LangChain agents in Python — create_agent, chat model initialization, tool binding, structured output, and middleware. Use for a single-agent tool-calling loop with a system prompt and a fixed tool list; use langgraph-code instead when the task needs explicit multi-step state-machine control flow, and deepagents-code instead when it needs a pre-assembled filesystem/planning/subagent harness for long-running work. Triggers on "LangChain agent", "create_agent", "chat model", "tool calling agent", "structured output langchain", "bind_tools".

Build stateful, multi-actor LangGraph agents in Python — StateGraph definition, conditional routing, checkpointing/persistence, and human-in-the-loop interrupts. Use when a task needs explicit multi-step control flow, crash/interrupt recovery, or approval gates — not for a single-turn prompt or a simple tool-calling loop (use langchain-code's create_agent for that). Triggers on "LangGraph", "state graph", "stateful agent", "multi-step agent workflow", "checkpointing", "resume from crash", "human in the loop agent".

Draft a private equity investment committee memo and render it as a branded PowerPoint deck. Adapted from the installed private-equity vertical's ic-memo skill (same 9-section structure), with PPTX output instead of Word. Use when preparing IC materials, writing up a deal, or creating a formal recommendation as a deck rather than a document. Triggers on "write IC memo deck", "PE IC memo PowerPoint", "IC deck", or "investment committee deck".

[Internal pipeline stage — run by /build; invoke directly only as a power user.] Decompose BRD into epics, stories, dependency graph, and feature list for agent team execution.

PRD-per-sprint evolution route for an existing harness-built (or brownfield) system — grounds a new PRD against the prior requirement spine, produces a human-approved design amendment against the living specs/design/ baseline, then runs /auto. Companion to /build (sprint 1) and /feature (single-story changes).

Show SDLC pipeline progress — a one-shot snapshot, a live watch, or a step timeline. Read-only; aggregates the state the harness already writes. CLI-friendly (Devin-style status/watch/timeline with --json).

Respond to CI failures and review comments on a harness-opened PR — poll, classify, fix, push, reply with evidence. Bounded and budget-metered; merge stays human-owned. Use when a harness PR shows red CI or unanswered review comments.

Use when a planned change touches persisted data shape — ORM models, migration files, schema definitions, serialized formats, or message contracts — in /change, /refactor, or /implement on an existing codebase. Routes schema changes through expand-contract and proves reversibility before any deploy. [Internal discipline — applied automatically by pipeline agents mid-task; direct use is a power-user path.]

Use when committing any change that includes structural work (rename, move, extract, reorder) in an existing codebase — keeps refactor commits behavior-free and behavior commits refactor-free so regressions stay attributable. [Internal discipline — applied automatically by pipeline agents mid-task; direct use is a power-user path.]

[Internal pipeline stage — run by /auto and /gate; invoke directly only as a power user.] Run the application and verify sprint contract criteria via API tests, Playwright interaction, and schema validation.

[Internal pipeline stage — run by /build; invoke directly only as a power user.] Generate Docker Compose stack, Dockerfiles, environment config, and init.sh bootstrap script.