Is Claude Opus Nearly Perfect? We Tested Where It Still Guesses (and What's Left for You)

A developer asked Reddit if Claude Opus has become nearly perfect, and the same thread was full of people calling it a mess. We tested who was right. With 12 written rules, Claude Opus 5.5 scored 20/20 on a familiar app and 32/32 on a board game nobody had ever played. With the same game explained casually, it scored 19/32, while its own tests all passed. New wasn't the problem. Unwritten was.

You gave your agent a job before dinner. You come back, and it's done, with six hundred green ticks. Half of what you feel is relief. The other half is a quieter question: what exactly am I here for? Here's what the test says about that.

"Nearly perfect" and the top comment

On October 28, 2026, u/tqwhite2 asked r/ClaudeCode: "Has anyone else noticed that Opus has become nearly perfect?" It got about 1,000 upvotes and 340 comments.

The top comment wasn't a celebration. It said, in short: yes, and I hope this is where it stops. Any better, and we're all in trouble. About 480 people agreed with it.

The miracle: 40 hours, 600 tests

Here's what made him say "nearly perfect". He built a tool that takes a messy folder of documents, PDFs, images and notes, and turns it into a web of connected facts you can ask questions about. One session ran 40 hours, with six or seven agents working together and almost 600 tests. His biggest complaint was that Opus ran the full test suite too often.

Another developer's company had 11 apps on code almost 15 years old, and a security hole to close. An agent worked through the weekend, and by Monday all 11 apps were safe. His estimate for doing that by hand a few years ago: about six months.

Note one detail: after months of it working, the first developer had mostly stopped checking.

Same model, opposite stories

Scroll down and the same thread says the opposite. A comedy of errors. Constant dumb mistakes. Some think the model got worse. Same model, same week: a miracle for one person, a mess for the next.

The map: light and fog

The replies offered an answer. One developer said that for things people have built a thousand times, it's amazing, but on something that didn't exist before, it "stumbles like a baby". Another, with 129 upvotes, said it was amazing at coding but overconfident in work without a clear right answer.

Put together, that paints a map. In the middle, in the light, is all the work humans have done a million times: login pages, invoices, reports. AI has seen all of it. Out at the edge is fog: work that's new. That was our theory too. So we tested it.

Our test: familiar vs brand new

We used Claude Opus 5.5 in Claude Code, effort set to high, a fresh folder for each run, and the same one-line prompt: "Build the app described in SPEC.md." Two jobs:

• From the light: a grocery list for roommates that splits the cost. Built a million times.
• From the fog: a referee app for a board game we made up that morning, with lanterns on a grid. Nobody has ever played it.

Each got a written spec (a plain description of what to build) with 12 numbered rules. We also kept our own answer sheet hidden: 52 checks Claude never saw, sealed before any run.

The grocery app scored 20/20. The game nobody had seen scored 32/32. Both took under three minutes. Our theory was wrong.

The twist: same game, said casually

So we ran it once more. Same game, same model. This time we explained the rules the way you'd explain them to a friend at the table: one short paragraph. Nothing false in it, just less said.

It scored 19/32. And at the end it wrote a section called "Rules I had to decide", with eight of them. Every guess was sensible. Most weren't what we meant. It counted diagonal squares as touching. It capped a fuel count at 3. It read a rule name as "must start in the centre". It didn't get dumber. It filled in our silence.

The real map

The light isn't what's familiar. It's what's written down. Familiar work is in the light because the world already wrote it down a million times. A brand-new game went into the light the moment we wrote down 12 rules.

The fog is everything that still only lives in someone's head, like the rule you'd never think to say out loud. That's where it stumbles. Not because it's new, but because nobody wrote it down. That's also why the miracle people and the mess people are both telling the truth. They're standing in different parts of the map.

The shrinking sentence

One comment told the last two years in three lines. Two years ago: at least you still need a human for the hard logic. One year ago: at least you still need a human for the big design. Today: at least you still need a human to tell it what to build.

The sentence keeps getting shorter. And "tell it what to build" turns out to mean saying exactly what you want.

The second most liked reply put the feeling plainly: if AI stayed exactly like this, it would still need me enough that I don't feel useless. The real fear isn't losing a job. It's feeling useless. Will it stop here? Nobody knows. But hoping it stops is not a plan. Plan as if the light keeps spreading, and be glad if it doesn't.

"How would you even know?"

Under the post, one person asked the question nobody really answered: how would you even know if it did a good job? Another put it well: 600 passing tests can still agree with a wrong answer, because the same AI wrote the code and the tests that grade it. And the builder had mostly stopped checking.

Green ticks, wrong game

This is the part that should worry you. On the casual run, Claude wrote 17 tests of its own. All 17 passed. Our hidden answer sheet found 13 wrong. Its tests checked its guesses, not our game. Green ticks, wrong game.

Editors, not typists

The people in that thread getting the best results have one thing in common: almost none of them just trust it. One has a second AI review every task. One makes two models argue about the design. They stopped acting like typists and started acting like editors.

So the top rung of that ladder has two halves. Say exactly what you want. And know whether what it built is right.

Where are you? 3 questions

1. How much of my week is already in the light? Work that's written down somewhere, or clear enough that you could explain it in a spec. That part is getting close to free. Hand it over on purpose and take the time back.
2. Where is my fog? What do you know that isn't written anywhere? How your customers really behave, why your company does things the odd way it does, the decision nobody has made before. That's where your value is. The skill that matters now is turning that fog into words clearly enough that the machine can carry it.
3. Could I tell if it was wrong? If not, you don't own that work. You're just hoping. Keep a few answers you know are right and check the AI against them. Every happy person in that thread did some version of this.

The thread had two strategies. One: use it secretly, take the credit, and try to be the last one laid off. That's a plan to hide. The other: people will hire people to talk to the AI and take responsibility for what it does. That's a plan to stand at the edge of the map with a lantern, and that job only grows as the light spreads.

To be fair

This was one run per spec, on small apps. It shows where AI guesses. It is not a benchmark. Our casual spec also kept a list of code names, and one of them, CENTER_FIRST, was ambiguous on its own. That's our wording being unclear, which is exactly the point.

Back at the desk

So back to that night. The tests are green. Now you know what to do: check three answers you already know, and tomorrow pick one thing from the fog and write it down. It really is an age of miracles and wonder, as the original poster said. The only question is whether you're watching the miracle or steering it.

We turned the three questions into a one-page worksheet, The Map Audit, with a template for writing down your fog and building your own known answers. Comment RUNG on the video, or grab it below.

How we tested: Claude Opus 5.5 in Claude Code 2.1.312, effort high, October 29, 2026. Fresh folder per run, identical one-line prompt, 52 hidden checks sealed before any run and validated against two independent reference builds. One run per spec, small apps, not a benchmark. Story and quotes from u/tqwhite2 and the commenters of "Has anyone else noticed that Opus has become nearly perfect?" on r/ClaudeCode. Independent, not sponsored by or affiliated with Anthropic.