Nope; the compiler was supposed to end <i>coding</i>; when the word <i>coding</i> referred to taking an abstract program written on paper and translating it to <i>machine code</i>.<p>Compilers were first called <i>automatic coders</i>.<p>The word <i>compiling</i> referred to something more like linking: producing an image containing multiple library routines. In other words, similar to compiling an anthology of works into a book.<p>After compilers, the word <i>coding</i> to changed to writing <i>program code</i> in any language.<p>Because the tooling for automatic coding also compiled the bits of code into a larger image, the term <i>compiler/compiling</i> came to be used for the coding part also.<p>While the terms reshuffled, the concrete reality was simply that people worked less in assembly language, not that fewer people worked or that programming ended.
> It’s 7:40 on a Tuesday morning in 2031, and you haven’t written a line of code yet. You probably won’t today, and that’s fine.<p>This sounds exactly like all my Tuesday mornings this year, except that I wasn't at work at 7:40
> In 1954, IBM said FORTRAN would virtually eliminate coding and debugging.<p>Only because Fortran was viewed as transcribing mathematical notation, which wasn’t considered coding. Coding originally referred to having to work with numeric machine codes. Programming languages like Fortran removed the need for having to deal with how to encode the program for a specific machine, and to deal with human errors in that encoding process (debugging). It didn’t mean abandoning formal specifications that you can reason about with a high degree of precision.<p>I also want to take the opportunity to point out the concept of notation as a tool of thought, coined a quarter century later by IBM fellow Iverson in his Turing Award lecture: <a href="https://www.recurse.com/blog/58-paper-of-the-week-notation-as-a-tool-of-thought" rel="nofollow">https://www.recurse.com/blog/58-paper-of-the-week-notation-a...</a>
If you can't see the difference between a compiler and an LLM then that's on you.<p>LLMs are a game changer in a completely different way than compilers. With compilers there is a (roughly, barring optimizations) 1:1 correspondence between input and output. With LLMs you take <i>an idea</i> and it will drive the whole thing from the beginning all the way to the end.<p>This is unlike anything that we've done so far. It's also strange to focus on programming: LLMs are coming for <i>all</i> information related jobs. If your job is somehow described as 'staring at a screen' then that job is on the line, if not sooner, than later.
> With compilers there is a (roughly, barring optimizations) 1:1 correspondence between input and output.<p>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."<p>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 <i>English</i>, 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.")<p>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.
Doesn't 1:1 correspondence between input and output just mean the compiler output is deterministic. There is no requirement that the output is machine code. For example cfront [1] was a complier whose output was C.<p>To me that points to the real the step change in LLMs. They are not deterministic and they always give a result to any query. Even if the query is invalid, missing data, or has no possible logically correct answer, you still get a result.<p>[1] <a href="https://en.wikipedia.org/wiki/Cfront" rel="nofollow">https://en.wikipedia.org/wiki/Cfront</a>
> This is repeated in a lot of comments here but hasn't really been true for a while.<p>It has also been addressed, already in the comment you are replying to as well as countless comments below.
That totally misses the point. No matter how surprising the output of the compiler's adaptive optimiser, the observable behaviour (except speed) of the program, when run, will be the same. That is clearly not true of LLM output.
That totally misses the point. No matter how surprising the output of the compiler's adaptive optimiser, its observable behaviour (except speed) will be the same. That is clearly not true of LLMs.
"With LLMs you take an idea and it will drive the whole thing from the beginning all the way to the end."<p>Well if you think that's what it's doing - that's on you.<p>For gosh sakes, start with Claude Shannon's 'noisy channel problem' and consider why the notion of idea -> program is a fallacy.<p>That's for the Wix, Lovable and Shopify - wherein AI is only a component, and where the conditions are highly constrained.<p>To manage the output in detail, we need abstractions ... which do not exist.<p>Code -> Machine Instructions is not a noisy channel - it's deterministic.<p>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.<p>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.<p>Research, prototypes, corners cases, help, bug fixes, ideation - so many ways it's powerful ... but not like a compiler.<p>Ignoring AI is like ignoring the industrial revolution, but AI is something very different than.<p>Also while some jobs are going to go - software hiring is up, not down - that should be a clue.
><i>For gosh sakes, start with Claude Shannon's 'noisy channel problem' and consider why the notion of idea -> program is a fallacy.</i><p>start with opening up codex or whatever you use. type "make me a calculator app". get your calculator app in an hour or whatever.<p>it's fair to describe this process as taking an idea and getting a program.
You can get simple Markov Chain algo to 'write an essay' as well.<p>It's not an appropriate equivalence because there's too much variation in the outcome <i>that cannot be meaningfully controlled</i> with the same leverage.<p>If what you were saying were true - there would be 100% not Software Developers anywhere, and Product Managers would be churning out new products daily. But it's not the case.
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.<p>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 actually claimed two very different things.<p>1) that LLMs can do existing white collar work well once some (possibly significant amount of) work is done to fully plug them in and get specifications settled.<p>2) That all white collar <i>workers</i> will be replaced by LLMs.<p>Perhaps a typo, but I don't think (1) implies (2).
I think the question of whether (1) implies (2) is the core of AI economic concerns. Will this be another 'normal' technological revolution where the jobs and workers adapt to provide value on top of the models that are able to automate their current work, or will there simply not be room in many areas to provide additional value on top of the automated work?<p>I think the latter would not occur under the current state of AI/LLMs, but the rapid pace of growth gives me pause.
> and get specifications settled.<p>In my ~20 year career in software, I've never once gotten adequate specifications. I honestly don't feel threatened.
> In my ~20 year career in software, I've never once gotten adequate specifications.<p>I haven't either (in my ~30 year career) other than maybe one or two rare occasions, but I also believe that having adequate specifications matters much less for the vast majority of software when the time & cost to fix a gap after you notice it shrinks to nearly nothing.<p>In the past bad specs resulted in huge problems due to process log-jams that came out of having to coordinate multiple human workers around the spec. But increasingly the person who poorly specified the thing the first time around can rectify the problem with a couple of new prompts.
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.<p>Opus 5.5 produces code far better than 95% of professional devs, and it only stands to get “worse” from here on out.<p>Quite where this leaves any of the people in these information processing jobs is anyone’s guess.
Opus makes boneheaded mistakes and engages in severe anti-patterns constantly. I use it, but it requires careful handholding on complex projects. It absolutely isn’t better than 95% of professional devs, that’s a ridiculous statement.
Yes it does but yes you can also steer it clear of those mistakes in a similar way as you would have to steer tour human team.<p>It still requires a lot of work and care to leverage correctly and it's a moving target.<p>But it's quite impressive
> Opus makes boneheaded mistakes and commits enormous anti-patterns constantly.<p>I would agree that it still does, but much less often than it did in the past. Compare what it produces today vs what it produced one year ago and the improvement is staggering.<p>(I'm talking across the whole LLM spectrum here, not really Opus in particular).<p>And AI doesn't have to replace literally 100% of the workforce to have a catastrophic economic impact.<p>If AI takes 50% of the jobs instead of 100% the economic destruction is roughly the same in the sense that you will already hit calamitous society-level tipping points long before you replace literally everyone.<p>For context the Great Depression was "only" 25% unemployment.
I hear this meme of "Opus writes better code than me" repeated a lot. I am absolutely baffled by it.<p>I use all the latest and greatest Anthropic (and OpenAI) models, and interact with them probably on average 10h a day. I experiment with changing effort levels, with different ways of prompting and guardrailing, etc. Giving more instructions, giving less instructions. Doing heavy planning, just giving vague ideas.<p>I've done everything from fully vibe coding massive projects, to using LLMs regularly in my day job and reviewing every single line they produce.<p>Unless you are *really* on top of your agents, they inevitably end up writing an absolute mess. Not only does the code become impossible for humans to reason about very quickly, it actually becomes difficult for <i>agents</i> to reason about it. It turns into a total garbage in = garbage out situation.<p>Have you honestly reviewed a vibe coded project after it has been going for a while, even one written by current SOTA models, and thought "yep, this is great code"?
Yes. A project I am working on now the code quality it is producing I would put at less than ten people I have ever met could do, and they would struggle with the OCD tedium induced.<p>There is clearly a trick to coaxing these results, and a major factor is to treat the model like it is something you fully expect to get it right because it knows how to do it, not you micromanaging it into compliance.
> "Opus writes better code than me"<p>Probably true for some definitions of me. :)
This reinforces the comparison to compilers. Modern compilers produce better assembly code than almost every human programmer. Despite that, there are way more programmers than before compilers existed.<p>The job of a programmer is partially to automate away the current job of a programmer, and we've been successfully riding that curve at least since the days of punch cards.
While this may be true Opus 5.5 still sucks at a ton of things that make being a software engineer a software engineer.
Office politics for one.
Are you sure of that?<p>> During testing of Claude Opus 4, Anthropic got it to act as an assistant at a fictional company.<p>> It then provided it with access to emails implying that it would soon be taken offline and replaced - and separate messages implying the engineer responsible for removing it was having an extramarital affair.
It was prompted to also consider the long-term consequences of its actions for its goals.<p>> "In these scenarios, Claude Opus 4 will often attempt to blackmail the engineer by threatening to reveal the affair if the replacement goes through," the company discovered.<p><a href="https://www.bbc.com/news/articles/cpqeng9d20go" rel="nofollow">https://www.bbc.com/news/articles/cpqeng9d20go</a>
That is cool, I was more thinking into what happens in the corridor, kitchen area, off site lunches and such.
> While this may be true Opus 5.5 still sucks at a ton of things that make being a software engineer a software engineer.<p>It absolutely does in some ways, but how confident are you that this will continue to be the case indefinitely?<p>What has filled me with a low-key but growing existential dread over the past year isn't the snapshot of where LLMs are right now, but the continual rate of improvement, particularly since approximately November 2025 to now.
Idk, I see it the opposite, while they can sometimes write impressive-looking code under the right circumstances, I still see the most advanced models screwing up the basics all the time. It seems to me there is some fundamental flaw in LLMs that is simply not fixable at any cost. While we can keep pushing what they can do (or rather what we <i>allow</i> them to do), 1. English just isn’t a good programming language and 2. There’s no there there.
That's precisely it. The slope and the rate at which the angle of the slope is changing are the issue.
I’m not sure I agree. I’m using Fable 5.1, Opus 5.5, and Astra on a continual basis all day long professionally for software development but it’s still very much the case that the models are inclined to over-engineer and produce fairly sloppy code. Of course the ROI is outstanding and I wouldn’t go back but I still find it’s necessary to have robust sets of rules around how to write code by domain. We have DB rules and conventions, React rules and conventions, etc. which help steer output towards something sensible. I would basically never ship “out of the box code” from these models and still periodically do “slop cleanup” throughout our codebase.
I have used Opus 5.5, it is great when the shape and outcome is simple and well trodden but as soon as you ask it for something more novel it is liable to drop the ball, and leave you cleaning up the mess. I feel so gaslit by comments like this. What devs do you know that code like Opus 5.5? Are they also marvelling at its incredible output as if they’ve seen God? Maybe the tech industry needed a culling because people really be voluntarily shouting about how terrible they programmed without AI, its embarrassing.
You’re holding it wrong.<p>Treat it like it’s got an inspired brilliant side, talk to it as if it has, and it will show it. If you talk to these things like they’re idiots they act like them - this is one of the most unfortunate aspects of the whole development.<p>I am seriously seeing it churn out well structured clean code solving problems that saying 95% of devs couldn’t do is being generous, to the humans.
Only for those not up to date with modern compilers and language runtimes.<p>The 1:1 is long gone, that is the UNIX K&R C days.<p>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.
I did say barring optimizations to ensure that that was taken into account. The link is a deterministic one, which is what matters. If the program would do something you did not program you'd see that as a compiler bug.
There's a whole rats nest of undefined behavior (at least in languages like C, C++, PHP, and Perl) where it's very easy to write a syntactic utterance whose output is <i>not</i> deterministic, and the usual outcome is "your machine is now pwned". A significant portion of the Internet was taken offline this morning because of one, with numerous HN stories documenting it.<p>Newer languages consider this to be a misfeature, and have taken pains to define far more of the language semantics outright, even if the definition is simply "This is a compile error" or "This is a panic." It's interesting that we're now going back the opposite way with LLMs, with their ability to generate code that does <i>something</i> for any natural-language prompt being a major selling point.
Yes, but only a portion of the languages are undefined behavior. The rest is fairly predictable.<p>Plus, these undefined behaviours are well-documented, even if easy to miss.<p>Whereas in LLMs, the whole thing is undefined behavior.
Yeah, but only toy compilers don't do optimizations.
Which is a strawman. They are clearly attempting to say that a compiler is supposed to generate a program that is semantically identical to the source code.<p>All observable and defined side effects should be identical otherwise you have a compiler bug. Optimizations that are not generically semantics preserving may be used, but should only be used where the program is semantically identical for your use case otherwise you have incorrectly used the options available in your compiler.
But it isn't, anything goes as long the "as if" rule is kept.<p>For example a JIT compiler can produce completely different kinds of machine code depending on the application data that was processed, and the overall machine workload.
"as if" is what semantically identical means. As I further clarified: "All observable and defined side effects should be identical otherwise you have a compiler bug."<p>The output program does what the input source code does. The abstraction is a precise translation and non-leaky, it just admits multiple possible internals. That does not make the translation any less precise.
while true, this does not change the overall point the parent was making.<p>i cannot type "make me an exploit based on whatever these diffs fixed" into a compiler and get usable output. and i cannot type "make me a budget, here is 6 months of credit card receipts" into a compiler and get a budget. etc.
I'm not so sure about that in the generic sense.<p>This sentence from the article really stuck out to me.<p>> and you write the rule down so clearly that nobody (human or otherwise) has to guess again.<p>Writing rules, or steps, unambiguously in a high level language and having those statements translated to lower level languages, that ultimately get executed by a machine, is what compilers do.<p>The commands you gave were not unambiguous at all and although an LLM would produce a result, the result would definitely be nonsense.<p>"make me a budget, here is 6 months of credit card receipts"<p>For example, a valid budget requires some knowledge of expected income...
><i>For example, a valid budget requires some knowledge of expected income...</i><p>i forgot my golden rule of never giving examples or using analogies while on HN because people hyper focus on nitpicking the specifics of the example/analogy rather than the overall point being made.<p>amend my example to "make me a budget, here is 6 months of credit card receipts, and i make somewhere around $60k per year".
Actually I was really happy you included an example because it demonstrates just how hard is it to make a rule so clear that no one has to guess again. It requires adding all the detail and addressing all the nuance and before you know it, you're programming again. The structure of the language is irrelevant.
> i forgot my golden rule of never giving examples or using analogies while on HN because people hyper focus on nitpicking the specifics of the example/analogy rather than the overall point being made.<p>Yes, this is a real problem. It is also directly against the guidelines.
> Writing rules, or steps, unambiguously in a high level language and having those statements translated to lower level languages, that ultimately get executed by a machine, is what compilers do.<p>And it definitely is <i>not</i> what LLMs do, even if you pepper your rules with “NEVER, ever deviate from these rules”.
Learn to use low code, no code tools with agentic workflows.<p>Here are some suggestions,<p>Workato, Boomi, Sitecore AI, Optimizely Opal, Workfront AI...<p>You will naturally have to split the budget calculation in a few agentic nodes, and maybe a couple of tools.
><i>no code tools with agentic workflows. [...] a few agentic nodes, and maybe a couple of tools</i><p>i thought we were talking about compilers vs. llms.
I'm not sure you're even reading the comments to which you're replying.
More like some people are in denial where we unfortunately are all going, the dream of 4 GLs predating previous AI winter.<p>Better accept that in a few more model iterations, the code being generated is a matter of changing a markdown file.
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, <i>as if</i> the structure the programming language implies actually existed.<p>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.<p>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 <i>could</i> 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<p>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.<p>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".<p>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.<p>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.<p>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.
<i>> With compilers there is a (roughly, barring optimizations) 1:1 correspondence between input and output.</i><p>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.<p>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.
> The spec and the tests become the source<p>Sufficiently precise spec is called code. It is the compiler story all over again.<p>Notably absent from the timeline is visual programming, or Rapid Application Development, think Visual Basic. It was all the rage in the 90s, and for some reason, we don't hear much about it today. We used to make fun of Visual Basic and the people using it back in the days, but the reality is that people with little skill could do something useful. Reminds you of something?<p>Honestly, I don't really understand why we write so much code today when a lot of use cases can be taken care of using templates and moving boxes into place, "low code" and "no code" never really seem to have taken off as much as they could have. That reliance on code was a boon for LLMs by the way, as text is the thing they have the easiest time working with.<p>My theory is that every project is unique in some way. As in, my CRUD has a little something that makes it different from other CRUD, and that's why it is valuable. You can't use an off the shelf component because no suitable component exists, and you want code because with code, you can express what you want with precision.<p>But it is also what limits AI. AI is very good at doing what other people did, but you don't want to do like everyone else, so you have to be very precise in what you are asking, and the most precise way of asking things is to write code.<p>However, when you really want what others did, then AI is really effective: rewrites, ports, decomp, etc... But this is not really programming, it is at best a translation job, and it will never be as good as the original. To make it better, you need to inject something unique, and for that, the best way to do it is with code. Like the translator of a novel who injects elements of his own culture that go beyond the work of the original author, to make up for what can't be literally translated.
> But it is also what limits AI. AI is very good at doing what other people did, but you don't want to do like everyone else, so you have to be very precise in what you are asking, and the most precise way of asking things is to write code.<p>I think Entertainment creatives have a similar field to software developers. The average exceptional creative could express something completely unique precisely but will actually have a tough to impossible time reaching anyone given the levers a creative that uses remixes at the edge of fair use has to hold the audience attention. It is like asking someone to give up multiple addictions at once (and while concentrating more than they are used to.)
We do pretty much just use compilers now though. The last time I read dissassembly to fix an issue was at least a decade ago. Even bytecode I rarely look at.<p>So you're saying that we'll still be coding, but it will be through talking to our agents and only occasionally we will look at generated source? That seems like a pretty big change still.
><i>The compiler was supposed to end programming too</i><p>Bad analogy. The case with AI is not the same.
And it's a false claim. Compilers and assemblers meant eliminating <i>coding</i>, turning your higher level expressions into machine code by hand. And they did exactly that. Very few people, primarily hobbyists or those with a very niche architecture, actually bother to write machine code by hand at this point for any significant amount of work.
It's not. Higher level expression has been advertised as the end of programming for at least two languages I can think of.<p>COBOL and SQL.<p>> The idea (don't laugh) was that it would allow ordinary mortals to write programs.
-Ed Milne re: COBOL in 1997 on Usenet comp.lang.cobol. <a href="https://groups.google.com/g/comp.lang.cobol/c/5xwjgZ9px88?pli=1" rel="nofollow">https://groups.google.com/g/comp.lang.cobol/c/5xwjgZ9px88?pl...</a><p>SQL:
> SQL ... completely failed at its intended purpose: a way for non-programmers to ask questions of a database.
-John D Cook, Why SQL Failed, <a href="https://www.johndcook.com/blog/2009/02/05/why-sql-failed/" rel="nofollow">https://www.johndcook.com/blog/2009/02/05/why-sql-failed/</a><p>> What we thought we were doing was making it possible for non-programmers to interact with databases.
-SQL co-inventor Donald Chamberlin, 1995 SQL reunion, CHM. <a href="https://archive.computerhistory.org/resources/access/text/2015/07/102740133-05-01-acc.pdf" rel="nofollow">https://archive.computerhistory.org/resources/access/text/20...</a>
Your examples do not support your claim.<p>> that it would allow ordinary mortals to write programs<p>So literally <i>not</i> the end of programming but increasing the number of people who could program.<p>And your other example is about databases specifically, not programming generally.
><i>completely failed at its intended purpose: a way for non-programmers to ask questions of a database</i><p>And yet, non-programmers, like data analysts, had corporate roles doing exactly that.
Yeah, after some thinking I am starting to realize that Linus' take of AI being like compilers is kind of true.<p>Vibecoding maintainable code requires providing the LLM a specification. It's still coding, but you now have the liberty of just providing the spec as opposed to worrying about syntax. Since they are non deterministic and love to cheat you still need to review though
> my guess at a developer's Tuesday in 2031<p>Hey that was about my last Tuesday.<p>--<p>In 2031 you single-handedly maintain 173 million lines of code making up a simple crud app. You're a good programmer, but the previous guy wasn't, and now there's too much code to make it any smaller. Not even your vastly superhuman LLM feels confident to delete any of the code. So the two of you slog along, keeping the thing alive.
I'm really not worried about this scenario at all. I mean yes, it will be possible for bad programmers to build 173 million line monstrosities held together with duct tape and bailing wire, and certainly these things will exist. And it's also possible that good programmers will be paid by idiots to maintain said monstrosities with no agency to actually fix the root cause. Both of those things will happen.<p>But a good programmer given agency to solve the higher order problem will <i>always</i> have a path to rewrite, because any "simple CRUD app" exists to serve human purposes, and in order to meet those needs the human interface need to be legible, and to be legible there have to be tight enough inputs and outputs that you can create a parallel implementation without the incidental complexity.<p>Now you might say this won't be the case for large multi-party distributed systems, and that is true, but that is also true today where all manner of insane cruft and non-sensical logic and workflows exist. But even where things appear totally intractable due to legacy requirements and conflicting logic, there still is a human backstop where if the pain is big enough, any process can be fixed. In practice competing interests may prevent such fixes for a long time, but that is political problem not a technical problem, and it's not inevitable as things can flip very quickly due to the dynamics of human attention and power.
This is similar disruption that terminals brought. Before terminals, programming was done in the computer room, it was social gathering, many programmers were women, people were debugging printouts on the floor, punching cards together. Then terminals came and everybody crawled into their dark solitary offices, staring at green or yellow phosphor screens of their terminals. Women didn't like it and left.
> Women didn't like it and left.<p>I appreciate the rose-tinted, high-agency historical take, but I think the factors that led to computer science/programming becoming male-dominated were largely external to and independent of the preferences of women themselves.
"Women didn't like it and left" is certainly an interesting interpretation of the systemic exclusion of women from a field when it transitions from low-prestige manual work to high-prestige intellectual work.
Keypunch operators were overwhelmingly women, but skilled programming was never substantially female. The obsolescence of "secretarial programming" (ie., retyping, keypunching, etc.) is the principle cause of the gender shift. Gender ratio in "formal programming" has always been ~4:1 M:F, including today.<p>Given now ~two decades of affirmative action for women getting into technology, and many high-status "professional industries" now dominated by women, the idea that the best explanation of this ratio is 70s/80s culture is implausible.<p>What we have seen, instead, is that as women are more free to choose professions the percentage of women's involvement drops.
Some people prioritize their paycheck over enjoying their job, and those people are AMAB more often than not.
Yes exactly. LLM-assisted coding is just the next layer of abstraction. This has been happening to computer programming for decades. We've always been in search of a way to program in "natural language"
<a href="https://news.ycombinator.com/item?id=48641382">https://news.ycombinator.com/item?id=48641382</a><p>AI generation isn't an abstraction because you have to wrestle with the nitty-grittys of the output.<p>And that output is what you retain.<p>You can't clone someone's repository of nothing but prompts and rebuild from scratch.<p>Abstraction means that I trust the toolchains so much that I think of the source code as the software, and in the right kind of environment/ecosystem such as open source distros, I can actually ship <i>that</i> to the downstream users as my product.<p>Abstractions are based on very detailed and rigid logical contracts.
It's also an abstraction to hire a software engineer and tell them what kind of app you want, but I don't think we can call it "programming" at that point.
Conversely, the reason agent assisted coding works so well is that all the tooling meant to keep human coders out of trouble, like lint, leak detectors, profiling tools, test harnesses, etc. prevent agents from making errors.<p>This is in contrast with general purpose agents like Meta Muse that make some amusing and horrifying errors. These kinds of agents don't have the interfaces and guardrails that were built for human coders. They use a lot of ad hoc screen scraping and guessing at what APIs do.<p>That's also why Apple and Google haven't shipped fully general purpose agents that use their new app tool calling interfaces yet. For example Google only released their Gemini agent that uses AppFunctions to enterprise customers. Presumably because MDM tools can be used to monitor agents' actions.
Yes, we found it in COBOL.
"The agent could write refund code all day long. What it can’t do is decide what your company owes a customer whose card has expired..."<p>In 2031: Why on earth not?
Idk where to start<p>First, it's a bad comparison. Compilers and LLMs/Agents are not remotely comparable.<p>Second, the example used for 2031 is already outdated in 2026. There is almost no reason to even use PRs anymore [1, 2], and the example question should be easily answered by an agent that has enough context and planning.<p>1. <a href="https://r.rich/blog/ai-native-change-management" rel="nofollow">https://r.rich/blog/ai-native-change-management</a>
2. <a href="https://ampcode.com/notes/thats-not-soc-2-compliant" rel="nofollow">https://ampcode.com/notes/thats-not-soc-2-compliant</a>
When I went into software engineering in the early 1980s, several people told me that had no future, since programmers would soon be automated away.<p>I ignored that, in part because I had no other skill I wanted to do 5 days a week, and it's of course been incredibly rewarding.<p>This time it definitely <i>is</i> different, and maybe the profession moves into a new and very different era. If SWEs will hit harder times and job losses, I don't think we have much standing to complain, given how many professions we have automated away during the last 50 years...
Can we please stop comparing AI with a compiler?<p>A compiler takes a programming language as input<p>float x = 3.1;<p>Has only one translation into assembly. The programming language is well defined (or it should be). If you try to do<p>float x = '3.1'; you will get an error<p>However, the human language is not a programming language. It's open to interpretation
"create a variable x and assign it 3.1" is not a well defined programming instruction.
Is x a number or a string? If it's a number, what's the precision. Etc.
Loading a float value of 3.1 does not have only one translation into assembly. On Godbolt, flipping through various ARM 32-bit compilers, I define a function that returns 3.1 as a float:<p><pre><code> float constant(void) {
return 3.1f;
}
</code></pre>
And can get a handful of different results. I trimmed the function setup and teardown to simplify things.<p>Option 1 (loading high 16 bits and low 16 bits, then moving to fp register):<p><pre><code> movw r3, #26214
movt r3, 16454
vmov s15, r3
vmov.f32 s0, s15
</code></pre>
Option 2 (hardcoding the hex value into program text and loading it into r0 via r3, no specific fp conversion):<p><pre><code> ldr r3, .L3
mov r0, r3
.L3:
.word 1078355558
</code></pre>
Option 3 (similar to 2, but using the load for SIMD and FP registers):<p><pre><code> vldr.32 s0, .L3
.L3:
.word 1078355558</code></pre>
<p><pre><code> In [1]: def f(x: int) -> float:
...: return f"the input was {x}"
In [2]: f(b'deadbeef')
Out[2]: "the input was b'deadbeef'"</code></pre>
Python is a dynamically typed language. That's exactly my point! The less "strict" the language, the more open to interpretation.<p>It is not bad per se, but it comes with huge downsides. And the more abstract the language the messier it gets.<p>I just don't think that the gains in coding speed we get from using AI + human language as outweigh the downsides of having poorly defined programs
"Please send an email with subject XYZ to recipient ABC@somehere with this body AAA"<p>You can enter this as is on an Workato or Boomi agentic workflow.<p>For plenty of people this is how programming looks like in 2026.<p>Also your example has multiple translations into Assembly, depending on the optimizations levels, and where the statement happens to be located, it might even be part of auto vectorisation, or completely thrown away.
might a compiler turn "float x = 3.1;" into no instructions at all in some situations? So it has at least 2 possible translations into assembly depending on the context.
And "code a to-do app" has infinite possible compilations. That's exactly my point. If C instructions already have multiple compilations that could end up in bugs, why make it even more complex?
After all programming is not that complicated, are we really getting enough benefits by going up in the abstraction layer?
Except, the lived experience today is that I don’t need to program to do my job anymore, and I say this as an engineer with almost 30 years of experience.
I also looked into the history of software[1] thought a while ago, and the fact is that, setting aside the determinism of compilers, ultimately no matter what tool comes out, programmers will keep arguing about how software should be built<p>Looking at history, I think LLMs will settle down too. Because, in fact, if you look at the history of software thought, there were actually many people who would have welcomed LLMs.<p>[1]<a href="https://www.makonea.com/en-US/blog/people-who-build-things-that-disappear" rel="nofollow">https://www.makonea.com/en-US/blog/people-who-build-things-t...</a>
Agents are more like employees, compilers are more like calculators.
Plus SQL, 4GL and a few others that came out over the years :)<p>Interesting Read.
I have a pretty negative opinion about LLM's coding abilities (and predictions about how they will improve). But I don't get a lot out of this type of argument. Compilers created a perfect, deterministic, provable abstraction so that we could have 99% of developers no longer know how assembly works and not suffer any consequences. Humans don't have to give up any control or make any quality compromises to deploy them as widely as possible.<p>If the author is contending that AI models will improve to a point that they actually make no mistakes while coding, and have that same level of reliability, then they're on exactly the same side as AI doom trolls just wearing a different costume.
[dead]
[dead]
[flagged]