How We Build With AI Agents: A Real Build Log

This is a working log from rebuilding our own marketing site with senior people directing coding agents. Humans owned architecture, taste, release authority and the awkward judgement calls; agents drafted components, refactors, tests and bulk content transforms inside that frame. Where agents missed, we caught it in review - and those misses are in this piece on purpose.

The project and the brief

We rebuilt the public Code23 site for 2027: new service architecture, question-shaped content, proof assets on the surface, and a stack we can evolve without fighting a theme. Own IP, so we can publish the workflow without waiting on a client NDA.

Scope that mattered:

• Six service hubs that actually match how we sell
• Blog and content model that can carry long-form pillars without CMS theatre
• Entity-consistent facts everywhere (est 2005, Reading base, 60+ five-star reviews, the same one-sentence description)
• Performance and accessibility budgets enforced before go-live
• No “AI magic” section that claims speed without showing how delivery works

We are not documenting a toy landing page. The brief was the same commercial pressure we put on client work: ship a site that sells, ranks, and stays editable. Companion numbers for throughput live in AI-accelerated delivery build-time data. The positioning definition sits in what is agentic AI.

The prompt-to-production trail

A typical implementation loop looked like this:

1. Human sets the frame. Architecture note, acceptance criteria, forbidden shortcuts (no unsupervised schema changes, no silent dependency upgrades, no inventing product claims).
2. Agent drafts inside the remit. Component variants, route scaffolding, content transforms, test stubs, refactor diffs against the design system.
3. Human reviews the diff like production code. Naming, edge cases, accessibility, whether the change matches the brief or quietly expanded it.
4. Agent revises against the review notes. Specific instructions beat “make it better”.
5. Harden before merge. Lint, tests, visual check, performance budget, then a human release decision.

That trail is boring on purpose. Agentic mastery is not a demo reel of prompts - it is a senior-directed pipeline with the same accountability we had before agents existed. The only change is how much implementation a senior hour can cover when the harness is tight.

What we kept visible on the board:

• Branch and PR titles that named the human owner
• Review comments that rejected “helpful” extras outside the brief
• Screenshots of broken states we refused to ship
• A short note on every merge: what the agent produced vs what a human rewrote

Clients who want this transparency on their builds can ask for the same artefacts. The log is the product differentiator; the chat transcript alone is not.

What the humans did vs what the agents did

Humans owned:

• Information architecture and which services earn a hub vs a spoke
• Brand and design-system decisions that affect trust
• Claims discipline (corpus facts only; no invented case-study numbers)
• Integration choices and release authority
• Accessibility and performance sign-off
• The call to scrap an approach when the agent kept papering over a bad model

Agents owned (under direction):

• First-pass components and page sections against existing tokens
• Bulk migrations of content fields and internal link patterns
• Test scaffolding and repetitive refactors across similar routes
• Draft copy variants for humans to cut hard
• Inventory of inconsistencies (duplicate descriptions, missing alt text, orphan templates)

Be specific about the split: agents are fast at volume work inside a coherent system. They are weak at deciding what the business is selling. On a multi-brand programme we once shipped 100+ sites from a shared kit - that pattern only works when humans lock the kit and agents multiply the instances. Same rule on a single flagship site: lock the system, then accelerate.

We do not let agents “own” production. Diff review is mandatory. The person who merges is accountable when something breaks at 3am.

Where it went wrong

Three failure modes showed up often enough to name them.

1. Confident wrongness on brand facts. Agents happily invented tidy statistics that were not in the brief. We caught them because claims go through a human gate against the known corpus (350+ projects, the Plastor model on 13,371 orders). Without that gate, a polished paragraph can ship a lie.

2. Scope creep dressed as helpfulness. “While I was here I also refactored X” is how reviews balloon. We started rejecting unsolicited extras unless they were required for the change. Speed without scope control just burns the fixed band later.

3. Tests that assert the bug. Agents sometimes wrote tests that encoded the broken behaviour. Human review of test intent mattered as much as review of the feature code. Our AI agent QA notes go deeper on that pipeline.

We also hit the ordinary stuff: flaky previews, content freezes while marketing rewrote a service pitch, and one integration path that looked fine in isolation and failed when two agents touched adjacent modules without a human merge plan. None of that is exotic. Hiding it would make this log marketing. Publishing it is the point.

What shipped and how we verified it

What left the door:

• Service hubs live and internally linked to the spokes that support them
• Blog collection frontmatter aligned so pillars and supporting posts share one schema
• Entity description consistent across footer, about, and key landing surfaces
• Accessibility and performance budgets checked before launch, not after a complaint
• A review trail that can answer “who decided this shipped?”

Verification was not a vibe check. Diff review, automated tests where they earned their keep, manual passes on conversion paths, and a human go-live. Same bar we hold on client work under AI development.

If you want the quantitative companion - what compressed and what still takes calendar time - read the build-time data. If you want the plain definition behind the workflow, start with agentic AI.

The delivery model is simple: humans lead, agents execute, review trails stay visible. When that is what you want on the next build, start at AI development.