A year’s work in two months
A client came to us with an idea for a retail product and not much else. No requirements, no architecture, no backlog, just the idea and a belief that it was worth building. They had set aside somewhere between nine months and a year to get it to market. We got them to a working product for their first pilot clients in about two months.
Every stage of that work was AI-assisted, from the first workshop to the code that shipped. The speed came from doing the ordinary things well, with AI involved at every step and experienced people over the top of all of it. Here is what that looked like.
From an idea to a shared understanding
I started where I usually start, with workshops to understand the idea properly: what was driving it, and what the client actually wanted from it. The difference this time was that an AI notetaker captured everything, and I then used AI to turn those notes into a first requirements document.
That document was useful precisely because it wasn’t finished. It laid out what we had understood and, just as importantly, flagged the gaps and the questions we still needed answers to. I went back and forth with it until it was in a state I was happy to put in front of the client, then we worked through it together in more sessions, refining until everyone understood what we were building. Every round, the notes fed back in and the document was updated, always with me checking what came out rather than taking it on trust.
Deciding the architecture
From the agreed requirements I produced the technical documentation, again with AI, this time connected to the various platforms we were weighing up so it could help shape the architecture. This is where experience earns its keep. The AI could propose an approach quickly, but the judgement of whether it was the right approach, whether it would hold up, whether it suited this client rather than a generic one, was mine. I sat over every one of those decisions.
Backlog and build
Once the architecture was set and the client was happy, I used AI to build the backlog in Jira: the whole thing, with roadmaps and some early spike sessions to flush out the unknowns before they turned into problems. Then we built, using Claude Code, with experienced developers working over the top of everything it produced.
We got into a good rhythm quickly. The AI kept the board current as we went, so the backlog and the tickets stayed accurate and there was a single source of truth the whole team could rely on. Nobody was updating Jira from memory at the end of the day.
Standards we didn’t bend
Speed like this only stays safe if the guardrails are real. We built a shared set of prompts, plugins and skills that the whole team used, so we weren’t all solving the same problems in different ways. And we held firm on standards: testing, documentation, and CI/CD pipelines that had to be maintained, not skipped because a machine wrote the code. All of it was shared, and all of it improved as we learned what worked.
Demos the client could steer
The client didn’t have to wait for a status report to know where things stood. Sprint reports and dashboards were generated automatically, and they could look whenever they wanted. In the demos themselves, we could use AI on the fly to make changes off the back of their feedback, so they saw straight away what an option might look like. We would then take that away and build it properly.
Faster, not different
We finished in time for their pilot clients, roughly two months against the nine to twelve they had expected. That head start mattered commercially, because a competitor was working on something similar, and getting to market first let them win clients the other firm couldn’t.
Nothing on that project was produced purely by hand. But a human was in the loop over everything, at every stage, and that is the whole reason it worked. The experience in the team is what let us push back on the output, critique it, and wrangle it into the right shape rather than accepting the first thing that appeared. Every principle you would want on a well-run project was still there: continuous improvement, proper agile ways of working, good engineering practice. They were just applied faster, with Claude Code treated as another member of the team rather than a shortcut around the work.
That is the bit people miss when they hear “AI-assisted”. It didn’t replace the way we deliver. It made a good way of delivering a great deal quicker.