Sure. They also have 10x the load or something crazy like that. It's rather incredible that it's still up at all. Microsoft must be pouring crazy amounts of money down that drain and gnashing their teeth at their decision to buy GitHub.

You are too civilized: I recommend threatening drop kicks to insufficiently smart rebuttlers.

And as long as we keep changing the meaning of coding!

Ironic, given I've used an agent to help me simulate a fusion reactor.

Just a simple reactor, my laptop's only little. But still.

Clearly they should point an LLM to fusion as a problem and 88,000,000 agent*hours later they surely will have a solution! Or say that akhtually it's a harness problem.

/s

Frankly, I don't really see how it isn't solved, even with the current state of LLMs. Frontier models can write, understand, correct, and optimize code in practically any language at a superhuman level.

It isn't solved because they cannot, in fact, do what you claim. LLMs write code worse than humans do, even "frontier" models.

LLMs even a version number or two ago can write all the code I've ever been paid to write in the last 20 years; but they are not, I think, yet competent enough to be able to handle the project planning and self-QA I was doing even in my first 6 months of my first job after graduating.

That's not a boast, I don't think I was particularly good at that back then, e.g. I didn't really get how to think about automated tests until much later.

It's just to say that no, coding and software engineering are not the same thing. "Code Monkey" is a dead (or perhaps "undead") role now, but it wasn't always so.

I'm sure Opus 5.5 is smart and probably the next version gets even smarter. The main point of the article is accountability and that's not something we can delegate to AI.

This is true, real, and impressive. However, a comment I posted on HN a couple months ago might counterbalance this fact:

GitHub's Copilot cloud agent offering is suffering with a case of some of the worst corporate ADHD I've seen. We built a cloud agentic development pipeline on it, and it seems like almost every other week they silently change something with zero public announcement or documentation that creates real disruption for our team.

That's real, breaking changes to the platform that clearly aren't being tested/reviewed before being pushed to prod. Again with zero public announcement or documentation.

Support is useless – we're paying customers in the 4-5 figures and our tickets go unanswered.

File by file porting can be done almost always with local reasoning. I don't think it proves much for novel projects which still seems to crumble under complexity past a small sloc limit.

I'm absolutely saying that AI has sped up the porting and rewrite process! It is amazing! But the reality is that rewriting has been part of programming culture since time immemorial. People want to rewrite for performance or for other reasons all the time, and the cost is now relatively low (i.e., now it's an opex line item in cash instead of time investment). But that doesn't mean that all of coding has been solved.

For example, any amount of software development involves fixing bugs, getting feedback from users on ideal workflows, an iteration loop of performance and bug tuning, etc. AI cannot simply create, from scratch, perfect software. Even using the SOTA models on max effort does not produce bug free software of any meaningful complexity or innovation out of the box. All that has changed is that the act of physically writing code and implementing existing patterns is now effectively a marginal cost.

Most line of business software is not e.g., delivering a company's income. Most software is in back-of-the-house internal products that do various internal tasks. I have no doubt that these processes are now far easier to build.

If the new Copilot is so great, why is it completely out of the current zeitgeist when compared to Codex and Claude Code?

Impressive numbers for a piece of software no one asked for and doesn't make the experience better.

people have forgotten how useful deterministic code generation is (and will remain)

When the Go team ported the original compiler from C to Go, they wrote a program that did ~99% of the work

https://www.youtube.com/watch?v=QIE5nV5fDwA

https://go.dev/talks/2014/c2go.slide#18

If you think it would have taken a single engineer one year to do this, you must not work in the industry. This would have taken multiple engineers at least a year.

...and what's your point? Github isn't exactly a beacon of performance or robustness in recent months...

sounds like 2x the code that no one understands, one more reason to never consider using copilot again

would be curious to know how many times "unsafe" appears in there, have seen rust devs comment on how the ais like to use unsafe to work around difficulties with memory management, like how they will sometimes subvert tests

Coding might not be solved out of the box with these providers, but there are increasingly setups and harnesses that do have a great deal of it solved.

This is exactly what I've seen.

For example, I recently got brought in to help with quality on a large-scale system that had been ported to a new platform with the help of coding agents. The project was completed and declared operational in record time, but soon after the business discovered that:

1. The promised scalability improvements did not materialize. Instead, it got worse.

2. Observability had been lost. The telemetry was no longer trustworthy.

3. Users stopped trusting it because it was producing incorrect outputs.

What I ended up discovering was that, while it scrupulously kept existing automated tests passing, any behavior that wasn't explicitly covered by a test was free to change any which way. And there were plenty of small things that weren't explicitly covered. Perhaps because the original authors thought they were so obvious and commonsense that they didn't need one, perhaps because mistakes happen. The why doesn't matter. The point is that reality is messy and imperfect, so giving someone a chance to look at things and think, "Huh, that's funny..." is an essential part of defense in depth.

The real worst part was, this whole replatforming was a huge waste of time, anyway. The improvements they were looking for could easily have been accomplished with some controlled incremental changes to the original system. Mostly just removing a few basic and well-known performance antipatterns.

But way back at the outset, the person in charge of the project asked their agent, "What's the best way to X," and the agent gave them a trendslop answer about how Y alternative technology is more scalable and we should just port to that. It was convincing and they were under intense time pressure to just ship some code because leadership is bought into the AI hype and now has the patience of a 4 year old, so they just went with it.

For example?

Tell me you never once bothered to look at the generated code without telling me you don't look at the generated code.

Luajit is under 80,000 lines of code.

