My friend Brendon is a sculptor. Recently, I asked what keeps him going through the long hours, the physical effort and the inevitable moments when a piece refuses to become what he imagined.
The buzz, he told me, comes from turning imagination into something tangible: something he can hold that once existed only in his mind. The piece changes as he works, shaped by the material and by what he discovers along the way. What he imagined at the beginning is rarely what stands before him at the end, because making the sculpture teaches him things that imagining it could not.
The finished sculpture matters, as do other people’s reactions. But neither is the deeper motivation. The motivation is the loop: imagine, build, encounter the gap between what you intended and what you created, learn from it, adjust the idea and keep going.
That conversation made me reconsider what we might lose when generative AI removes the grind from building software.
The story I had been telling myself went roughly like this: the grind was never the point. AI compresses it, leaving us with more time and energy for the joyful, creative work of building. It was a clean narrative, easy to share and perhaps mostly wrong.
There are two kinds of grind.
The first is friction: boilerplate, dependency problems and repetitive tasks that demand effort without deepening our understanding. It is the work that makes you think, surely I should not have to do this for the hundredth time. AI is increasingly good at stripping away that kind of grind, and we should welcome it.
The second kind is where learning happens: the mistake you have to diagnose, the approach that fails, the afternoon spent working out why an AI keeps hallucinating. These experiences can feel like friction while we are inside them, but they leave us more capable than they found us. That grind is not getting in the way of the work. It is the work.
The distinction is not fixed. The same task can be empty repetition for an expert and valuable experience for a novice. Debugging an authentication failure for the tenth time may teach one person nothing; solving it for the first time may give someone else a lasting understanding of how the system behaves. Removing effort is not automatically progress. We have to ask what the effort is producing.
The grind that teaches you nothing is worth removing. Solving the same simple but laborious problem for the fourth time in a week does not make you better at it. It makes you tired. This is where AI tools excel: removing effort that consumes time without building skill.
The grind that teaches you something is worth protecting.
Brendon can hold his sculpture and feel the gap between the idea and the object. Software developers have often had to wait much longer to experience that loop. They might feel the relief of shipping or the exhaustion of debugging, but the moment when an idea reaches a user and gives them feedback has not happened as often or as quickly as it should.
AI tools change that. You can imagine something in the morning, have a working prototype before lunch and learn from someone using it that afternoon. The distance between imagination and tangible output has collapsed. The joy Brendon described is now available to many more of us.
That speed is exhilarating. It is also where the danger begins. If AI helps us produce prototypes without requiring us to understand them, the loop has become faster but not necessarily more educational. We can generate more while learning less.
Vibe coding can produce a working artefact: evidence that an idea can work. A working capability is something an organisation can operate reliably, securely and repeatedly. Getting from one to the other requires more than generated code. Someone must understand the assumptions, the data, the failure modes and the environment in which the thing has to operate.
That understanding does not appear automatically when the prototype runs. It develops when someone tests the limits, encounters a problem and stays with it long enough to work out what is happening. AI can help diagnose the problem and propose a fix, but the builder still has to decide whether the explanation is credible and whether the fix is right for this system, this customer and this context.
A hundred vibe coded prototypes that nobody uses for more than a day is not a successful AI transformation. It is a slop factory.
This matters particularly in businesses built on complex data. At OAG, a convincing interface is not enough. Schedule, pricing and status data each have their own texture, limitations and failure modes. A useful builder needs both domain knowledge and enough technical depth to recognise when something is wrong. Neither skill is sufficient on its own.
AI can accelerate the route to a first answer. It cannot remove the need for judgement about whether that answer deserves to become part of a product or process that other people rely on. Judgement develops through contact with reality: watching something fail, understanding why and carrying that understanding into the next version.
The practical response is not to preserve inefficient work for its own sake. Nobody becomes wiser because a deployment process is needlessly painful. The aim is to remove repetition while keeping the encounters that develop understanding.
Build something that solves a real problem. Then test its limits. Break it deliberately. Investigate the parts you do not understand, and involve people whose knowledge fills your gaps. Use AI to clear away the routine work and to help you explore, but do not outsource the explanation. If you cannot say why the thing works, where it is likely to fail and what would make it safe to rely on, you do not yet have a capability.
The rhythm is simple: build, break, learn, rebuild. AI can collapse the first step from weeks to hours. Your learning loop is still yours, but faster than ever.
If you build ten prototypes and understand no more at the end, you have produced activity rather than capability. The useful measure is not how many things you generated. It is whether each cycle improved your understanding of the problem, the data and the system.
For nearly a century, OAG has been built by people who understood aviation data deeply enough to turn it into something valuable. That depth came from time, attention and a willingness to stay with difficult problems until they yielded.
AI allows us to remove much of the routine effort surrounding that work. We should. But we should not mistake all difficulty for waste. Some difficulty is where judgement develops.
Brendon’s joy comes from making, encountering the gap and learning from it. Ours can too. We just have different materials and new tools.
The Builders Blog is a practitioner-first publication on AI, aviation data, and building things that actually work. Subscribe to The Builders Blog LinkedIn newsletter here.