> With compilers there is a (roughly, barring optimizations) 1:1 correspondence between input and output.

This is repeated in a lot of comments here but hasn't really been true for a while. I remember, c. 2010, Kenton Varda complaining to Google's internal compiler team about how it generated some particularly non-intuitive assembly code out of the protobuf generated code, and the response was "Yeah everything is adaptive optimization now. Benchmark it and give us a profile and we'll put it in the compiler test suite. Trying to reason about what the compiler is doing and micro-optimize accordingly hasn't worked since the mid-90s."

I do think that LLMs are a step change in how we program computers, but the main step change is that the source language is now English, which opens up programming to a wider market accordingly. And this'll come with all the downsides of English: the ambiguity, lack of precision, multiple meanings, and so on. If you try to recover that control over what the computer generates, you end up reinventing computer science. (Which isn't that far off from how I use LLMs to program: anything that has widely accepted "best practices", I'll just let the LLM do, but if there's anything novel or requiring high-precision, I'll tell it "leave that function body blank; here are the inputs and outputs to the rest of the program; I will fill in the algorithm details myself.")

I also think that people are underselling the extent to which compilers were a step change to previous practices of programming. For someone accustomed to C, try doing register allocation or inlining yourself; you will suck at it, and it will take up the vast majority of your head space that could be spent on better things. For someone accustomed to a garbage-collected language like Python, try doing manual memory allocation and object ownership yourself; you will suck at it, and it will take up the vast majority of your head space that could be spent on better things.

I agree. Programming was just a natural first problem to tackle, but the impact will not be limited there. If you give today's best model access to all the data sources and systems an average white collar worker has, it probably could do most of their job. But organizational change takes its time, systems need to be integrated into new AI tools and so on, so it will take a while.

People tend to overestimate change in short term, and underestimate it in long term. AI hasn't replaced programmers yet, but I believe it will replace most white collar workers in 20 years.

You can absolutely spot people that aren’t using the latest models personally because they succeed in clinging to notions that doing so would dispel in three seconds.

Opus 5.5 produces code far better than 95% of professional devs, and it only stands to get “worse” from here on out.

Quite where this leaves any of the people in these information processing jobs is anyone’s guess.

"With LLMs you take an idea and it will drive the whole thing from the beginning all the way to the end."

Well if you think that's what it's doing - that's on you.

For gosh sakes, start with Claude Shannon's 'noisy channel problem' and consider why the notion of idea -> program is a fallacy.

That's for the Wix, Lovable and Shopify - wherein AI is only a component, and where the conditions are highly constrained.

To manage the output in detail, we need abstractions ... which do not exist.

Code -> Machine Instructions is not a noisy channel - it's deterministic.

Idea -> Code is theoretically not possible at any scale in a stable scenario because it's not deterministic, it won't make 'what you want' - then you have to spend a Million Mythical Man Hours to get it to do what you want.

Given that only a small portion of a developers job was ever 'writing code' in the first place - and that we write on average a fairly small number of 'usable lines of code' per day, the 'coding' was never it.

Research, prototypes, corners cases, help, bug fixes, ideation - so many ways it's powerful ... but not like a compiler.

Ignoring AI is like ignoring the industrial revolution, but AI is something very different than.

Also while some jobs are going to go - software hiring is up, not down - that should be a clue.

Only for those not up to date with modern compilers and language runtimes.

The 1:1 is long gone, that is the UNIX K&R C days.

Modern compilers are full of heuristics, PGO driven optimizations, machine learning compiler passes, JIT compilers, and various kinds of GC implementations, the time of 1:1 mappings is long gone.

So true. I believe the programming harness is only the first of many many harnesses that will soon displace all knowledge workers. The LLMs already contain all the weights and facts. They just need loops to get results out.

It’s basically moving from chat (conversational copiloting) to result driven agent harnesses, exactly what happened with code. To us.

The reason it happened so fast with code is because: - anthropic is a software company and scratching their own itch - open source codebases in training input - vast amount of books and docs too - real-time linters and tests provide confident feedback for closing the loop quickly

