Post

At the risk of starting the flame war to end all flame wars... Modern LLMs (GPT-5.1, Claude 4.5, Gemini 3) produce excellent code and can be a significant productivity boost to software engineers who take the time to learn how to effectively apply them - especially if used with coding agent tools

I wouldn't argue with that, but it supposes that the main issue with software development is the speed of production of code, and it is certainly not. Nothing I have seen has convinced me that no silver bullet is not still valid. We are still not reducing any of the essential complexity.

I'm also a bit anxious about a Jevon's paradox situation. I.e Code is cheaper, so we make and use more of it, which is likely to lead to more issues. Most of the cost of systems is in maintenance not build. We will see, if it was going to have a huge impact we should be seeing it.

Thats a really great application of Jevons I haven't seen before I've been thinking a bit recently about what changes now that code is much cheaper to write but I hadn't made the connection to that meaning there's going be a LOT more of it, which will cause all sorts of new problems

1 repost37 likes

There’s kind of an inverted incentive now; because writing code is easy, writing a lot if code is now a productivity antipattern. The most valuable engineer is no longer the one who can solve a problem with +10k lines of code in a weekend, but the one who can solve same with -2k lines.

I would argue that's always been true. We know that SLOC is a bad productivity metric. I've worked with people who would code all night and drop code bombs at 3am and they rarely help the situation. Productivity is completely solving problems, not writing code.

This has been my concern for a long time, not least because AI-written code has a tendency to be a _lot_ more verbose. I've already seen it in a professional context. The scariest part is that occasionally reviewing developers are so overwhelmed by the amount of code they turn to AI to review it...

One of the stories about the ca. 2014 healthcare.gov debacle was that systems had been created using codegen tools but operated, debugged, and repaired down at the level of the output Java code. No one had written it so no one could succeed at maintaining it. We’ve been here before.

The best analogy to me is compilers where you have to reason at the higher level ignoring the bytecode or assembly. If our high level language is going to be English language prompts we will need to stay up there through the full writing, reviewing, and maintaining cycle.

What intermediate artifacts or imperative styles will make that possible? Specs like OpenAPI or standards for test suites start to look a lot more important, and prompts look less like “write a function” and more declarative statements of intent or behavior, “a thing that does X”

Compilers are an interesting analogy! They're "AI" in that they can write assembly better than 99.99% of human devs. Most devs can't even *read* optimized compiler output. But compilers are deterministic (hugely important!) and sometimes you do need to know how they work (race conditions, etc.).

No code generation has succeeded there though. And I think there's real information theory reasons why. Compilers use context free grammars, it's not the same. Everyone who has tried using generative AI for code generation by now has realised there's a point where it just cannot do it.

I had some thoughts on this for a talk I gave recently about the impact of AI coding tools. Including this Jevons! One enterprise use of cheap code is that you can more economically do data migration by integrating the two systems instead of just moving the data. Lower risk, smoother transition.

A hard thing will be to stay strong about when to throw this code away. And to avoid having lots of cheap components which hide all the complexity in the interactions. We find hard to observe and reason about the complexity in between things