Note: This video and podcast was generated using AI, adapting the original content and technical insights created by the author of the Jax London blog post.

Venkat Subramaniam likes to tell the story of a bus ride thirty years ago, after a glacier tour in Canada. The driver offered the group two ways back down into the valley: two hours by road, or twenty seconds – over the cliff. Nobody took the short way. That, says Subramaniam, is where software development stands right now: AI can generate a great deal of code in twenty seconds. But not every fast route is a good one.

Forty Years of Discipline

Subramaniam is not just another voice weighing in on AI. As a book author and a regular keynote speaker and trainer at conferences worldwide, he has spent four decades defending the very questions most developers find tedious: why a method runs too long. Why a name has to carry its full meaning. Why a test should say more than just “green.”

His best-known distinction sums up the stance: the novice asks which code he can write. The expert asks which code he can avoid writing – because code is a liability, not an asset. He has trained and shaped generations of developers with that stance. For many in the field, he is something close to a role model.

“Who are you?” is a trick question for him. The wrong answer: Java programmer, Python programmer, Kotlin programmer. His own answer runs differently: We are not programmers. We are problem solvers. Programming is just one of the tools we use.

That’s why his reaction to AI is surprising. No regret that a machine now does the coding. No “it will never do it as well as I can.” Subramaniam describes himself as fascinated, not afraid – for one simple reason: every moment in life is a chance to learn. He also has an explanation for why others feel differently: someone who has done a task the same way for a long time feels threatened when a tool takes over that part – their turf is under threat. But the tool only removes, not the part that matters. His own goal, Subramaniam says, hasn’t changed. He has simply been handed a far more powerful tool to reach it.

You’ll soon be able to see this man live: Venkat Subramaniam is delivering one of the keynotes at the upcoming JAX London. Anyone who wants to go deeper can spend two days with him in working in his intense bootcamp during the conference (October 5-9, 2026).

Learn more: Subramaniam’s own two appearances at JAX London go deeper into exactly this stance.

• Bootcamp: Building AI-Ready Systems with Clean Code, Software Design & Architecture — Venkat Subramaniam, Agile Developer, Inc. (two-day workshop, October 5 & 9)
• Worth a Million Arguments — Venkat Subramaniam, Agile Developer, Inc. (keynote)

Speed Without Discipline Is Not Progress

“Speed plus discipline is agility. Speed without discipline is a disaster.” The line sounds like a slogan. But it’s really an observation from forty years of practice – and it applies directly to working with AI: AI supplies the speed. What comes of it depends on who wields it. Subramaniam has spent decades training developers in Java, Kotlin, and other languages – and still says: at its core, this isn’t about the language. It’s about a mindset. Development teams have always wanted to do the right thing. They just never had the time. Normally, that comes at a cost. Under deadline pressure, you know the standard you should meet. You let it slide anyway – there’s no time left. For the first time, says Subramaniam, teams can move fast and still do things right. For engineers, this is finally the chance to make up for missing discipline.

“You can outsource development to AI. You cannot outsource your own reputation.” he says.

Russ Miles, another JAX London keynote speaker, makes the same point with a different image: brakes on a car aren’t there to stop it. They’re what let you drive faster than you could safely coast to a stop. Take them away, and speed isn’t freedom – it’s just delay before a crash.

Discipline Shows in Building, Not in Talking

What this looks like in practice is illustrated by an episode from the weeks before our conversation. A client wanted a particular feature. Subramaniam’s gut feeling: not a good idea. But how do you tell someone that before you’ve actually tested it? That would be just a hunch – a bias, as he himself puts it. So he thanked the client for the idea and used AI to build it as a working prototype in ten minutes. The client looked at it. Within a few minutes, both of them agreed: not a good idea, let’s drop it. 

Software, he says, displays the “observer effect”: the moment you see something, you want to change it. That moment of seeing used to cost days or weeks of prototyping. Today it costs ten minutes – the software equivalent of 3D printing in mechanical engineering.

Responsibility Can’t Be Rolled Back

At JAX London you will also meet Rod Johnson, the creator of the Spring Framework, who has spent years working on enterprise software – systems that don’t end at a prototype but carry real business processes. He draws a distinction that gives Subramaniam’s principle additional backing: AI as a personal assistant is impressively reliable, because mistakes cost almost nothing. One “git revert,” and the error is gone. AI as an automated business process is a different matter. Not everything there can be rolled back.

An example: a chatbot at Air Canada that mistakenly promised a customer a far-too-generous fare. The airline tried to walk it back afterward – but the customer had already accepted the offer. Air Canada ended up in court. And lost. You can’t roll back a promise the way you roll back a commit.

Learn more: The Air Canada example is one case. Here’s where the industry works through the rest.

• Trade-Offs Are Everything: Non-functional Requirements For the AI Era — Eoin Woods, Artechra
• Low Latency Machine – Can Generative AI Write High-Performance Code? — Sumit Gundawar

The Industry Has Made This Mistake Twice Before