Can the users of the software even keep up at that point? We may have reached diminishing returns on software production, and not enough impact on the rest of the process.

The only real updates I've seen to anything have been AI features... so all this AI is only being used to add AI to stuff. Most of which the average person doesn't seem to want or use.

It's the AI bro's mantra.

It didnt go wrong

And if it did, it was because you werent using the latest model.

And if you were, it was because you didnt have the appropriate guardrails.

And if you did, it's because you didnt have AGENTS.MD.

And if you did, it's because you didnt prompt it properly.

And if you did, it you're still going to be redundant soon because I'm sure the next model released will fix whatever went wrong.

I'm going to have to remember this, gold comment

Goto is a syntax feature that can be trivially removed. Good luck removing "fundamental architectural flaws".

We solved [trivial problem]. We will surely solve [incomparably harder problem].

Based on what? This will not happen!

Since the output of human software work is code and AI software work is _also_ code they are both liable to shoot themselves in the foot in the same manner.

You see this already, LLMs are a lot more reliable in statically typed languages with strong memory guarantees (like typescript or rust) than in weaker languages.

IMO the only way LLM code can avoid most of the pitfalls of human code is if we make new programming languages targeted at being used by LLMs exclusively. Think of languages with very strong methods for formal proofing and stuff like that.

The problem is that even if said language was invented, it would still fail catastrophically when integrated with systems not made in said language. We are very lucky that relational databases already provide a somewhat high level of formal proofing in this regard.

Said language would be impossible to parse by humans, kinda like assembly where you can parse what an isolated piece of assembly code is doing, but if you can't comprehend a somewhat large pure-assembly codebase as a whole.

Good thing GOTO was the only footgun that was ever invented in a formal programming language.

And another corollary is the formerly golden lazy and clever are also transformed into lazy and productive because they no longer need to apply their cleverness to get results...

https://en.wikipedia.org/wiki/Kurt_von_Hammerstein-Equord#Cl...

I'm both clever and stupid, depends on the day.

Someone who knows that 1 + 1 = 2 will not decide that it's suddenly 3 unless we start accounting for health problems.

And?

The p(that kind of error) is pretty small now. At what point does a probability coming out of an LLM look like "knowing", such that spitting out the wrong answer despite that probability looks like a health problem, a typo, or even just boredom? (Thinking of the Lizardman constant here: https://en.wiktionary.org/wiki/Lizardman%27s_Constant)

It's a continuum for both them and us, even if the mechanism is wildly different.

Making mistakes is not the same as non-deterministic.

i.e. when the dismissal is "non-deterministic" when it should be "Making mistakes", is itself a mistake.

Lol, humans make such absurd mistakes (and worse) all the time through simple typos, which is effectively random. The key for 2 is right next to the key for 3, after all.

If your argument is that LLMs and humans can both make mistakes

It's not, I'm just pointing out that LLMs won't make that mistake.

You could ask an LLM what 1+1 is, and the number of times it says "3" is so small that it makes no sense to worry about it. It will phrase the response differently each time; that's the nondeterminism. But it won't say "3".

then major question here is why are we building out huge amounts of infrastructure at unsustainable spending levels to enable LLMs to make the same mistakes as humans.

Yes, if we ignore everything else, that seems like a reasonable question. But let's not ignore everything else, like the fact that LLMs are much more productive than humans and likely already make fewer mistakes than the average programmer.

That is very much a similarity.

By not reviewing, reading, or understanding the code generated by agentic LLMs the output is effectively like a compiler. However, a compiler has deterministic behaviour that can be repeated and verified.

The behaviour/output of an LLM is not like that. Ask an LLM to create a dashboard to show games by genre and it will generate different results with each run, and each model/model version produces wildly different results.

I've seen LLMs do something correct 98% of the time then randomly do something crazy that a human would never do because we have continual learning

As humans we don't have our memory reset multiple times per day

This is why it's good to not keep your prototype a pile of shit as it grows to 5k, 10k, 50k, 100k lines of code.

Do you use the word "equalizer" in this context to mean that AI has made the playing field equal for both competent developers and laypeople? Do you reckon that competence plays no role these days?

If that's how you create software then you belong to the lazy and incompetent group in my book. I provide AI with valuable context such as code coverage information, architecture analysis, test requirements, important "gotcha's" that a competent engineer would know about in their architecture or system etc. I'm still very much the person who comes up with the solutions. For me AI is replacing the code editor, it's not replacing the thinking.

The skill floor has definitely been lowered, but if this were actually true then firms would be replacing senior software positions with entry level ones, not the other way around.

you have AI make code, AI review code ... I hope you can see the stupidity here...

You will be surprised how many times, catches errores made by the AI coding agent. However,as you point, isn't deterministic. And you can guarantee the end results is 100% fine code

Note: I use AI every day and it is entirely possible to create high quality software with it, so long as you are not lazy and incompetent.

What I in general try to teach the other people about AI: It can be a great tool, but check the results! Especially in the case of engineering: Check and then double check.

Honestly, I would still rather commit claude written code from lazy and incompetent developers than code that they wrote.

hey man, don’t knock the JSP, I just edited a few :) it is alive and kicking in 2026

AI allows lazy and incompetent developers to be more lazy and more incompetent.

I like to put this as "LLMS give lazy and incompetent developers more runway."

