CODING AGENTS

Software That Survives

Human-Driven Development with Coding Agents

A working method for using coding agents without giving up the engineering decisions that keep a product maintainable.

Ask about this workshop

Format and fit

Full day · Half-day version available

Who it's for

Engineers and technical founders using Claude Code, Codex, pi, or similar coding agents in real projects.

Preparation

Bring a laptop with Claude Code, Codex, or pi installed and authenticated.

Workshop abstract

Projects rot in the gap between generation speed and review capacity: cognitive debt, verification debt, architectural debt, and the loss of judgment that follows when the tool does the work without teaching the person directing it.

This workshop turns Human-Driven Development into repeatable practice. We work hands-on with Claude Code, Codex, or pi, while keeping the durable controls in the repository: instructions, automated checks, review gates, work ledgers, and release evidence.

The team structures a repository so any coding agent inherits its standards, moves enforceable rules from prose into machinery, runs implementation and review as separate turns, and builds verification around the work before it reaches users.

The goal is not to type more. It is to decide what the agent may write before it writes it, and to preserve enough context and evidence that a person can still stand behind the result.

What the team will be able to do

Structure a repository so Claude Code, Codex, pi, or another coding agent inherits the team's standards.

Move enforceable rules into linters, type checkers, formatters, and hooks.

Run a ledger-driven loop where implementation, review, and human approval remain distinct.

Route work by capability and cost while keeping senior judgment at the review gate.

Build layered verification that catches regressions before users do.

Workshop content

Module 1

The frame

Vibe coding, vibe engineering, and Human-Driven Development; the four debts; and the production-debugging test every merge must pass.

Module 2

The repository as control plane

Expand the deterministic surface, then use canonical documentation, repository instructions, glossaries, memory, and reusable workflows to carry guidance machines cannot enforce. Map the shared practice onto Claude Code, Codex, and pi through a compact harness translation guide.

Module 3

Ledgers, turns, and gates

One active queue, explicit implement-and-review alternation, approval gates for consequential changes, and a record of where execution departed from plan.

Module 4

Delegation and model routing

Separate orchestration from implementation, choose the cheapest adequate model for each task, compare how Claude Code, Codex, and pi delegate work, and trust recorded evidence over self-reported results.

Module 5

Verification in three layers

Contract tests on fixtures, behaviour evaluations on representative cases, and invariant checks on the shipped deliverable itself.

Module 6

Review and ship

Blind architecture review, dated findings, materiality-based human attention, deterministic release commands, and Git discipline across concurrent agent sessions.

Threaded lab

Using Claude Code, Codex, or pi, the team receives a deliberately vibe-coded feature with representative defects, wraps it in the controls module by module, and watches those controls expose what is wrong.