Here’s the obvious objection: many companies think this is simple: If AI makes us this productive, why not cut the workforce? Subramaniam is firmly convinced it won’t play out that way. He’s seen this movie before – twice.

The first time was offshoring, in the early 2000s. Western software development was supposedly finished – why build expensively at home when it’s cheaper elsewhere? Offshoring did absorb real capacity spikes. But in the process, the industry learned something it had only suspected: software development is communication, understanding, iteration – short paths to customers and stakeholders. That insight got a name. Agile. In the end, we needed more developers than ever.

The second memory is more recent: the automation of testing. Anyone who believed at the time that automated tests would make professional testers redundant was thoroughly wrong. Automation didn’t shrink testing. It made it bigger – more systemic, more complex, more demanding. The job grew; it didn’t disappear. 

Subramaniam draws a simple conclusion for AI from this: anyone who thinks a more powerful tool makes the job smaller hasn’t understood the history.

Both Matter: Fundamentals and Critical Thinking

So what does it take, if not knowledge of a programming language? Subramaniam answers with two words he repeats in almost every sentence: fundamentals and critical thinking. Fundamentals means understanding what production software actually requires – performance, security, reliability, resilience. Critical thinking means the ability to ask, of every AI output: Does this actually make sense? Is there a better way?

A project manager once asked him whether fundamentals were even necessary anymore, since AI would have his back. Subramaniam’s answer came without hesitation: AI will not have anyone’s back. It will expose you in public, in the most humiliating way possible. Knowledge isn’t something AI replaces – only the execution is replaceable, not the knowledge itself.

Russ Miles describes almost the same risk, just with different vocabulary. He calls it cognitive debt: the moment you no longer understand your own codebase because you’ve handed too much of it over to AI. Two terms, the same concern. Knowledge doesn’t vanish just because you no longer perform a task every day. But it does vanish once you stop needing it.

Learn more: These same two questions – what fundamentals still matter, and how to think critically about AI output – get worked through live at JAX London.

• When Everyone Can Generate Code: Why Algorithms and Engineering Skills Matter in the Age of AI — Michael Inden, OST
• Patterns and Anti-patterns of Agentic Engineering — Victor Rentea, Independent Trainer

70% of the Work Is Reading Code, Not Writing

Anyone who wants to know what actually happens in the JAX London bootcamp should remember a number Subramaniam likes to cite: roughly seventy percent of working with code is reading, only thirty percent is writing. AI is strongest precisely where humans are weakest – handling cognitive load, complexity that can’t be grasped at a glance. Subramaniam compares this to a lawnmower with cruise control. The machine handles the speed. Steering is still done by hand.

That steering is what he teaches. One of his recurring rules: you always have to understand one abstraction level below the one you’re working at – otherwise you can’t judge when something breaks. It’s what his two-day bootcamp practices: day one at the code level, day two at the architecture level – not to master AI, but to sharpen your own judgment while AI does the code writing.

Not an AI Problem. An Enterprise Problem.

At this point, Rod Johnson states: enterprise AI is not a data science problem and not a machine learning problem. It’s an application development problem. Exactly the field engineers have always mastered – building systems that are robust, maintainable, and integrable. The tools currently coming out of AI research don’t automatically solve that problem. That’s work for people who understand how businesses actually function.

This is also where a conference like JAX London is redefining itself. It’s consistently oriented toward enterprise AI – technology-agnostic, not tied to any one language, though it comes from a Java ecosystem legacy. Johnson, who comes from the Java world as the creator of Spring, confirms from his own experience why that shift is the right one: the questions that matter aren’t about language. They’re about how you integrate AI into systems, domain knowledge, and lines of responsibility that already exist.

That New Mindset Can Be Learned

Asked what participants take away from his bootcamp, Subramaniam answers without hesitation. The old norm was “trust but verify.” His new norm sounds tougher: “Don’t trust, and verify the heck out of it.” He sums up his goal in a single sentence that could stand as the motto over the entire JAX London bootcamp: “We want sustainable speed, not uncontrolled speed.”

His keynote in London is titled “Worth a Million Arguments” – about how to make technical decisions when every option seems to sound equally good. Russ Miles and Rod Johnson contribute, in their own keynotes, the two frames that have run through this piece: the question of identity and collaboration on one side, the question of enterprise readiness on the other.

Why This Is the Best Time to Be an Engineer

AI is changing plenty about how software gets built. The popular view treats this as full automation – hand it the problem, get back the software, humans optional. Subramaniam has spent forty years defending fundamentals precisely because they don’t become optional just because a machine got faster. Johnson insists enterprise AI is an application development problem, not a data science one. Miles calls the alternative cognitive debt.

That’s the real news, and it’s good news: the principles – discipline, fundamentals, critical thinking – matter more now than they have in decades. Not despite AI, but because of it.

That’s the work JAX London is set up for. Subramaniam, Johnson, Miles, and a wider lineup of great speakers aren’t there to explain a tool. They’re there to build the engineering culture this moment actually calls for. Nobody leaves with a final answer. Everybody leaves with better questions.