Agents Do the Engineering Work Under a Written Plan

Give the agent the repository rather than a prompt: the conventions file it must follow, the expert subagents that own each domain, the tools it may call, and a plan written specific enough that a wrong assumption shows on paper. It works in your repository, under your branch rules and your access model.

Verify what it reports by running the check: the build, the tests, the applied delta, the digest on the box. The command and its output travel with the work, so a claim is never the evidence. What runs unattended and what waits for a person is set per environment before the first run.

A Claude Code Harness That Learns From Every Session

Close every session by writing what it taught back into the harness: a correction becomes a rule, a procedure becomes a skill with its failure modes attached, an incident becomes a line in the lessons log carried beside the code. Expert subagents own their domains, and guard hooks enforce the limits rather than a reviewer remembering them.

Distribute it both ways. What belongs to this codebase stays in the repository; what is general moves into the library every other project reads from, so a trap paid for once is inherited instead of rediscovered. The harness ships with the work as plain text the customer’s own people can open, run and change.

The Cheapest Model That Meets the Quality Bar

Run each part of the work on the cheapest model that still meets its quality bar, and reserve the expensive models for the tasks that need real judgement. The monthly bill then follows what was done rather than the name on the model.

Record every choice with the evidence behind it, including the configurations that failed, so the next project inherits a tested decision. Several suppliers cover the same work at different price points, and the record of which model does what sits in the customer’s own repository where their people can change it.

3 lenses
parallel code-review agents on every change, from the repository's own harness
12:32.5
merged in-house promo video, five scripted acts, narration per segment
83
topics in the business-user class built by the same harness
25h
two slots healthy and unreachable, the incident behind digest checks

The Agentic SW Engineering Playbook

Analyse & Plan 3 steps
01

Read the Estate Before Granting Autonomy

Run repository analysis as a skill that records what the repository is, its deployment shape, its addresses per environment or slot, its databases and its authentication. Write an unknown value as TBD, and name the git-ignored file that holds a secret rather than the secret. What lands is a README the next session reads.
02

Route Each Role to the Model It Needs

Split the work into roles and scope each to its own brief and tool set. The delivered content team runs Writer, Reviewer, Translator, Researcher and Publisher as separate Claude Code subagents, with a structured Reviewer verdict driving a revision loop capped at two passes. Spend the full context where judgement is needed, and give every loop a stopping condition.
03

Plan Before the Agent Is Allowed to Act

Give every step one shape: overview, an open research and planning prompt, the finding, a copy-paste recipe, then the expected outcome, which is how the 83 demo steps in the business-user class are written. Apply the same discipline to issue creation: run a bounded scan of the relevant code first, so the filed issue cites real files.
Wire the Harness Layer 3 steps
04

Ship the Harness as a Working Artifact

Ship the harness the material teaches: expert sub-agents, a three-lens parallel code-review agent team, guard hooks and scaffolding slash commands, all used live in the lessons. Restructure the AI configuration so each instruction lives in exactly one place, and keep the harness runnable and handed over as part of the repository.
05

Encode the Failure Modes as Skills

Write each failure mode into the skill as an executable rule. A zone-file import replaces every record set, so a record omitted from the file is a deleted record, which makes a snapshot of the live zone mandatory before writing. Name the git-ignored credential file rather than the credential, and ship a recurring operating loop as Microsoft 365 Copilot Cowork skills the task owner runs without a terminal.
06

Let Hooks Do the Enforcing

Put the harness rules in guard hooks: one caps the instruction file at 90 lines, one prints the skill roster on every prompt so an existing skill fires, and a verification gate sits behind both. Run the long-horizon version as a scheduled workflow measuring the live pages through PageSpeed Insights, with read-only permissions, a network allowlist and a capped output.
Build with Agents & Ship with Confidence 2 steps
07

Build with Agents on a Configuration That Holds

Record the orchestration configuration that works, and the one that breaks. A Magentic team on Microsoft Foundry fails against the Responses API with a manager ledger error; run it on the Chat Completions client with no Anthropic-protocol model inside the loop. On that footing, one run from a free-text prompt returns the article, the German variant, social atoms and a publish manifest.
08

Make Every Deploy Prove Itself

Build and push in parallel, then queue the box-side work on a file lock, because concurrent layer pulls corrupt each other's containerd ingest. Compare the pushed digest against the image on the box, compare the running container against that image, and check that the public hostname responds. Container health, DNS and the edge proxy can each be correct while the site is down, which cost 25 hours once.
Improve & Scale 2 steps
09

Carry a Lessons Log With the Code

Keep a lessons log beside the code and write each incident into it as a rule: an LFS checkout that replaced every video take with pointer files, the credit-routing setting that unlocked the avatar narration budget, the image-model prompting recipe that keeps generated frames free of garbled text. Repository consolidation follows the same rule, recording per-path provenance and leaving live dependencies where they run.
10

Report What Shipped, Bill What Was Recorded

Read unit and end-to-end results from test reporter output per application, and name the untested surfaces as gaps. Where no reporter output exists, state the reason on screen. Rebuild billing from the recorded time ledger, so every figure on the invoice has a session behind it.

Frequently Asked Questions

Does this only produce application code?
The same harness produces course and class material for any subject, through a factory that composes slides with overflow checks, generates narration per slide, composites annotated photos and renders avatar video. It produces multimedia through a media service exposed twice, over HTTP for what a person clicks and over MCP for what a model calls. It also produces operations output, including billing rebuilt from the recorded time ledger.
How is agent behaviour bounded in a real repository?
By hooks and gates. One guard hook caps the instruction file at 90 lines so it stays short enough to be read on every turn, another prints the skill roster on every prompt, and a verification gate sits behind them. Where a tool is irreversible, an approval gate goes in front of it: the governed MCP exercise hands over a live server with six tools including one destructor, and requires boundary rules plus a stress test against adversarial prompts.
Can a model write directly to a live business system?
A draft tool returns an interactive form rendered inside the chat client, prefilled with what the model proposed, while the model itself has no write tool and saving runs through a separate path triggered by the person looking at the form. Read-only integrations stay read-only, and a skill names the git-ignored file that holds a value instead of the value.
How does a deploy prove that anything actually shipped?
It compares the digest just pushed against the image on the box, compares the running container image id against that image, and finishes with a check that the public hostname responds, reporting an unchanged digest as a deliberate no-op. The same checks are available outside a deploy through the health and identity endpoints, so the question can be asked at any time.