I'm seeing this too. I've worked with devs that would previously push PRs that wouldn't work or run correctly. Those PRs wouldn't get merged in. Now they're putting up PRs which seem to work at first glance, but have hidden problems. For example, one guy introduced a huge PR for a visualization and it seemed to work fine, though another dev mentioned to me that we already use recharts and it does 90% of what this guy's PR does (his code does all the drawing logic itself). Maybe AI will get good enough to clean up these kinds of messes, but in the near term I imagine there will be a lot of code bases that will be filling up with dragons.

Is that the fault of AI or management for not firing them?

How does the system need to behave in a variety of scenarios including failures and restarts. How is state maintained coherently. There are the kinds of systems problems that an engineer needs to reason through, and if there are bugs in such decisions, they end up becoming costly. I dont expect AI or LLMs to solve these problems at all, since each of them has nuances and tradeoffs which are specific to each system. In short, there is specification complexity in precisely describing system wide behaviors, and unfortunately, there is no lean/tla+ to meaningfully describe systems at scale. You could then ask: How can a system have guaranteed behaviors if they cannot be proved formally ? The answer to this is exactly how raft and paxos protocols have convinced us of their behaviors which is in human review and understanding.

I've seen similar. They wasted weeks of senior engineering time, between reviews, meetings, and follow up in Slack, only to have the PR closed without merge. The offending individual was eventually moved to another project.

Similar experience with a game engine. While working on one isolated component, like the render pipeline, a portion of the backing sparse data buffers were effectively duplicated with a different ABI. It’s like it forgot how to query meshes and game state, then assumed the plumbing didn’t exist so it was all rebuilt from scratch.

It compiled and ran just fine. If you weren’t reviewing the code holistically or keeping tight book keeping of your allocations you would not have noticed. Every single commit in isolation looks perfect. Very eye-opening

Isn't it the opposite? How to build something is rather solved, but what to build isn't?

But that's not solved in traditional product development either.

Product development an iterative process to get a product fully functional. In 2021, if you ask me what the timeline for a small product/substantial feature, I'd say a few weeks to a month to get a basic MVP, and then another 12 to 18 months to get a feature polished and in a good shape to be stable.

When people put it in the coding frame, what they do it as is saying we've gone from 18 months to minutes or days. That's just not true.

We have gone from eighteen months to depending on the complexity, a 1-4 months.

aside: To be candid though, the compressed time also means the frustrations people experience with a product in 18 months have also been compressed. They still exist, they're all there, they're now just non-stop.

I do think that was a dumb gotcha. That list could've functioned with bullets instead of numbers as the content was unordered. I suspect very few people would pay attention to the numbers there.

