For years I’ve held up my hands like I’m describing the size of a fish I caught once (never been fishing but that is not your bee’s wax), showing the range of software quality. On one end: move fast and break things. On the other: quality is non-negotiable.
Most of us have spent our careers swimming somewhere in the middle of that spectrum. Deadlines loom, features need shipped, and we quietly nudge the principles aside in the name of speed (there is always a million dollar deal resting on that button being pink). We tell ourselves we’ll fix it later. Spoiler: we rarely do.
The landscape has shifted.
From Speed to Quality
AI has made speed a commodity. Scaffolding, testing, refactoring, they all happen in seconds now. The thing that sets teams apart isn’t how fast they can move, but how well they can keep the quality of their systems intact while moving that fast.
If “move fast and break things” was the motto of the last decade, the new reality is:
“move fast but don’t break things” – Chris Oliver 2025
That only works if quality is treated as the non-negotiable end of the spectrum and we find ways to make that fast.
All those resumé terms are key
The classics (bangers 🎵) haven’t gone anywhere, they are more important now. One of the big headaches with AI-assisted and agentic coding is context sprawl. These tools can only work with what they “see” and the bigger and messier your codebase, the hardier (lol) it is for them to stay on track.
That’s where principles earn their keep:
- Single Responsibility (SOLID) keeps classes small and focused, making them easier for AI to reason about.
- KISS reduces noise and unnecessary complexity, which means fewer misleading signals.
- DRY cuts duplication, so the model doesn’t have to guess which of three slightly different implementations you meant.
Following principles doesn’t just help humans, it helps machines help us. Cleaner, simpler code narrows the context window, reduces hallucinations, and gives you more reliable AI output.
New Principles for the AI Era
Trust but Verify
AI is confident, often too confident. It will suggest code that looks plausible but hides subtle bugs, inefficiencies, or security risks. Your role as an engineer is to bring the scepticism. Treat AI like a bright junior dev: listen, learn, but always review before merging.
Leverage, Don’t Abdicate
AI is an accelerator, not a chauffeur. Use it to draft boilerplate, generate tests, or suggest refactors but don’t hand over the steering wheel. The danger isn’t just bad code, it’s losing touch with the system you’re responsible for. Hate picking up legacy software and the engineer that wrote it left to farm cheese or something, don’t become the cheese farmer of your own software! Delegation is fine. Abdication isn’t.
Transparency First
Black-box code is the fastest route to future pain. If you don’t understand how something works, whether AI wrote it or you did, it doesn’t belong in production. Demand clarity. Favour code you can reason about over code that looks clever.
Quality > Speed
The old trade-off is gone. Speed is cheap; anyone can scaffold fast. What’s scarce and valuable is quality. Build tests, enforce boundaries, and design for maintainability. AI multiplies whatever foundations you give it, so give it solid ones
Principles Enable Agents
Cleaner codebases aren’t just better for humans, they’re friendlier for AI. Small, focused classes reduce hallucination. Consistent naming and DRY practices keep context sharp. In short: the more you follow principles, the better agentic coding works.
Closing Thought
When I hold up my hands again to illustrate that “fish of quality,” the industry must shift toward the quality is non-negotiable end. AI didn’t make engineering easier; it made it more important to get the fundamentals right.
The best engineers aren’t the ones who ship the fastest. They’re the ones who can swim in these waters moving fast but never letting go of quality.
Quality is the new speed.