AI coding tools have changed what a small senior team can deliver. Code that used to take a day now takes an hour. Code that used to take an hour now takes minutes. That speed becomes your speed, with shorter timelines and more senior attention left over for the parts of the job that actually matter.
But the headline matters more than the hype. Faster output is only useful if it’s right. AI is excellent at producing code that looks right. Reading every line, understanding what it does, and knowing whether it’s safe to deploy: that’s still the job. Twenty years on the tools is what makes the difference between getting it right quickly and getting it confidently wrong.
A lot of the work in a software project is familiar territory. AI is brilliant at this and we lean on it heavily:
The pattern is the same across all of them. AI gets us to a credible draft in a fraction of the time, and we apply judgement to take that draft to something we’d put our name on.
The interesting question isn’t where AI helps. It’s where we deliberately don’t trust it. These are the parts of building software where being confidently wrong is expensive:
Every AI-suggested line goes through the same review one of us would give a junior engineer’s code:
Faster delivery on the predictable parts of the build. Work that used to fill a sprint, like scaffolding, mapping, drafts of tests, and repetitive refactors, now fits into hours. Your timeline shrinks where it can, without cutting corners on the parts that need careful thought.
Lower cost on the invoice for the same outcome. You don’t pay senior rates for boilerplate any more. The same project takes fewer hours, and the hours we do bill are spent on the work where experience actually moves the needle.
More senior attention where it’s actually useful. Architecture, trade-offs, the hard calls about what to build and what to leave alone. That’s where two senior practitioners earn their keep, and AI gives us more time to do it well.
Code you can hand to anyone afterwards. Well-tested, well-structured, documented, and not a black box that depends on its original authors. AI helps us produce more of it, faster, but the standard is the same as it’s always been.
The honest version. Junior developers using AI ship more code, but the same proportion of bad code as before. Sometimes more, because AI is fluent enough to bury the mistakes. Senior developers using AI ship better code faster, because they catch the errors AI can’t catch by definition: misalignments with the actual goal, subtle assumptions, the trade-off the prompt didn’t mention.
That’s the offer. Senior practitioners with twenty years on the tools, using the best AI tools available, applied with the kind of judgement that only comes from having been wrong enough times to learn.