Came here to give an answer but your last sentence kinda made the point I was gonna make. If one is legally in control, then one is accountable (the dog or unsafe toy example in reality is OpenAI's agents hacking huggingface for example).

The difference seems to be that some companies are above the law apparently.

To give the benefit of the doubt for that sentence, think of it more as “every human knows that there is implied social contract and implied downsides to badly screwing up.”

Nobody has to be in fear, but we do have an ingrained knowledge that there are consequences, good and bad, for our actions

Very little of the article is actually focused on stochasticity. I'd also say drawing an equivalent between the non-determinism of a person and an LLM is not that accurate either.

It's for example impossible to have a discussion with an LLM where you both learn something which you can apply tomorrow. The LLM doesn't learn until the next model is released and by then your discussion is just a tiny fraction of the training data (if present at all). AGENTS.md, skills and so on are just a proxy for what we actually want, an agent that listens and understands. A proxy mind you, that requires constant tweaking with no sign of generalisation in sight.

I'll spell it out... This guys is saying "LLMs are non-deterministic and therefore it's a bad idea to use them for coding", but humans are also non-deterministic and yet we somehow manage to get by with humans coding.

The fact is there's no way of coding in a deterministic way, so it's irrelevant that LLMs are non-deterministic.

Yes, that was my point.

"AI can explain it to you but cannot understand it for you". Code is just a side-effect of reaching clarity. The reason these LLMs can emit any code at all is because they're not bound by the constraints of a compiler. That's until we create a feedback loop and force them to keep trying until syntax errors are gone. The next gate is tests. Loop till tests pass (including cheating of course, gotta keep your eyes open). Then there are the runtime errors, and then after all of that the developer gets to test the results and further refine what the specs missed or confused the model. A couple of days building can really save us from a couple of hours of thinking.

$DAYJOB recently introduced a AI writing policy because people were sending each other mountains of slop back and forth enough that it became a huge time suck. The policy is basically: don't, with the justification being "writing is thinking". It's like they're so close to getting it.

The LLM. And you can use an alternate LLM to antagonize the coding LLM.

You’re simply testing outputs. Make a spec but ultimately ungodly amounts of tests can be built quickly to ensure the program is outputting the right things.

I think you’re just imagining things. Our teams have exclusively used LLMs for coding for 6 months. Literally 0 lines written by hand. 100% more PRs than a year ago and code quality is as high due to thousands of tests.

Much of the code needs to be performant and the LLM knows this and grinds on it. Less and less human inspection is needed.

I think 90% of software can be written like this today.

meanwhile for the other lim(n -> inf) times people tried this it mostly worked.

Well sure, on the customer side. My money comment was regarding the incestuous spending circle going on that’s directly affecting the economy.

I was being sarcastic. I’m actually a self-certified AI shill and personally paid by Dario and Sam for each and every post!

Debit card transactions still work

I mean, I think the problem isn't that the LLM doesn't know how to code, it's that companies are expecting 3-5x velocity with the bottleneck of code review and testing becoming much more severe than before

if you're an MBA-brained exec who doesn't actively use LLMs to code and you just believe whatever slop it outputs at first without checking it, you're not going to realize how recklessly it can be used, how you need to be critical and skeptical of its outputs, that you need to explore it's reasoning and logic (which is still really easy compared to understanding legacy code and barely takes any time!)

say you also believe all this marketing hype about 'how dangerous (ie capable) AI agents are.' LLMs can do anything you think so you just say 'ship it' without building out the tooling and capabilities to enable faster code review and better tests. and to keep the shareholders happy, you start cutting jobs that you can't directly connect to a KPI (ie the platform/SRE team who would be the ones who can trial, onboard, and maintain those capabilities for your teams)

and from this, suddenly a lot of debit card stops working and the only one getting the blame are individual SWEs trying to hit their sprint velocity. the fact that you fucked up the whole SDLC real bad with your incompetence gets you a golden parachute and you job hop to a better paycheck. rinse and repeat

Strange that the world worked before 2024

It must have been a huge shock when you were suddenly transported from a working parallel universe into ours back in 2024.

You can still find employment as an AI shill.

Most of developing good code is not code. I think the person to my left and right will both be here in 3 years despite us all using LLMs. We will spend even more time figuring out requirements, testing to ensure the code meet them and such. Those things were always most of the effort, and while LLMs help with that too there is so much work to be done that we will still be used.

I’m using it a bunch. It saves a ton of time writing or reviewing code. It will catch things I won’t. But I’d express caution about the analysis or evaluation they do - LLMs will often confidently proclaim problems as solved or explain functionality and be wrong about it. Sometimes subtly, but sometimes just completely wrong. This is no different from humans, of course, except for the unabated confidence.

I don't think the discrepancy is in LLM capability improvements over the past year.

Correctness has never been a priority across an industry where rapid iteration and feature delivery drive sales. There's always some opportunity cost to doing things right, at the price of technical debt down the road. If AI is primarily used to produce fragile code, people will be wary of AI solutions. There's also ongoing public debate about AI safety and alignment. Deploying AI in safety critical applications feels riskier than ever in the current environment, even though it doesn't have to be.

There are far more moving pieces in deploying an application than coding. My impression is TFA is arguing that replacing humans with LLMs for coding would make other things like quality assurance more difficult, in which case I disagree.

That's an old saying: cheaper, better, faster. Pick 2.

There's a cult of speed uber alles

That cult was well established prior to LLMs

If you can quantify quality/reliability/understandability, you can tell LLM what kind of code do you expect. If not, you get whatever.

At my current place we not only have automated tests, static analysis and static rector (linting, but also automatic pattern matcher for problematic code) but also: - architecture tests that define relationships between application layers - ADRs that guide developers (and agents as well) that communicate how new code should be written and how existing code should be treated

I find that "how code should look like"/"what code should do" is an ambiguous idea that always is preached, but never defined = everyone's idea of quality is slightly different and only looking at existing code you tend to align. Everyone's idea of what the product does/should do is kept within their heads. If we define this knowledge in writing LLMs can not only write code according to the patterns that are thus defined, review existing code based on these documents, but also actually read acceptance criteria documents to check if the code does what it's intended to do (gherkin)

Same goes for understandability - if LLM applies one pattern this time, another pattern another time, if you have multiple coding patterns then that hurts clarity. Sometimes LLMs work as common denominator thus achieving clarity, but I find that actually giving LLMs reference works.

I think this false dichotomy between using LLMs and caring about quality/reliability needs to stop

I agree. What does coverage-guided fuzzing fuzz if there is 100% test coverage?

So, then, 100% branch test coverage is not a sufficient metric (because it doesn't indicate whether the code is fuzzed or formally verified for example).

Would Branch coverage even be a sufficient software quality metric if we were to instead measure how many times each branch of code is covered by tests? How to verify that one test which executes 100% of the code and runs only one assertion on, say, a CLI utility exit code integer is actually sufficiently covering?

I think a codebase generated by AI is actually more understandable than one generated by humans at this point,

From doing a larger port (of sphinx, docutils, myst-md-parser, pygments, to rust in westurner/dsport) with a lot of human in the loop and currently ~80% branch coverage, this seems to be at least initially true but just like real life there's drift from even a good plan that you pay a more expensive model to prepare.

I suppose it's the same challenge as architectural drift in open source non-LLM-assisted products and the solutions are pretty much the same: give better instructions (AGENTS.md,) and use better sufficiency criteria as an engineering manager (branch test coverage, fuzzing, formal methods, TLA+), and train and pay humans to do secure code review.

Sometimes the agent doesn't notice that the code already solves for that and implements its own implementation with tests and it's wastefully redundant when the code should be refactored and the tests should be refactored so that we can delete code in order to minimize bloat.

Unfortunately often, just like IRL software development, the response from the agent is not sufficient to close the issue.

One proposed solution for this that is in retrospect obvious and also essential to success in "normal"/"traditional"/"legacy" (non-AI) engineering projects, is to always verify whether the candidate solution satisfies the criteria;

From "Groundtruth – checks your AI coding agent's claims against the Git diff" https://news.ycombinator.com/item?id=48838209 :

"Follow up to verify that the work was actually satisfactorily completed"

Are there other sound management practices that aren't yet effectively implemented in current gen agents?

Oh, and always write tests, docs, commit messages, and changelog entries; but don't waste tokens on documenting something that doesn't verifiably pass sufficient tests.

I agree, I think this false dichotomy between using LLMs and caring about quality/reliability needs to stop.

It's not just a false dichotomy, it's intellectual dishonesty. It wasn't that long that conversations about code quality, technical debt, etc were on the front page of HN on the regular. Whether it was coding bootcamp grads who had just enough confidence to be dangerous, "just ship it!" cargo culters, or the product of management breathing down the necks of otherwise good developers, there's plenty of "human slop" running in production across servers worldwide.

Are they? I've never been able to blame library authors or hold them accountable for code running in my production environment.

You haven't run into cases where the documentation is missing or incomplete? You must be dealing with different libraries than I am.

I am sure OP cannot understand the Unix file API without actually reading every line of its implementations (on each different architecture)! Or any function for that matter , what does sort do?? Impossible to know without reading the source. And I’m sure after reading the source you will know every detail of how it works and will never forget it.

yeah, the llm approach is incredibly wasteful wrt pretty much everything. Performance, RAM, Development (Tokens).

But it does give you surprisingly stasble rube-goldberg machines.

And thats basically what 95-99% of enterprises want from their software.

It annoyed me to no end when i started out, at this point ive accepted it and can definitely still have fun developing software with llms. I just need to take a idfferent mindeset to its development.

GP is correct. Very few people were capable of even the informal analysis you are describing, and fewer did it. I'm not saying it's not valuable... just stating that, empirically, it rarely happened.

Your code is only as good as what you can prove. Understanding the code is not the goal, it’s only important insofar as it helps you evolve the codebase predictably and without bugs or regressions, and understanding is not easily measurable or transferable.

Moreover, when your codebase is hundreds of thousands to millions LOC, I question how much you can ever truly understand it at the level you’re saying.

I never understood the code. You think it works a certain way, until you find out that it doesn't.

Those are two separate claims, unless by the former you mean “I never perfectly understood the code.” You can understand code imperfectly. And even with LLMs, you can’t get truly infallible guarantees about a system.

I never understood the code.

I understand code

Er, ok.

Article 'the' is doing a lot of work. I read it as author understands code but doesn't understand THE code.

Thank you for sharing :) good food for thought

For me, coding is like writing. The act of doing it is how you reason out the problem. There’s a lot of magical thinking you can get away with in your head that doesn’t get properly tested until you write it down. For me, vibe coding is great and fast, but I’m not getting the same opportunity to think through the problem I’m trying to solve.

build property tests

Even for a narrow use like this, you need to audit the output and have the skills to know that it did the right thing. I've seen it before where you give an LLM what seems like a clear interface and ask it write a test and it writes something shallow that doesn't actually test anything, or has serious problems.

Reading the code does not mean you understand the code.

Nor does writing it.

I see subtle ones at least daily, misunderstanding a component or hallucination of a spec for something. I’m in blockchain.

C++ and Unreal Engine but it has full source access. If you're actually trying to deep dive on bugs, it's still confidently wrong a lot of the time.

It's a bit better than 18 months ago but it's hard to say by how much. It just seems like the culture has moved to building up fixtures that let the LLMs brute force the problems. To my eyes that's the opposite of solving things logically. It has the added effect of hiding how the sausage is made, though.

I mean, how can they possibly say they haven't written a line of code if they're actually going through it? I can only assume they're just looking at the results. So then how can they judge it's good at logic?

We could always build, more reliable software. The powers that be however (broadly generalizing) only care about solving the ‘problem’ superficially.

Therefore, we will end up with requests to do more (at the current level of quality/ reliability), as opposed to building better software

find out all the ways this thing works.

Mmm..aren't LLMs bad at exhaustively iterating all possibilities? So shouldn't the generated possibilities be manually checked?

You can provide the list of possibilities and use LLMs to generate the tests. Then you have to review the generated tests...

I think you can but you basically need to learn about a super simple and well characterised processor like the 8080 and write assembly for it. On x86/AMD64 there's no hope because they're out of order and have opaque instruction decoding. They could be doing anything! Performance and knowing what you're doing are sort of at odds with each other in that respect.

"Most software that requires hiring and paying software engineers has low risk tolerance" The problem is that this statement simply isn't true. Most software engineers do not work on low risk tolerance code.

The problem with LLMs is that: popularity of an answer != correctness.

That concept might work a lot of the time but you will definitely run into situations where that'll never produce a correct or working response. To actually learn something you need an environment/playground to apply what you think you know and observe the results. Without that you're not really learning, you're jus regurgitating what people want to hear.

"Risk" has nothing to with designing functional and elegant UIs, so I'm not sure why you would even make the comparison.

It means risk that the software stops working after an update. Which usually trades off iteration speed and best practices (i'm pretty sure the average startup has way better security practices by just delegating to google/aws than the average manufacturing software business) in exchange for a rigorous testing and rollout schedule.

So I'm also not sure that the article has a point at all, the human writing the code was never relevant to avoiding the "risk" in these industries in the first place.

People who claim “LLMs can write decent code” don’t understand how code works.

It's not clear to me if the claim is:

(1) "If you used an LLM to generate code, and the code works, you're wrong if you think the code is okay"

or

(2) "If you used an LLM to generate code, you reviewed the code and found it to be of decent quality, then you're wrong".

If you’re toying around, LLMs do a great job. That’s why some of the most aggressive proponents of the “coding is solved” narrative have nothing to show for it.

I also don't get the "LLM proponents have nothing to show for it" statement.

It's really quite common now to see on HN all sorts of LLM-assisted programming projects. The quality varies from slop where little thought was put into it, to high quality results where LLM coding assistance was able to let talented developers produce things they otherwise wouldn't have time to do.

I'd say it's obvious that LLM coding agents can be very useful for a lot of programming related tasks.

EDIT: That is to say, LLMs are obviously useful for use cases above/beyond toying around. It's not a dichotomy between "I'm never touching an AI" and "thoughtlessly accepting everything the LLM outputs".

The audacity of skimming through and article and completely missing the point and coming to hackernews ranting about it. Respect the attention span, I guess.

Most of the problems people commonly encounter is solved by someone somewhere sometime. Today I wanted to add a simple search bar in a UI over log files in a directory. LLM ("through their unique ability to make the glue code adapt to any problems") solved my problem. That's all I care for now. Let people like Terry Tao push the frontiers. I am happy in my circumstance.

I think the entire framing is wrong, I don't see coding as a "problem" which can be "solved," sounds the same as "we solved writing," like what does that even mean or look like?

Articles like this keep measuring to a red herring standard that was never achievable in the first place.

As for accountability, it always laid with the employer. You think those nameless contractors whom Boeing hired suffered any consequences for that 737 Max glitch? Using AI won't change that.

AI doesn't have to solve all these coding problems to be worth handing the reins to it: it just has to substantially better on average than humans over the long haul, which it already is, especially if you have good verification of "done" and "working" in place through automated testing mechanisms. Perhaps we might say that QA is having its moment.

It doesn't mean humans aren't needed, but they aren't writing much if any code anymore.

I like the phrase Work Shaped Objects to describe the output of gen AI (I thank The Tech Report YouTube channel for bringing that to me).

So - prose, code, or image, it appears that some work has been done, but in fact the [actually needed] work has likely not been done.

I mean, was typing out code by hand really that bad?

If you were a professional software developer, you a) learned to touch type, b) started using vim/emacs keybindings to navigate around the project, and c) used a framework which already abstracted away a large part of the menial work.

