You own every line.
Whether you typed it or an agent did, if it ships under your name, it's yours. Nobody gets to say "the AI wrote that".
Over 90% of our code is written by AI. Here's why that's safe.
We're not experimenting with AI on the side. It's how we build, every day, for real companies with real customers.
01
Engineering with AI, not vibe coding
Our engineers are career software engineers. We were shipping production software long before AI coding tools existed, and we value exactly the same things now that we did then.
The question that matters most hasn't changed: how does your code reach production, quickly and safely? A good pipeline builds, tests and releases every change the same way, every time, in small steps you can undo in minutes. Those are the rails that let a team move fast without coming off them.
AI writes code faster than anyone can read it, which makes the rails more important, not less. Without them, it's just faster mistakes. We engineer with AI. We don't vibe code.
02
The bottleneck moved downstream
For most of software's history, writing the code was the slow part. With agents, it isn't. Writing code is no longer the bottleneck, so the queue forms further down the line: review, testing, merging, releasing, and finding out whether a change actually works in production.
How fast you can move with AI now depends on how mature your machinery is for getting code into production, safely.
A team with a slick pipeline, one that tests every change thoroughly and can ship to production several times a day, turns AI's speed into real progress. A team with flaky tests, manual releases and a deploy every fortnight just gets a longer queue, and bigger, riskier releases at the end of it.
This was always true, long before AI. The teams that shipped small changes often, with confidence, always outpaced the ones that didn't. AI has just made the downstream bottleneck painfully clear.
That's why the pipeline is the first thing we build. In the first week of a new company, before most of the product exists, every change already goes from commit to production through the same automated tests and checks. Everything we build after that rides on it.
Anyone can write code faster now. What sets teams apart is how fast, and how safely, it reaches production.
03
What it looks like day to day
Every engineer works with AI coding agents every day, and no two of us work quite the same way. Some of us work strictly test-first, in thin end-to-end slices, with an agent pairing on each step: a failing test, the code that passes it, then the tidy-up. Alongside that, we brief agents with a specific remit, such as researching an option, sketching an architecture or working through a migration, and review what comes back. The engineer sets direction, reviews and decides. The agents do most of the typing.
It's changed where our time goes. We spend less of it writing code and more of it on the things that were always the hard part: understanding the problem, choosing what to build, and judging whether what came back is right.
It's also changed what a small team can cover. One engineer who understands infrastructure, frontend, backend and data can now move quickly across all of them. That's why we hire T-shaped people: breadth is what lets you ask an agent for the right thing and know when it's got it wrong.
04
How we keep it safe
Adversarial review.
Every change goes through automated review, where a review agent argues with the coding agent before a human signs off. We accepted that no person can read every line any more, so review discipline matters more, not less.
More testing, not less.
Agents working in parallel can trip over each other in sneaky ways. We invest heavily in smoke tests and in fast, well-cached test runs that only test what changed, because the merge queue is now our bottleneck, not the typing.
Caution scales with risk.
On a certified B2B platform with large customers and SLAs, we're far more careful than on a pre-revenue prototype. In small teams you can see the business risk directly and set the dial yourself. That judgement is what we hire for.
05
Why we're good at it
AI has made producing code cheap. It hasn't made context cheap.
An agent is only as good as what you can tell it: what you're trying to do, what state things are really in, and why past decisions were made. Most organisations keep that in meetings and in people's heads, where no agent can see it. The rest sits in a backlog that's weeks out of date, and an agent fed a stale backlog makes confident mistakes instead of obvious ones.
We've spent over a decade doing the opposite, long before AI made it fashionable:
- We narrate our work. Every engagement has a log channel with a running commentary on what we're doing and why.
- We write commits and pull requests that explain our reasoning, not just what changed.
- We treat reality as the source of truth, not the backlog.
None of that was designed for AI, but it turns out to be exactly what agents need. Point an agent at the repository and the log, and it has the real picture.
You can buy the tools. You can't buy the culture that feeds them.
06
We've been at the frontier for a while
Google Labs. We spent nearly a year as core contributors to Breadboard, Google Labs' generative AI prototyping framework, working with their San Francisco team from the UK while the field was being invented. It started because we were building with it on our own, and Google noticed.
AI in the products we build. These include AI-driven logistics insights for Sygnal One and the optimisation engine behind AdPeak.
“We needed an enthusiastic dance partner in very early product explorations, when everything was in flux and we pivoted nearly daily. I loved that they just rolled up their sleeves and jumped into the fray. They made a huge impact on the future direction of the product.”
“ExaDev have been transformative in helping shape our technology as we grow as a business. Our partnership has enabled ClearStake to scale rapidly, enabling us to confidently support enterprise clients and quickly embrace new technologies such as AI.”
07
What it means for you
Faster checkpoints.
A small team gets to something you can show customers sooner.
More ground covered.
Fewer handoffs between specialists, because each engineer can work across the stack.
More of your budget on judgement.
You're paying for experienced people to decide what to build and to check it's right, not for typing.
A codebase your future team can own.
The same habits that feed our agents mean every decision is written down. When you hire your own team, the context is all there.
08
Questions
- Isn't AI-written code sloppy?
- Vibe-coded software often is. We engineer with AI: every change goes through the same pipeline, tests and review it always has, and a named engineer owns every line that ships.
- Will my future team be able to maintain it?
- Yes. It's ordinary, well-tested code in mainstream languages, with the reasoning behind it written down. If anything, it's better documented than most hand-written codebases.
- Can you help my existing team work this way?
- Yes. Many of our engagements sit inside existing teams, and the habits rub off. Talk to us about Engineering Support or Advisory.
Want a team that's already worked out how to do this properly?
You'll talk to one of the senior engineers who run the company, not a salesperson. If we're not the right fit, we'll say so and try to point you to someone who is.