By Francesco Marcolini
There’s been a lot of discussion recently about whether AI is genuinely making software development faster, or whether we’re simply shifting the effort from writing code to reviewing, debugging and fixing it. Another topic that keeps coming up is whether AI is taking the enjoyment out of programming, turning developers into people who spend their days writing prompts rather than writing code.
I’ve been writing software for over 30 years, and, like many developers, I’ve recently been spending more and more time working with AI-assisted development. During that time, I’ve gradually settled into an approach that works extremely well for me, allowing me to take full advantage of AI’s capabilities without losing control of what I’m building or, just as importantly, the pleasure of programming.
I thought I’d share my experience and how my way of working has evolved.
The problem with generating too much code
One of the most impressive things about AI is how quickly it can generate code. You can describe an application, ask AI to build it, and within minutes have something that might previously have taken days or weeks to write. That’s an extraordinary capability, but generating code quickly and developing software quickly are not necessarily the same thing.
Traditionally, software development involved spending time understanding requirements, designing the architecture, writing the code, reviewing it, testing it and fixing whatever didn’t work. With AI, it’s tempting to skip much of that initial analysis and design, jump straight into generating code and deal with the problems afterwards. The immediate results can be impressive, but I think this is also where some of the difficulties people are now discussing originate.
AI can generate thousands upon thousands of lines of code in very little time, but who’s going to review all that code, and how well does the developer actually understand it? When you’ve designed and written an application yourself, you know how the components fit together, why certain decisions were made and where to look when something goes wrong. When AI has designed and generated everything, that knowledge isn’t necessarily there, and reviewing thousands of lines of unfamiliar code can become an enormous, almost impossible task.
What I see happening is that development can turn into a continuous cycle of trial and error. You run the application, discover something isn’t working, explain the problem to AI, let it generate more code, try again and repeat the process until things eventually work. The problem is that each iteration can introduce additional complexity, and even when the application finally behaves as expected, the underlying code can become increasingly difficult to understand, debug and maintain. There’s also the considerable number of tokens consumed by repeatedly asking AI to correct code that nobody has really examined in detail.
Some things AI does remind me of a junior developer
Having spent so many years writing and reviewing code, I’ve developed fairly strong opinions about what makes software maintainable, and there are certain patterns in AI-generated code that I find particularly frustrating.
One is its tendency to introduce unnecessary complexity. I’ve seen AI create an entire class containing a single method, used in exactly one place, without any apparent architectural reason for doing so. At the same time, I’ve noticed that it can be surprisingly poor at recognising opportunities for useful abstraction, often writing several methods that perform essentially the same operation with only minor differences, rather than identifying the common functionality and extracting it into a single reusable method.
This is something I’ve always considered fundamental to good software development: recognising common patterns, avoiding duplication and keeping the implementation as simple as possible without sacrificing clarity. Yet AI seems quite capable of introducing abstractions where none are needed while overlooking obvious opportunities to simplify code through reuse. The result is often more code than necessary, with the additional maintenance problems that come with it.
Another habit I’ve noticed is excessive defensive programming. AI frequently checks parameters that have already been validated, sanitises data repeatedly just in case something unexpected appears, and introduces null checks for values that, according to the application’s design, should never be null. Naturally, external inputs must be validated and genuinely uncertain conditions need to be handled, but I’ve always preferred establishing clear contracts and validating data at the boundaries of a system, so that internal components can rely on those guarantees.
If invalid data reaches a component where it should never appear, I’d rather have the application fail (gracefully, of course), exposing the problem so it can be fixed at its source, than have another layer of code silently compensate for it and potentially hide the underlying issue.
In some respects, AI reminds me of a junior developer who knows a great many programming techniques but hasn’t yet developed the experience to judge when they’re appropriate. I suspect some of these habits reflect patterns found in the enormous quantities of existing code used to train AI models, although that’s only my impression. Whatever the explanation, these are things I’ve encountered often enough to influence how I choose to work with AI.
Finding my own way of working
Over time, I’ve settled into an approach that is somewhat different from asking AI to design and implement an entire application.
I begin by describing the system I want to build, including its purpose, requirements, expected behaviour and main components. AI is extremely useful at this stage, helping me organise ideas, refine requirements and produce documentation that I can refer to throughout development. I’ve used Markdown files extensively for this, although more recently I’ve started experimenting with HTML documentation, which I find more practical and easier to navigate.
Once I have a clear understanding of what I’m building, I start writing code myself. I design the architecture, establish the structure of the application and create the initial framework, defining the main components, their responsibilities and how they interact. I often work my way down to the individual classes, because I want to understand not only the overall architecture but also how the underlying implementation is organised.
This is an important part of the process for me. Over the years, I’ve learnt that good foundations make an enormous difference to the quality and maintainability of software, and I want to remain responsible for those decisions rather than delegate them entirely to AI.
Once the structure is established, I start giving AI implementation tasks, together with very precise instructions about how the code should be written, how it should fit into the existing framework and which conventions and patterns it must follow. AI still writes a substantial amount of code, particularly the more routine implementation details, but it does so within an architecture that I’ve designed and understand.
The distinction is that I’m not asking AI to decide how the application should be built. I’m asking it to implement functionality within a structure that I’ve already established, and I remain responsible for both the architecture and the coding principles being followed.
I think of AI as a very capable and remarkably fast assistant, rather than someone to whom I’ve handed over the entire engineering process.
Slower at the beginning, faster afterwards
One interesting consequence of working this way is that progress can initially appear slower. While AI could already be generating large amounts of code, I’m still analysing requirements, designing components, establishing conventions and writing the initial framework, so there may not be much visible functionality to show for the effort.
However, once those foundations are in place, development accelerates considerably. AI can implement functionality quickly because the architecture is already defined, the coding guidelines are clear and there are far fewer decisions left open to interpretation. Instead of repeatedly correcting structural problems or refactoring implementations that don’t fit together, I can concentrate on adding functionality and moving the application forward.
I still review and test the code, of course, but there’s a substantial difference between reviewing an implementation whose structure and purpose I already understand and trying to make sense of thousands of lines of unfamiliar code generated from a broad prompt. Because I know how the application is organised and AI is following established conventions, I find that there’s considerably less corrective work to do.
In my experience, the overall development process becomes progressively faster rather than starting at extraordinary speed and then slowing down under the weight of accumulated complexity. I can produce software much more quickly than I could before AI, while retaining a level of understanding and confidence in the code that I consider essential.
AI hasn’t taken away my enjoyment of programming
Another topic I’ve seen discussed quite frequently is how AI is taking the joy out of programming. I can understand why some developers feel that way, particularly if their daily work has shifted from designing and writing software to repeatedly prompting AI, testing the results and asking for corrections.
For me, however, the experience has been quite different, and this is one of the things I particularly like about the approach I’ve adopted.
After more than 30 years, I still genuinely enjoy writing code. I enjoy thinking through a problem, designing a solution, working out how the different components should fit together and writing the code that establishes the foundations. I still enjoy getting into that familiar zone where you’re completely absorbed in what you’re building, and hours can pass without you really noticing.
In fact, as I’m writing this article, I’ve just spent the entire day programming, and I’ve thoroughly enjoyed it. AI hasn’t taken that experience away from me, because I’m still actively involved in designing and building the software rather than simply describing what I want and waiting for the result.
What AI has largely taken away is the repetitive implementation work: the smaller details, the routine methods and all those parts of development that need to be done but aren’t necessarily the most interesting or rewarding. I still make the important technical decisions, write the code I want to write and understand how everything works, but I no longer need to implement every detail myself.
The result is that I can spend more time on the aspects of programming I enjoy most, while producing considerably more software in the same amount of time. For me, that’s a very good balance.
Will I still be working this way in five years?
Probably not, or at least not in exactly the same way.
AI is improving at an extraordinary pace, and I can easily imagine a future where models become capable of designing and implementing entire software systems with a level of reliability, consistency and architectural understanding that makes much of today’s development process unnecessary. Perhaps that future will arrive sooner than we expect.
However, I also think the transition will take time, particularly for companies with established systems, existing development practices and demanding reliability requirements. For the time being, I see considerable value in combining the experience and judgement of developers with the remarkable implementation capabilities that AI already provides.
This is the way I’ve chosen to work with AI, and it’s working extremely well for me. I’m using AI more than ever, writing fewer lines of code than I used to and producing software considerably faster, but I’m still designing, still programming and still in control of what I’m building.
And there’s a certain irony in all this: I wrote this article with the help of AI, during the short breaks while it was working on the smaller coding tasks I’d given it. While AI was busy implementing those bits, I was putting together my thoughts for this article, which, come to think of it, is a pretty good example of the way I now work.
I’m still coding. Just differently.