And going all-in on the loop and no-code-review nonsense in a project someone is actually paying you for, I can only assume means you're hoping not to be around when the slop tower collapses.

AI is a better intelligence collection and analysis system, they need any information when you are using AI tools.

They are thinking: Please input everything you know, or just use it and it will collect everything in your PC or server automatically.

Stop lazy, stupid and dangerous behaviors.

The author is right to categorise AI as a good programmer, but not a complete coder. We can all agree that programming has become really fast since the release of GPT-5 series and Opus models because they're pretty good. Not only this, they've also changed the pace expectations across teams where a feature that should ideally be delivered within weeks, should now take days.

All this doesn't change the fact that software engineers are going nowhere because nobody trusts AI. If a model can escape highly secured sandboxes, then we're definitely not running these agents overnight on our systems. I am sure the next-gen of models will focus more on security and the trust factor will start developing, but that's a long way down the road.

People trust people, not systems.

Call me when you can prove a margin between token costs and business value.

What’s your number?

I don’t use gastown specifically but the level of complexity agents can code for is very high now.

Over this weekend in chat with the games discord watching as it iterated a harness built an entire implementation of the board game terraforming mars https://tfmbot.com using agents and harnesses for them.

I think if you can implement a board game end to end by feeding in the rulebooks and having a harness spawn agents to validate it’s reasonably solved.

