generic-claude

Agentic Coding Reference

Agentic coding that amplifies an engineer's judgment instead of replacing it.

Ship in days what would otherwise die in triage — and hold a high bar for years. The work worth trying but never worth weeks gets built and tested against real users instead of shelved. The bar holds because durable specs and nested feedback loops keep every agent, session, and person pointed the same way.

TL;DR — The interface is a conversation; the machinery behind it is deep. A file-based pipeline of ten one-job specialist agents builds one vertical slice at a time. Each appends a schema-validated record to a shared log, a deterministic router dispatches from it, and a reviewer roster gates every change; an advisory change-grader then flags where human attention pays — nothing auto-merges. The work runs through four nested feedback loops, from the inner TDD cycle out to whole-codebase review, so drift is caught before it compounds. Durable specs — PRD, system design, ADRs, ubiquitous language — are the shared memory every agent, session, and person reads and writes. One CLAUDE.md carries it across four agent tools; /materialize and /harvest adopt it in your project and feed improvements back.

You don't use the agents directly. Adopt the harness, start a conversation, and describe the feature — the right specialists are selected for you, behind the scenes. It's an engineering team you collaborate with, not a toolbox you operate. The depth documented below is for building and extending the harness itself; to adopt it, the Quick Start is enough.

Why This Exists

AI coding agents face the same two challenges human engineers always have: keeping long-term memory across sessions, and running multi-scale feedback loops that catch drift before it compounds. The difference is degree, not kind — a human forgets between Friday and Monday; an agent forgets between one message and the next. Within days, not years, an agentic project that skips the disciplines that compensate starts drifting: terms picked inconsistently session-to-session, settled decisions re-litigated, this week's architecture contradicting last week's.

The fix is to treat the disciplines human teams already built as the memory and feedback substrate — documentation standards, DDD, TDD, ADRs, ubiquitous language, and XP-style nested loops. Every agent, every session, and every person on the codebase reads and writes the same durable specs, so all stay pointed the same direction. A file-based specialist pipeline of ten one-job agents operates it, building one vertical slice at a time. A single rules file (CLAUDE.md) carries it across Claude Code, Copilot CLI, OpenCode, and Junie CLI.

Two working reference implementations (Go, Spring Boot), portable skills, and enforceable documentation standards demonstrate the pattern; a bidirectional /materialize + /harvest loop adopts it in your own project and feeds improvements back.

It is for anyone running an agentic coding workflow over more than a few sessions:

• a solo developer driving an agent team past what fits in one conversation;
• a team where each developer drives their own agent team on a shared codebase;
• a human-only team that wants the same discipline against the slower drift humans face.

The failure modes are the same; only the speed differs.

The architecture, principles docs, and reference implementations are stable and in active use. The specialist pipeline machinery (JSONL contract, reviewer-roster fan-out, capability progression) is operational, though its cost-effectiveness is still being measured (with Harness Stats) and will be revised as evidence accumulates. Treat the disciplines as the validated core and the pipeline machinery as one reference implementation of the shape the harness can take.