Other occupations will want to limit their public knowledge sharing (sadly) and avoid formal specification / standardization of their unique workflows. And definitely avoid equivalents of realtime linters and tests.

I think a better comparison is website builders, and people still paid web devs.

Everyone in this thread is being pedantic about what optimization is but missing the point that code is a precise description of some virtual machine that is realized with near perfect accuracy by the compiler. Yeah you don't know exactly what the silicon is doing with a modern compiler but you do know that the final result of the program for any input will be defined by whatever the correct interpretation of the program is, as if the structure the programming language implies actually existed.

LLMs are not this, and they cannot be this because it is their ability to operate on vague instructions that make them as powerful as they are. They can take an imprecise natural language description of a process and realize it as a process in a programming language. The problem is that understanding and manipulating the precise problem description is your job as a software engineer. The LLM can and will make its best attempt based on what exists in its training data, but it cannot know what is the precise behavior that actually fulfills goals and I think, contrary to the parent article, it cannot determine where the edges are to ask you with enough certainty that you will be able to take your hands completely off the wheel.

I think the nature of LLMs also explains why it is good at the verticals it is good at. Porting is an extremely well defined, replicate the behavior on another platform. There are far fewer vagueries in that. Game dev is not extremely well defined, but the consequences of imprecision do not have a lot on the line. Furthermore, games are pretty self-contained, so there's not a lot of guessing about what could happen or what the behavior of a counterparty system could be. With some pretty big exceptions, it is all there for the LLM to see in C++ (or whatever).

The new "coding" is trying to write an accurate specification so the LLM will generate what you want.

It's definitely going to be a socioeconomic shock, but staring at a screen for 8 hours a day is something I won't miss.

No it isn't lmao, it's coming for the rote, statistically average part of a job. It can't do the unexpected. While it has turned out that the unexpected is way, way smaller than many presupposed, it remains true. And if it did take over all information jobs, that would be the end of LLM improvement, forever. Hapsburg, model degeneration, whatever.

bro they've been saying this for five years now and the only people affected are copywriters and translators, and for the latter, unwisely. it is absolutely not coming for all white collar jobs. anyone who uses a coding agent sees these things fail in familiar machine misunderstanding ways that make sense to programmer, and in roles where data is not easily captured in text, humans are needed to keep the LLM in touch with reality

when is it going to happen already? OpenAI says Astra is AGI. why hasn't your prediction already come to pass? it's not early, it's late, these companies owe $1.5T. It's time for your side to start explaining why exactly GPT 3 or 4 or 5 or Astra hasn't already caused this in the way it's been predicted over and over by the labs

Whenever I read these arguments, it seems to me like folks are talking past each other because programmers tend to fall into two camps.

Those who spend time thinking about a problem, then writing design notes, specifications, and test plans, and focus on the implementation last. For these people, AI agents primarily act like an extension to their existing toolchain, and thus like the analogy of "AI as the new compiler".

The other side are people who don't like writing specifications and such, and rather prefer to sit down figure things out as they start coding. For them, an agent feels radically different from a compiler.

In both instances the AI agent is still the same tool, with the same real-world capabilities and limitations. It is not like one camp is blind, they just have very different workflows.

It also seems to me like many in the "sit down and code" camp then slowly figure out that doing some planning ahead of time helps them get better results, and they see this as another AI-led paradigm shift, when in reality it is how many other programmers have worked for decades.

> With compilers there is a (roughly, barring optimizations) 1:1 correspondence between input and output.

Maybe if you are using a compiler to provider a portable assembler (i.e. C) where ~1:1 mapping is the whole point. But in that case you'd be actually be using assembler instead in a world where all CPUs were the same.

That is very narrow view, though. Often — and I'd say most often — people use compilers so they can think in higher levels of abstraction, like SQL. Taking SQL and adding millions or billions of additional keywords doesn't really change anything with respect to the concept. Its still the same thing at the end of the day, even of those millions/billions of additional keywords are much more powerful than a small set of keywords.