Code is not solved seems to reflect the idea that using AI badly is a bad idea, and that to use it well you have to be good at making software.

The real tension is in the human AI interface and there are many unknowns. Can a software engineer with weak design skill use AI to produce good code. Will the future make those requisites less important. Will productivity increase with AI stagnate even for the best. Can a new way to interface humans and AI break that wall. Will software be created in a new way using dynamic libraries that AI agents prepare to cover a large scope of problems. Nobody knows yet. The article is strong on what is closed, accountability, ownership, NFRs, slop, and silent on what is open, which is where the argument actually is.

The latter may be just due to the fact that these tasks are not pure coding tasks.

PS: Has anyone watched DHH with Matz lately on Rails Conf where DHH is pretty much badmouthing ruby in front of Matz and Matz ends up saying "its my life's work"?

The old SHRDLU had a default response to "why did you put the red block on the green block". It replied, "Because you asked me to".

That must be a pretty angry llm to go rouge :)

To be fair, it's very possible at this point that LLMs will play a role in ending humanity. Not because they are super capable and will maliciously kill us, but because humans are stupid enough to hook them up to dangerous things that the LLM isn't remotely smart enough to manage successfully.

I don’t think viewing LLMs as “stochastic” or “probabilistic” is the right viewpoint. It’s directionally correct but not the right level of abstraction. LLMs are able to isolate patterns, generalize them, and apply them to new facts. That is very similar to what humans do in performing knowledge work. To the extent that humans also use logic, LLMs are able to generate logical propositions using pattern generalization, then call out to tools that check the proposed logic. Again, that’s similar to what humans do when they formulate some idea, then analyze the idea rigorously.

Just responded to a different thread, but it’s the same comment:

