From autocomplete to delegation
The first generation of AI coding tools made typing faster. Coding agents change the shape of the job: instead of suggesting the next line, they take a described task, work across several files, run the tests they can and come back with a change to review. OpenAI's Codex was the point where that workflow clicked for us.
The important mental shift is that delegation is a skill. An agent given “improve the homepage” will produce something plausible and unhelpful. The same agent given “migrate these three components to the shared design-system button, TypeScript strict, no visual changes” will produce a reviewable diff in minutes.
Where it earns its place
The wins for us cluster in a few recurring categories: mechanical migrations, test backfill, small features with clear acceptance criteria, and the kind of refactor that is valuable but boring. In all of those, the specification is short and the success test is objective — which is exactly the profile agents handle well.
What we deliberately keep out of agents' hands is anything where the acceptance criteria are still being formed: early-stage interface work, anything touching security boundaries, and architecture decisions. Delegating an undefined task is not saving time, it is deferring thought.
Review is the job now
The uncomfortable truth about agents is that they move the bottleneck rather than removing it. Generating a diff is cheap; reading it like you wrote it yourself is not optional. We treat agent output exactly as we would treat a junior developer's pull request — with a review checklist, tests that have to pass, and no merge on vibes.
Done properly, this has made review better rather than worse. Because the agent's work is well-scoped by construction, reviews are shorter and more focused than the sprawling human-authored changes they replaced.
The honest balance sheet
We would not claim a multiplier number, because honest numbers need measurements we were not taking before this workflow existed. What we can say is qualitative: the team spends more time on the parts of the job that need a — specification, interface design and judgement — and less on the mechanical middle.
Agents have also changed what we write down. Tasks that used to live in someone's head now get specified carefully enough to hand over, which would be good practice even without AI on the other end of it.
Anatomy of a well-scoped task.
The task briefs that produce good agent work share a shape: context about where the change lives, constraints that name the boundaries the agent must respect, acceptance criteria that are objective rather than aspirational, and stopping conditions — what to do — when the agent cannot meet the criteria rather than guessing its way past them.
Writing briefs to that standard takes minutes and transforms the results. The contrast with “improve the homepage” is not subtle: one brief forces the thinking upfront, the other borrows against it and pays in review.
The review checklist, written down.
Agent output earns merges the same way any diff at this studio earns one: a consistent checklist — does the change do only what the brief authorised; do the tests actually test the changed behaviour; is anything slipped into the changeset the brief did not ask for; and does the diff read like something a careful colleague wrote?
The checklist matters more for agent output than for human work, because agents whose work is reviewed thoroughly produce increasingly trustworthy brief-following behaviour — while agents pushed through on vibes train nobody, least of all the reviewer.
Agents in a static-first pipeline.
The studio's build discipline is an asset with agents: prebuild checks run the gates — types, content, SEO, accessibility, performance budgets — that fail loudly on hard thresholds. An agent cannot quietly ship something past a pipeline designed for that exact purpose.
Practically, that means the gates earn their keep twice: they protect the site from human mistakes as they always have, and now they close the loop on delegated work — a task passes not when the agent believes it is done, but when the pipeline says so.
When we stop an agent.
Not every delegated task deserves to finish. The stop signals: the agent attempting work the brief never authorised, replaying the same failing edit with cosmetic variations, or reporting completion that the acceptance criteria clearly contradict.
Stopping early is not failure — it is the cost signal that the brief was under-specified, or the task belonged to a different tier than the tool. Both lessons belong in the next brief; neither belongs in the merged history.
