Shipping AI in the Real World: Lessons From Our Latest Cycle

AI moves pretty fast. If you don’t stop and look around once in a while, you could miss it. Recognising this, we have been running a structured approach to AI adoption for production systems.

A critical element is ensuring we keep up with the latest approaches while retaining safety, responsibility and avoiding inefficiencies caused by churn. Here are some of the things we’ve learned from our latest cycle.

---

Stack: Opus 4.5 + Cursor

Opus 4.5 remains the default model of choice. Yes the token cost is higher, but the increased accuracy reduces correction cycles and ensures it remains competitive. We find it far superior to Codex 5.2 which we find often doesn’t “get it” and needs more additional context.

Cursor (with Opus 4.5) remains our go-to tooling and is popular with engineers. Despite engineers having GitHub Copilot licences use of this locally has been completely supplanted (though increasingly we are using GitHub Coding Agent with custom agents within GitHub Enterprise so the licences remain). We have evaluated Claude Code and Codex CLI and remain convinced that Cursor is our tool of choice.

---

Why We Dropped Vibe Coding Tools

We have dropped the use of Replit (and indeed any vibe coding specific tools). There are two reasons for this.
We find Cursor/Opus 4.5 produces superior results and gives more control. This does introduce an increased learning curve for non-engineers however.
We now understand “the art of the start” rapidly creating new projects using the above to avoid having to throw the prototype away with the ability to evolve in a structured manner.

---

Open Spec: Spec-Driven AI That Scales Beyond the First Draft

So how do you choose open source tools wisely, and prepare for the possibility of change?

AI (and vibe coding tools) do a jaw-dropping job of creating working software with little input. Iterating on that initial effort becomes increasingly messy and often leads to a desire to start again. A spec-driven approach proposes a solution to this.

Having reviewed tools we have selected Open Spec, as a relatively lightweight framework, as the tool we will take forward.

---

Legacy Codebases: AI-Assisted Modernisation With Less Risk

One of the most exciting areas for us is how we can use Open Spec to help onboard, support, modernise and evolve legacy codebases.

This is a service we have provided for a number of years and usually involves a technical discovery, understanding and reviewing solutions for maintainability as well as recommending a roadmap. We know what good looks like. With AI we can dramatically reduce the effort and cost of the review process (and ongoing change).

---

Continuous Improvement: Agents, Skills, and MCP (Done Safely)

Outside of this, our engineers continue to evolve how we use custom Agents, internal tools, and reusable “skills” as part of continuous improvement taking our existing proven delivery patterns and turning them into repeatable building blocks.

A key part of that is our selective use of approved MCP Servers, which allow agents to integrate safely with real engineering systems. In practice, that includes work item integration (so tasks and acceptance criteria stay connected to delivery), testing (running and interpreting results), logging access (to diagnose issues using real runtime signals), Azure access (for controlled environment and resource visibility), CI/CD (to validate changes end-to-end), and GitHub (for repo context, PR workflows, and automation).

The focus is fewer manual steps, faster feedback loops, and higher confidence changes in production systems, without compromising safety or introducing unnecessary risk.

---

Less time coding, more time engineering: the shift we’re seeing

Our approach includes careful measurement and review. AI adoption isn’t something you can just switch on. It takes time for engineers to adapt their habits, build trust in the tooling, and learn where AI accelerates work versus where it adds noise.

After 24–36 months of active use – and thanks to some dramatic advances in the tech – we’ve reached an important milestone: in the last quarter, our engineers have become prompt-first rather than code-first. This is enabling a higher proportion of time is now spent on non-coding activity. This is allowing more time to be spent on clearer thinking, better framing, stronger specifications, improved review, and tighter feedback loops. The coding itself is often faster, but the engineering around it becomes even more important.

In terms of output, 51% of our code is now AI-authored, and that percentage is even higher in front-end systems where patterns are consistent and iteration cycles are rapid. We’re also seeing increasing confidence in incorporating the saving in effort AI can bring in estimations, although this remains a work in progress – especially where requirements are uncertain or systems are complex.

It is not all about effort reduction. We are seeing better outcomes. The good news is that quality is increasing, and as a result customer value is increasing too: faster delivery, better maintainability, and fewer correction cycles.

Our Promise: Staying Ahead So You Don’t Have To

As a disclaimer – this is all aimed at adoption within Talk Think Do for engineers building and supporting mission-critical systems for customers. This is massively paying off for us but does not universally apply.

At Talk Think Do we have a friendly team of experts who know what good looks like. Our strategy is to be on top of changes in AI technology so customers don’t have to and – critically –  to pass the benefits onto them directly in terms of speed, cost and outcomes.

Control your own destiny

AI is changing how software gets built, but it doesn’t change what matters most: control, maintainability, and long-term outcomes.

A huge amount of risk in modern software delivery still comes from the same place it always has: unclear ownership, limited visibility, and suppliers who optimise for short-term delivery rather than sustainable systems. If you don’t own your codebase, don’t understand it, or can’t evolve it safely, then AI simply accelerates the wrong things.

At Talk Think Do, we help organisations take control of their software destiny, whether that’s building new cloud-native platforms, modernising legacy systems, or strengthening the engineering foundations of critical applications. Our approach combines proven engineering practices with a structured, responsible adoption of AI, so you benefit from the speed without inheriting chaos.

That includes:

• Owning and understanding your source code (so you can change suppliers, scale teams, and evolve safely)
• Building systems that remain maintainable as they grow
• Onboarding existing applications from other suppliers and internal teams and applying AI practices
• Reducing delivery risk through better discovery, specification, and technical governance
• Using AI to accelerate delivery while improving quality, not trading it off

If you want a software partner who is actively staying ahead of AI changes and translating them into real improvements in cost, speed and outcomes, we’d love to talk.