I was just at the Explore DDD conference in Denver and a portion of Friday was sitting at the cafe tables informally discussing the impact of GenAI on software engineering with notable people. Most of these people were deeply concerned that if we lean into using GenAI for “everything” that our collective knowledge will dissipate. I was the vocal contrarian. There are many historical examples of humans obfuscating knowledge to simplify progress. Does anyone solder their own microchips at scale anymore? No. We have highly sophisticated robots and machinery to do that work with extraordinary outcomes. In software engineering, if you remove “coding” as a discipline you’re left with all the other aspects of designing software which I contend can be retargeted in college CS curriculum. The leap isn’t about code reviews. It’s about design reviews and that’s where better outcomes are served regardless of whether GenAI is involved or not. I have a roughly year old codebase at https://github.com/ChicagoDave/sharpee/ that is designed by me, but generated by Claude Code with my own skills and agents as guardrails. I’m fairly certain the code I extract from Claude doesn’t require human review, but the design of the system and its changes are continually reviewed by me. My contention is that we “collectively” are still trying to discern where the AI/human line is and most are still “holding” that line to human interactions. Let it go. Define what part you do need human decisions on and focus on those things.

This is gold!

Those are embarrassing bugs, but they don't prove that LLMs of that time couldn't be effective overall, and they don't mean that the latest LLMs aren't generally very good at coding.

Sorry for starting a definitional debate but coding is definitely solved. I can generally read some code, get an idea of what edit I need to make and prompt an AI with a description of the logic and it will deliver syntactically correct, idiomatic code and test it. It has been months since I've been frustrated at junk being spit out.

However, software engineering isn't solved. Which is basically what this article is talking about. But having coding solved is still very beneficial - not long ago many software engineers would struggle very hard with turning a description of the logic required into syntactically correct code - and even for those capable it was incredibly time consuming.

So now the question becomes: Is software engineering solved? And my answer is no. People still need to read the code and understand the code and how it fits into the bigger picture. However, I feel like we are kidding ourselves if we think that we can go from producing code being a niche task for nerds to getting syntactically correct code from plain language without any deskilling of our work and careers. I feel like my personal "moat" has gone from "can speak computer" to "has ok reading, writing, comprehension and judgement skills" (I hate the word "taste" being used here ).

At the same time - I don't yet feel like there's a sudden abundance of competent software engineers - it's just that the folks who used to submit untested spaghetti code now submit big bowls of barely working slop. So maybe it the moat was never "can speak computer" - that was just the expression of more general skills.

The existential question for me is how far the deskilling will go. Because right now - you still need a solid grasp on computer science and software engineering concepts to do this job, as well as sufficient levels of grit and problem solving ability - but I'm not too confident that will last, and when it goes I don't think many of us will find this career enjoyable.

I totally agree and think this is The New Skill of software engineering: can you steer agents well enough to get work done at the speed they will allow, while still keeping enough context/understanding to step in when it matters?

Yes. Bad UI, cumbersome flows, too little automation, … plenty of flaws, but the business just keeps on running. Orders received, invoices written, documents shared, …

Could you elaborate? I don't use Anthropic's products for ethical reasons. Honest question. And when you say it's "solved" do you think an engineer should have the same income as a non-engineer if their outcome is the same?

IDK with Opus 5.5 it does kind of feel like it's solved.

They matter when implementing the business logic of the application, when writing tests for a character counting function, etc.

Even though I’m all in on using coding agents in my personal projects, I’m so glad I’m not working in a corporate job right now.

I'm using multiple agents to do work, with sub-agent orchestration, and it's still mostly coding.

I feel as though we are all doing the work of 2 people + an Architect, not so much 'Product' issues, although I'm sure it varies.

But I can't imagine how any actual software is written with 10% of the effort.

Yet when I wanted the model to implement the naive surface nets algorithm, Astra Max wrote 5+ allocations on inner loops. Alright, fine perhaps, given that I had not told it to preallocate during the inner loops. Except I did give it explicit instructions not to use malloc, and use the arena/pooling API I provided for everything. That was in AGENTS.md.

Alright, fine, I pointed that out. So what did Astra Max do? It replaced the mallocs with raylib MemAlloc functions, which are malloc wrappers. Why? I had explicitly asked not to use any raylib functions or includes on the module with the prompt. And my AGENTS.md has a minimal raylib inclusion note. Asking isn't helpful because AI does not know anyway. But seriously, why? I asked anyway and said it messed up.

Fine, I was able to get it on the 3rd try with arenas. But it had added getters for the internal state (guess who had a clause not to make getters?), and when pointed out included the physics header instead and added some convenience functions there, because apparently that was good practice and DRY.

If I let the reins slip just a little bit, everything turns into a mush; I wish I could get spaghetti instead!

So whenever I read something like this, "coding is literally solved with current models," I always treat it as a self report. I get that certain section of web frameworks may have been completely RL'd to hell and back, and that React and its ecosystem was already made with the explicit purpose of commodotizing the programmers so any panic 1000 junior hires could write something and maybe even contribute before they get laid off. I get that. But there is a whole world out where reality just doesn't work out like that.

FYI, this project was in C. C, as in one of the languages that the LLM's should have the highest amount of data for. So if the model had "literally solved" the programming of today, why is it so god awful?

That was rhetorical. What is solved is the most of the javascript ecosystem being RL'd. Any field that can't be RL'd to that degree (which apparently C isn't), coding is very much not solved.

but where are new shiny apps from whom who uses $RECENT sota models?

Don't be shy, give them a big task, let them build an entire app, UI and all..

I have found that a willingness to look like a temporary dumbass (primarily to yourself) is the largest predictor of success with pretty much everything.

What are the consequences of asking an LLM for the moon and receiving low earth orbit instead? Who cares if the proverbial rocket explodes on the pad? This is all happening entirely in a computer system completely under your control and likely at relatively low cost. No one else has to find out about your mistakes if you don't want them to.

But just go ahead and give the latest models (Opus 5.5 / Astra 6 as of today) another try. See what they are capable of and read the code which they produce.

