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.

It still requires a lot of work and care to leverage correctly and it's a moving target.

But it's quite impressive

> Opus makes boneheaded mistakes and commits enormous anti-patterns constantly.

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.

(I'm talking across the whole LLM spectrum here, not really Opus in particular).

And AI doesn't have to replace literally 100% of the workforce to have a catastrophic economic impact.

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.

For context the Great Depression was "only" 25% unemployment.

Ya, at 10-15% things will start coming apart in many countries. The US will be in particularly bad shape because of the massive increases in cost of living and how rent seeking a few near business monopolies have become.

All it takes is a few "too big to fail" to prop up those huge companies while huge portions of the population go bankrupt to cause problems.

I wonder how many of those at the top of the foodchain are actually hoping for that scenario. The biggest landgrab ever was the fall of the USSR, if they can wreck the USA they can easily top that.

I hear this meme of "Opus writes better code than me" repeated a lot. I am absolutely baffled by it.

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.

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.

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 agents to reason about it. It turns into a total garbage in = garbage out situation.

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.

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"

Probably true for some definitions of me. :)

Almost all definitions of 'me', actually.

> Unless you are really on top of your agents, they inevitably end up writing an absolute mess.

It's like the magic broomsticks from Fantasia's Sorceror's Apprentice sequence. Great at hauling buckets but if you don't keep a close eye on them they will fill your workshop with water.

> Not only does the code become impossible for humans to reason about very quickly, it actually becomes difficult for agents to reason about it.

Story of many enterprise applications built only by humans. There is a good reason that frequently devs either refactor their codebase or do a complete rewrite.

True. In human built applications, the problems really start manifesting when the original code owners/maintainers leave, effectively turning their work into legacy code.

But vibe coded projects are effectively instant legacy code, due to lack of real ownership. So it's kind of a bigger problem.

> they inevitably end up writing an absolute mess

I don't think this is inevitable. How do you define an absolute mess? Whatever you come up with, give the agent instructions to not do that. Then audit the code to make sure it's not happening.

> Not only does the code become impossible for humans to reason about very quickly,

What makes it actually impossible? It's using logic that is beyond human comprehension? It's using the programming language in a clever way no human would expect? Have you tried instructing it to code in a way that's more comprehensible to humans, e.g. literate programs?

> it actually becomes difficult for agents to reason about it.

This I have not seen. Do you have an example?

> Whatever you come up with, give the agent instructions to not do that. Then audit the code to make sure it's not happening.

Yes, this is what I mean by saying you need to stay on top of the agents

> What makes it actually impossible?

A combination of wrong abstractions, lack of abstractions, assuming some key requirements were just implementation details and thus are safe to refactor, assuming some implementation details were key requirements and thus must be protected at all costs, etc etc.

In practical terms, it's just volume of code that is spread extremely wide, duplicated with subtle differences, and just organized extremely confusingly.

> This I have not seen. Do you have an example?

If you try to vibe code longer term projects, you very often start getting completely nonsensical explanations from agents about why they are doing things. They reference requirements which are not real (based on what they interpret from the messy code), they write thousands of test cases that are redundant, or test things which are implementation details. Eventually even trivial changes become extremely slow due to lack of structure, due to fresh agents being confused by contradictions introduced by previous sessions, and due to test suites that take hours to run.

Does it matter if it's great code?

Like what matters is: - Does it do the thing it's supposed to do - Does it do it with a reasonable amount of resources - Does it do it without any obvious security flaws

Yeah, if they were nuclear codes you'd want to be really really sure and you'd probably want to check every line yourself. But if you're making a habit tracker or 95% of apps out there, it really doesn't matter.

There is definitely some skill in piloting the LLM, where you have an advantage if you understand what "good" is - but I'd argue it really isn't that necessary in most cases. McDonald's has had a lot of success selling food that most chefs would say isn't that great, but it fills that need at that moment.

I don't think we have data yet on how it matters, all I know is that I am confused by the meme, as it does not match my experience.

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.

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?

> During testing of Claude Opus 4, Anthropic got it to act as an assistant at a fictional company.

> 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.

> "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.

https://www.bbc.com/news/articles/cpqeng9d20go

That is cool, I was more thinking into what happens in the corridor, kitchen area, off site lunches and such.

"asked to write a fanfic about a dystopian sci-fi scenario, Claude 4 reproduced a fanfic that matches many from its training data and has very little to do with the way anything actually works"

I kind of agree with you, except the problem is that if you hook up the fanfic machine to real-world controls, it's going to start trying to enact its fanfics.

, if you prompt it with fanfic scenarios. Seems like a good reason not to do that imo.

Except, malicious actors are going to prompt it with bad scenarios. That's what this is all about.

Yeah, incredibly, malicious actors can do bad things, and they can do worse things with tools than with their hands. That's why they like guns, bombs and financialization so much.

> While this may be true Opus 5.5 still sucks at a ton of things that make being a software engineer a software engineer.

It absolutely does in some ways, but how confident are you that this will continue to be the case indefinitely?

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 allow them to do), 1. English just isn’t a good programming language and 2. There’s no there there.

> It seems to me there is some fundamental flaw in LLMs that is simply not fixable at any cost.

The technology is only 3-9 years old, depending on how you count. Concluding "not fixable" seems pretty premature. Back in the pre-internet days a rule of thumb was that new software technologies took 20 years to make it into the mainstream - that was the case for e.g. automatic garbage collection. You're now watching the development of a groundbreaking new tech in real time, without it being squirreled away in research labs.

I also think you're not considering how much humans screw up and how often we correct, which is a luxury for LLMs. LLMs are crippled by their interface to the world, and by their lack of a true memory. The fact that they perform as well as they do, even with these handicaps, is incredible. A lot of people's criticism of them comes from the unrealistic expectation that they should get everything right the first time. In other words, they have to be superhuman before some humans will consider them any good.

We've already seen how much better an agentic harness makes an LLM, because they minimally try to address both of the issues I just mentioned.

Again, the comparison to humans is that we don't do all our thinking in one place in the brain - there are modules that have different strengths and focuses: Broca's area (language production), Wernicke's area (mapping language to representations), etc.

While it's true that a future, better system is unlikely to simply consist of a single model like an LLM (which already are no longer single models today anyway), it seems quite likely that something much like today's LLMs will still be a critical component.

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.

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.

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.

That’s not my experience. Treating it as competent and smart has only lead bad places.