I just realized something quite interesting — the software development industry is undergoing a transformation I’ve never seen in my 20+ years of career.

Over twenty years ago, I started DCSL Software (, which later became One Beyond). I left the company in 2023 when it had over 300 employees and was operating globally. Afterwards, I founded a robotics startup and raised over 4 million pounds. Honestly, I never thought I’d go back to coding.

Since 2014, I’ve stopped writing code daily. Not because I couldn’t, but simply because it’s a natural progression as a company grows. You hire smarter people, focus on leadership, and gradually the keyboard becomes less relevant. Nearly a decade like that feels completely normal.

But the surprising part is that recently, I find myself returning to the role of developer — not out of nostalgia, but because of practical necessity. I’m building a truly complex robotics platform. And my way of working is completely different from before.

This personal shift clearly shows me that something fundamental has changed in how we approach software development.

Looking back, we used to work in a waterfall model. It’s not just theory; it’s pure economics. Code is expensive and slow to build, so the only rational approach was to think carefully from the start. We wrote detailed specifications because we had to — contracts, delivery, everything depended on them. Writing a good spec was a rare skill, and I happened to be pretty good at it. I could envision what the finished product would look like before it existed, anticipate complex parts, and describe behaviors with enough precision for a team to build upon.

Then, the industry shifted to Agile. Publicly, because it’s better for responding to change. Privately, because we realized that no specifications truly exist intact in large, long-term systems. Businesses change, users change, technology changes. Agile is useful, but it comes at a cost. We abandoned deep upfront design, instead discovering gradually. It works, but it also normalized a mindset that thinking too far ahead is unnecessary or even risky.

Now, I realize the reason I can go back to coding isn’t because I suddenly have time or want to relearn a decade of new tools. It’s because AI has fundamentally changed the cost of experimentation.

People often misunderstand this point. The real change isn’t that code is written faster. It’s that now everything can be tested quickly, cheaply, and most can be reversed. What used to take weeks for a developer can now be tested in minutes. You explore an approach, see how it feels, discard it entirely, and try a different one with almost no penalty. That was simply impossible before.

Previously, code created strong emotional and financial attachment. If something took two developers three weeks to build, it’s understandable not to want to throw it away. Hard decisions were made early, not always because they were right, but because reversing them was too costly. That constraint has disappeared, and that’s why I’m returning.

Now, I operate at my strongest — understanding the problem, shaping the system, detecting complexity — while AI handles mechanisms. I don’t write code the way I did at twenty. I direct it, fine-tune it, fix it, and occasionally stop it from going astray. This feels more like leading a team than coding. You’re truly the boss — setting direction, reviewing results, spotting lazy shortcuts.

A common misconception is that this new freedom makes design less important. In fact, it’s the opposite. Having a clear, detailed idea of what you’re building remains extremely valuable. It even improves AI output. The clearer your intent, the better the results. Vague thinking only produces more ambiguous systems faster.

AI operates like a person. It wants to help, to provide answers. If you’re vague, it fills in the gaps. If you’re careless, it makes assumptions. If you don’t challenge it, it confidently keeps going down the wrong path.

But design is no longer a fragile product that must remain unchanged for years. It becomes a guide for experimentation, not a constraint. You maintain a strong vision of where you’re headed, while being ready to test, discard, and evolve the path to get there.

The new skill is knowing when exploration is effective and when it’s just noise. AI will happily keep creating structure long after it should be simplified. It doesn’t know when a file is too large, when an abstraction leaks, or when something that works today will cause pain later. Those instincts still come from experience.

When experimentation becomes cheap, many long-term assumptions no longer hold. Planning is no longer about locking everything down upfront. It’s about setting intentions, constraints, and boundaries. Estimating less about predicting effort, more about understanding the space you’re exploring. Our relationship with code has completely changed. Less attachment to specific implementations, more focus on behavior, structure, and outcomes.

That’s why the software industry feels unstable. Many try to apply old mental models to new tools. It works for a while but misses the core point.

I am confident this change is permanent because, very simply, I wouldn’t rebuild otherwise. The only reason I trust returning to practical software development after a decade is because the constraints that initially pushed me away no longer apply. Code can now evolve through guided experimentation in a way that was impossible before.

This doesn’t mean experience is less important. It means it’s different. Its value is no longer in memorizing syntax or frameworks. It’s in judgment, structure, and knowing when to stop.

This isn’t the end of software development. But it is the end of the old model. And once you work this way, there’s no going back.