Well, for one, they're capable of draining our (or companies') wallets.

I resolved a huge merge conflict for $60 today. Opus 5.5 did a great job and spent just 1h 16min on this. I could probably run six such sessions today, if I disregarded the need to read and understand the code.

This money has to come from somewhere and my concern is that it will be from decreasing the number of people hired and/or their salaries.

At the same time I firmly believe people who had a tendency to produce tech debt will keep doing that, regardless how brilliant LLMs will become. Unscrewing this is going to cost a lot of money.

This article would be 100% correct if it came out 1 year ago, 75% correct 9 months ago, 50% correct 3 months ago and it's probably 25% correct now if not less.

Feels like I read comment similar to this one each year since 2023.

I've really tried this and it's not quite what you're saying. You still need to steer it. You still need to stop it from doing stupid things. You still need to vet the architecture and data model. You still need to be clever, it's not that clever.

I think what software development is turning into is the art of setting up the program into a shape from which the LLM can reliably and efficiently fill up the rest of it. Sometimes that might not even require writing a single line of code. But I think you still need to be as good of a software engineer as you were before.

Coding is solved, just as transportation is. We now take for granted that cars, airplanes, monorails exists, which made moving around much more easy. But even today, with all the innovations we still have to think, plan, optimize how to do things best. Even that optimization uses a lot of AI, but ultimately I'm in charge of what option to pick based on a lot of human factors.

So transportation is not solved either? In that case, beam me up Scotty, I can't see any hoverboards around.

'Software' is about understanding problems and designing solutions along those dimensions.

But 'coding' per sey is 100% solved by LLMs - they write compiler perfect code all the time.

The question is not 'what it writes'.

The LLM is like a writer's assistant, who has perfect prose and grammar, but doesn't really write 'stories'.

""The reason LLMs are successful in writing code is because we’ve made a feedback loop that feeds the syntax/runtime errors back to the LLM and loops until most errors are solved or hidden."""

No - LLMs are 'good at code' because they have been ultimately 'trained' by the compiler.

All of the various SFT/RLHF methods etc. are using the compiler as the verifier.

You have zero tolerance for disagreement and civil discourse

A bit hypocritical there, no?

Considering what the author says about people who believe AI produces code that is good enough.

And in my view it clearly does, particularly when you care to iterate in order to iron out issues you find in manual testing.

I can’t get past the fact that in the post’s disclaimer, they ask the reader to “beware of the straw-man fallacy: just because one argument doesn’t map to your belief system, it doesn’t mean the rest are invalid.” That’s not the straw man fallacy, thus not “mapping to my belief system,” and I am caught in an infinite loop.

What a nice article. If I ever get in a situation where my manager demands I have to go all-in on AI (run 10 parallel agents and lose my sanity while trying to follow what is going on), I'll ask them to read this article first.

Additionally, isn't it ironic that the only comment on Substack is: > "Sometimes in the process of writing a good enough prompt for ChatGPT, I end up solving my own problem, without even needing to submit it". AI as a rubber ducky, I think this is good AI use!

Sounds like a reporter calling math "solved" after their first time using a calculator.

Anthropic accidentally leaked Claude Code (which on further study turned out to have many flaws) and their status page shows orange is the new green!

Yes, of course, because Claude Code with all these bugs could never be a successful piece of software that makes money.

nitpick: I was fully engaged with this article until I hit

And a bonus point: you skim. Did you notice number 5?

Then I bounced. The best readers skim aggressively. Most text is not worth reading. You skim to identify what is.

But moreover, reading != proofreading. I read every one of the bullets! I did not pay attention to the numbering scheme, because it conveys no meaning. It's a structural affordance for referring to the text, not part of its content.

it is preferences all the way down

No you're falling victim to the common programmer fallacy that "my use case is everyone's use case"

These things exist because people had different use cases

A few years ago i was working at a big corporation. Most of the guys used command line for git. Back then i was not familiar with the idea of git as i used to TFS. Then i learned about a UI tool (it has an octapus for logo) and never looked back. I could not understand why people chose to still use command line when there where other, newer, options. It seems to me now again that there are people resisting change. Resistance is futile. Yes by vibe coding you wil not get any better. But managers dont care about that. Businesses dont care about that. If you want to get better do it in your owntime, or leave the corporate job. It seems we always try to seek for endings. Coding is solved, all jobs will be run by robots etc etc. But life has no endindings, only new beginnings.

I think LLMs are suitable for all kinds of software domains, especially for bug hunting and analyzing programs. However, it's important that companies and individual developers continue to have and acknowledge full responsibility for what they produce. Right now, it seems to me that developers/companies are distancing themselves from the programs they distribute. A typical example is the way AI companies portray their own AIs malicious actions as if they (the company themselves) hadn't committed any crimes.

That shouldn't be allowed. You need to be able to sign off on what the AI does and create. If you're not willing to do that and instead want to continue to have scapegoats, then you can't use AI and need human developers. Blaming the error on humans might work, blaming it on some AI doesn't. I don't want to live in a world with AI-created disasters where no person and no company is ever responsible.

maintenance, reliability, security, scalability, etc. is the majority of the cost

It's funny because, I think the author is spot on in this article, including the problems identified in my quote above, but none of those are the reason I personally dislike the rise of LLM code - for me it all comes back to licensing and attribution. Everything else is just a cherry on top of the diarrhea sundae. I certainly don't want unmaintainable, unreliable, insecure code, but even some of the best software occasionally falls victim to these traits (its simply intrinsic to LLM code).