If AI writes the code, “easy to write” becomes a strange reason to choose a programming language.
Here’s a prediction that will annoy developers: we may be approaching the end of choosing programming languages primarily for the convenience of the person typing them.
For years, we’ve celebrated languages that let us express more with less effort. Cleaner syntax. Less boilerplate. Faster prototypes. Fewer things to remember.
Those advantages mattered when turning an idea into code consumed a large part of our attention.
But what happens if AI handles much of that translation?
If a machine can produce the verbose version, the convenience of writing the short version loses some of its value.
That doesn’t mean Python is dead. It means “Python is easy to write” could become a much weaker argument.
Your favourite syntax may be solving yesterday’s problem
Imagine choosing between two languages.
One is pleasant to write but leaves more mistakes to be discovered while the program runs. The other requires more explicit structure but catches more mistakes before deployment.
When humans write every line, that extra structure can feel expensive.
When AI generates the first draft, the calculation changes.
Perhaps we should welcome the boilerplate if it makes assumptions visible. Perhaps the compiler asking awkward questions is doing exactly what we need when a machine can generate plausible code faster than we can review it.
In that future, the winning language might be the one that makes incorrect code hardest to accept.
The language that feels most convenient at the keyboard might lose to the language that gives generated software the tightest boundaries.
Code is becoming cheap. Confidence isn’t.
The provocative version of this argument is that developers are defending their favourite languages using a cost model that AI is changing.
We still ask:
“How quickly can I write this?”
The more useful question may become:
“How cheaply can I establish that this works—and keep it working?”
Those questions lead to different priorities.
A concise implementation is less impressive if reviewing its behaviour takes longer. A beautiful abstraction is less helpful if nobody can explain what happens when a dependency fails. A working demo means little if the next generated change silently breaks an assumption.
Typing fewer characters doesn’t solve those problems.
Neither does generating more characters.
Python deserves a better defence than “it’s easy”
Python is the obvious target because its accessibility is such a prominent part of its appeal.
But dismissing it would be lazy. Libraries, existing systems, integration requirements, and the people maintaining a project all matter. Replacing a working ecosystem because another language looks better on paper can be an expensive mistake.
The challenge is narrower—and more uncomfortable:
If your strongest argument for Python is that it saves human effort while writing code, how strong is that argument when AI does much of the writing?
Defend the ecosystem. Defend its suitability for your workload. Defend the speed at which your team can investigate and fix problems.
But “look how few lines this takes” may stop winning the debate.
The uncomfortable counterargument: humans still have to read it
This is where the prediction could fall apart.
If AI makes code abundant, readable code might become more valuable. Someone still has to investigate incidents, challenge assumptions, and approve changes.
A language that is easy to understand could reduce the cost of supervising AI—even if ease of writing matters less.
That distinction is crucial.
Easy to write is not the same as easy to verify.
Sometimes they overlap. Sometimes a short expression hides enough behaviour to make the reviewer’s job harder.
The future may reward human readability. It just might reward a different kind of readability: explicit contracts, visible effects, predictable behaviour, and fewer surprises.
Programming languages aren’t dying. Our reasons for choosing them need an update.
My bet is that AI shifts the competition between languages.
Less emphasis on saving keystrokes. More emphasis on catching mistakes.
Less admiration for a tiny implementation. More scrutiny of what it guarantees.
Less loyalty to whatever feels comfortable. More attention to the cost of running, reviewing, and changing the system.
There won’t be one universal winner. A data experiment, a mobile app, and a payment service have different constraints.
But developers who refuse to reconsider their language preferences may find themselves optimising a part of the job that no longer costs very much.
If AI writes your next 10,000 lines, would you choose the language that makes them easiest to generate—or the one that makes them hardest to get wrong?
This is a prediction, not a benchmark. I’m interested in counterexamples that challenge its argument.
AI disclosure: I developed the argument in conversation with AI, which helped draft and structure this article.
Top comments (0)