Smarter Models, Sloppier Prompts: Why AI Feels Dumber While It's Getting Smarter

Smarter Models, Sloppier Prompts: Why AI Feels Dumber While It's Getting Smarter

Yes — another AI post. Second one this year. I know.

Back in July I wrote that the harness, not the model, is what lets you ship production code with AI. Rules, memory, tests, a second model, worktrees, the whole scaffolding. I stand by every word of it. But I left one piece of the harness out, and it's the piece that's been quietly rotting for four months.

Me.

Imagine this: a new model drops. Everyone says it's smarter. You switch, and within a day it feels... off. It asks questions it shouldn't need to ask. It charges ahead when it should stop. It does the thing you told it never to do, and somehow also refuses to do the thing you told it to always do. You open X and, sure enough, the timeline agrees with you: nerfed. Lobotomised. "They quantised it to save money." You nod along, close the tab, and type into the terminal, in all caps, exactly what you think of it.

That was me. This week.

Meanwhile, an AI (maybe) cracked Navier–Stokes

Here's what makes that feeling so absurd.

On September 8, OpenAI announced that an unreleased internal model had resolved the Navier–Stokes existence and smoothness problem. If that name means nothing to you: it's one of the seven Millennium Prize Problems, each carrying a million-dollar reward. The Navier–Stokes equations describe how fluids move — water in a pipe, air over a wing, the coffee in your mug — and the question is whether they always behave, or whether they can blow up into nonsense in a finite amount of time. Mathematicians have been stuck on it for decades.

No human wrote the proof. According to Simon Willison's breakdown of the announcement, a swarm of AI agents worked on it for about 88 hours, sent each other 2.7 million messages, and produced around 130 billion tokens of output. Then they spent roughly another 17 hours turning the proof into Lean — a language where a computer checks every single step of a proof, no hand-waving allowed. The answer, per the reporting: yes, it can blow up.

Now, the fine print — because I'd rather not turn this blog into a hype account:

  • Nobody has won the prize. OpenAI has said it won't claim the money. The Clay Mathematics Institute, which awards it, has said only that the problem has "apparently been settled" — and it only recognises a solution after peer-reviewed publication and vetting by the wider community, which it's in no hurry to rush.
  • It's one version of the problem. The claim covers the version where an outside force keeps pushing the fluid — not the unforced version most people picture.
  • It's contested. Mathematicians are arguing over the method, and over credit: two human researchers, Tristan Buckmaster and Levent Alpöge, had been working on a closely related problem — using OpenAI's own models. There's already a paper arguing that a Lean check of an AI's formal proof doesn't guarantee the human-readable proof says the same thing.

Notice the shape of that, though. Even at the very frontier of mathematics, what made anyone take the claim seriously wasn't the model. It was the harness: a proof checker that verifies every step, and a room full of humans who refuse to take the machine's word for it. Same lesson as July, just at a much higher altitude.

But even with every caveat attached, sit with the contrast for a second. In the same months a swarm of machines was producing a serious, if disputed, attempt at a Millennium Prize problem, I was in my terminal typing things like "WHY DIDN'T IT APPLY???" at a model and grumbling about nerfs.

So either AI is getting dumber and smarter at the same time, or something else in the loop changed.

Spoiler: something else did. So I did something I should have done months ago: I went and looked at what I'd actually been typing.

The receipts

Claude Code keeps a history of every prompt you send. Mine goes back to May 2026: roughly eighteen thousand prompts across a handful of production systems — the farmbetter work from the last post, a movie streaming platform with a Flutter app, a NestJS backend, a Cloudflare CDN worker and an admin dashboard, plus a few client projects. So I ran the numbers on myself. Month by month: how often I swore, how often I misspelled things, how long my prompts were, how often I asked a question.

Month (2026)Prompts with swearingMisspelled wordsMedian prompt lengthPrompts that are questions
May5%5.2%15 words32%
June10%7.1%12 words32%
July17%8.8%14 words33%
August20%7.5%13 words36%
September17%7.1%15 words38%
October17%7.5%13 words35%
November (so far)19%7.1%13 words40%

(The misspelling number is crude — words my Mac's dictionary didn't recognise, after letting tech jargon through. But it's crude the same way every month, so the trend is real even if the exact figure isn't.)

Read that swearing column again. In May, one prompt in twenty had a swear word in it. By August it was one in five. It never came back down. Shouting in all caps went up by about half over the same stretch. Misspellings climbed by more than half at the July peak and settled a notch above where they started.

Here's the part I didn't expect: my prompts didn't get shorter. Median length barely moved. Same number of words — just more of them were swear words, and more of them were questions.

And my two most-sent prompts, ever?

  • continue — 227 times.
  • status? — 101 times.

Continue what? Status of which of the three things running? I knew. I always knew. The model, waking up mid-thought in one of nine terminal tabs, had to guess.

Ambiguity is the real tax, not typos

Let me be fair to myself for a second: typos mostly don't matter. Modern models read straight through "figure of phrase" and know you meant "figure of speech." (Yes, that's a real one of mine. We'll come back to it.) A misspelled word is noise. The model filters noise for a living.

What it can't filter is a missing noun.

Here's a real one. Mid-task, I asked the AI to check whether a map setting existed on our dev environment, and to add it if it didn't. Simple, right? Except two different websites read that exact setting: the customer-facing site and the admin site. My message named neither. The AI picked the customer site, set the value, rebuilt its dev deployment, and reported back: done.

I meant the admin site.

So the value had to be deleted, the customer site rebuilt again, and the admin site — the one I actually cared about — carried on using a demo map until I noticed and asked about it later. My reply at the time was, and I quote, "next time ask me if I'm vague."

Read that again. I asked the AI to compensate for my vagueness. Not to be less vague myself. To ask me when I am.

  • Without the noun: one message, one wrong site, one undo, two rebuilds, and the real fix still pending.
  • With it — "on the admin site's dev environment, check for the map setting; add it if it's missing" — six more words. Done once.

Anthropic's own prompting guide has a test for exactly this, and it's brutal in its simplicity:

"Show your prompt to a colleague with minimal context on the task and ask them to follow it. If they'd be confused, Claude will be too."

The same guide tells you to think of the model as "a brilliant but new employee who lacks context on your norms and workflows." New employee. Not a colleague who's sat next to you for four months. Which is precisely the mistake I'd drifted into.

Why it happens (or: who's actually tired here?)

None of this was a conscious choice. I didn't wake up one day and decide to be vague. It crept in, and I think I know why.

It feels like a conversation, so you talk like you're in one. The answer streams back at reading speed, in friendly, fluent prose. After a few hundred exchanges your brain files it under "colleague" — and you start texting it the way you'd text a colleague who's been on the project since day one. Half sentences. Shared context assumed. "status?" is a perfectly fine message to a human who was in the stand-up. To a model that just got its context compacted, it's a riddle.

I was running a lot of them at once. On a typical day this autumn, I sent prompts into nine different sessions. My record is thirty-two. Some days I was delegating so much that the background agents I'd spun off accounted for around 90% of the tokens spent — by early September my weekly usage was sixty times what it had been in late July. When you're juggling that many threads, every message you type is written by a context-switched, half-attentive version of you.

Frustration compounds. The model gets something wrong. You're annoyed, so your next message is terser and angrier. Terse and angry is less clear. Less clear produces another miss. Round and round.

In the last post I wrote a whole section on managing the AI's context window — how, when it fills up, the AI gets dumber, "same as a tired engineer at hour ten, except it won't tell you it's tired."

I never once thought about my context window. Turns out I was the tired engineer at hour ten. And I didn't tell anyone either.

The twist: my harness was eating my anger

This is the part that genuinely surprised me, and it's the part that actually explains the "the new model is worse" feeling.

In July I told you my best trick: turn every mistake into a rule. My rules file had twenty-four of them back then. I wrote, proudly: "the AI did something that made me furious, and instead of just fixing it that once, I turned my anger into a law."

Four months later, it had fifty-nine. At its peak the file was over 60KB — somewhere around fifteen thousand tokens, loaded into every single session before I'd typed a word. And when I finally sat down and read the whole thing end to end, a lot of those laws were fighting each other:

  • Never write code until I explicitly say go. And also: never wait for my go on anything you can already do.
  • When my request is vague, ask me. And also: never end a turn with an open question while there's work you could be doing.
  • In one project's file: verify every feature end to end against a deployed environment. In my global file: never test against a deployed environment.

Every one of those rules is correct in the incident that produced it. Each was written on a different day, by a different flavour of furious me, about a different mistake. Put side by side, with no context, they're a coin toss. And whichever way the model called it, it broke a rule I'd written in capital letters — so I got angry, and wrote another rule.

Then there's the bit that really stings. In the last post I also bragged about this:

"There's a neat twist, too. That same tool quietly watches my corrections and distills them into behavioral rules — so a chunk of the 'do not do that again' bookkeeping I opened this whole post with runs itself."

Here's what "distilled" actually looked like, straight out of the file it wrote — filed as hard rules, loaded at the start of every session and again after every context compaction:

  • [hard] Dumbass lol. You are funny. I didn't mean it directly, it was a figure of phrase lol.
  • [hard] Do not can't we save the translations though? So that we do not keep on having to translate on the fly?

The first one was me laughing at the AI for taking a joke literally. It became a hard rule. The second was a perfectly reasonable question — can't we cache these? — and the tool bolted "Do not" onto the front of it and filed it as a prohibition. There were twenty of these in one project alone, with rule numbers in the four hundreds. Others were just my angriest messages, verbatim, every swear word intact, promoted to law with zero context about what had made me angry.

That "neat twist" was quietly poisoning the well.

Shouting doesn't work the way you think it does

There's a mechanical reason this backfires, and again, it's sitting right there in Anthropic's prompting guide:

"If your prompts were designed to reduce undertriggering on tools or skills, these models might now overtrigger. The fix is to soften any aggressive language. Where you might have said 'CRITICAL: You MUST use this tool when...,' you can use more normal prompting such as 'Use this tool when...' instead."

Read that, then read my rules file. Mine was wall-to-wall "CRITICAL" and "NEVER" and "MUST" — and, in the machine-made bits, considerably worse words than that. Older models needed shouting to pay attention. Newer ones take you at your word. So when a new model arrived and read fifteen thousand tokens of all-caps contradictions, it did exactly what the guide predicts: it over-applied the loudest rule to situations it was never meant for.

The guide even uses my exact style as its example of what not to do. Under "Add context to improve performance", the less effective prompt is literally:

NEVER use ellipses

The better version just says why: the response will be read aloud by a text-to-speech engine that can't pronounce ellipses. Then the guide adds one line that I wish I'd read in May: "Claude can generalize from the explanation." From the reason, not from the volume.

So when I sat down this week to work out why the new model felt worse, the first thing I checked was the model settings. They were fine — the effort level was already turned up near the top. The problem wasn't the model. It was what I'd been feeding it: a pile of shouted, contradictory, context-free rules, a chunk of them auto-generated from my worst moods.

The model didn't get dumber. It got more obedient. And I'd given it a lot of loud, conflicting things to obey.

The loop, drawn out

If you're wondering how a reasonably careful engineer ends up here, it's a feedback loop, and every step of it feels sensible from the inside:

  1. The AI makes a mistake.
  2. I'm frustrated, so I write a terse, angry correction.
  3. That correction becomes a rule — in caps, with no context — either because I wrote it or a tool did it for me.
  4. The rulebook grows. Rules start contradicting each other. The loudest ones get over-applied.
  5. The AI behaves worse, in new and confusing ways.
  6. I'm more frustrated. My prompts get even terser. Back to step 1.

At no point in that loop did I ask whether I was the input that changed.

What I changed

I cleaned the rulebook. I read every rule end to end, fixed the ones that contradicted each other, and made the vague ones specific. I also shrank it a lot — more on that in the next section.

I turned off the auto-distiller. A machine reading my angriest messages and promoting them to law, with no context, is the opposite of engineering judgment externalized. It's just mood, externalized.

Things that must never happen became enforcement, not prose. If something is genuinely non-negotiable — never print a secret, never run a gcloud login that breaks every other session — a capitalized sentence is the wrong tool. I've had an AI read "use grep -q" in its instructions and run a command that printed six live credentials anyway. Those things now live in hooks and wrapper scripts that physically block the action. A shouted rule is a request. A hook is a wall.

And on my side of the keyboard:

  • Name the target. Which site, which environment, which repo, which ticket. Six extra words beat one undo.
  • A question is a question. My own rule number one says the AI must not treat a question as a request to change code. That cuts both ways: if I want something done, I say "do it." If I ask "can't we cache these?" I should expect an answer, not a pull request.
  • Write the rule the next morning, not mid-incident. A rule written while furious encodes the fury. A rule written calmly encodes the lesson — with the why, because the why is what the model actually generalises from.
  • Before adding a rule, read the ones it might fight. Every new law should get checked against the existing ones. Mine never were.
  • Run the colleague test. Before sending, read the prompt as someone who wasn't in your head for the last six hours. Would they know what "continue" means?

Typos? I've mostly made my peace with them. The model reads through "figure of phrase" just fine. It's the missing nouns and the shouting that cost me.

Putting the context on a diet

In July I covered the basics of treating context as a budget: get an exact token count, see what's eating the window, prune the junk. Everything above is really the same problem seen from the other side — the model's attention is finite, and I'd been filling it with my own noise. Here's what I've added since, none of which made it into the last post.

The rulebook is context, so compress it like context. Every token of rules gets loaded before every message, in every session, and into every agent I spin up. Three moves took it from about 63KB down to about 35KB:

  • History out, rule in. Each rule used to carry the full war story of the incident behind it. Those stories now live in a separate incidents file; the rule keeps a single line of why and a number pointing there. Nothing is lost — it's one read away — it just isn't re-sent on every turn of every agent.
  • Procedures load on demand. The long, step-by-step detail moved into skills. The rule says "before doing X, load skill Y", and the twenty steps only enter the context when X is actually happening.
  • Project rules live in the project. Rules for one client's codebase don't get loaded while I'm working on the streaming platform.

(Still too big. I know.)

Agents report to a file, not to the chat. Early on, I'd have a sub-agent read half a codebase and then paste its entire report back into the main conversation. In one session I burned through 56% of a million-token window, mostly on reports relayed word for word — paying for every one of those tokens twice. Now every brief ends the same way: write the full report to a file, return ten lines at most, no pasted files, diffs or logs. The main thread keeps the conclusion. The evidence sits on disk if I want it.

Hand off before the bloat. Over sixteen days in September, I ran 1,434 agents. 119 of them went past 250,000 tokens of context — and those 119 accounted for 43% of everything the agents cost. The worst one ran 755 turns at an average of 473,000 tokens of context, and by itself cost more than my entire first week of August. A model deep into a stuffed context window is slower, pricier and sloppier — the tired-engineer problem again. So every implementation brief now carries a handoff clause: keep your working state in a file as you go, and at around 180K tokens, finish the step you're on, write your state, and stop. A fresh agent picks up from the file with a clear head. Hard ceiling: 250K, no exceptions.

Don't spawn an agent for a two-minute job — and cap the family tree. A fresh agent burns tens of thousands of tokens just getting set up. 107 of those September agents finished in under fifteen turns: full startup cost, almost no work. And uncapped nesting gets out of hand fast — two jobs I'd authorised to use "up to three sub-agents" turned into seven agents and about a million tokens. Now it's at most one level of nesting below an agent, at most three running at once, and small lookups I just do myself.

Make tools do the reading. Long command output goes to a file and gets summarised by a script; it never gets pulled into the conversation. Filters run on the server, not in the context window: one investigation read a handful of cloud config values by dumping three entire environments and grepping the result — minutes of output for a few lines that one targeted query returns in a single round trip. This post is a live example: the numbers at the top came from about eighteen thousand prompts, roughly 6MB of history. The model never read a single one of them. A script did, and handed back one table.

And an honest update on the context tool I praised in July: I still use it for the exact count and the diagnosis. I've switched off its automatic restarts, and the rule digest you read about above.

The theme is the same as the rest of this post. The model has a finite attention span, and everything you put in front of it competes for that attention — your rules, your reports, your logs, your angry messages. Even that Navier–Stokes swarm didn't try to cram a Millennium problem into one context window. It was millions of messages between agents with focused jobs, each one seeing only what it needed.

So: the operator is part of the harness

I closed the last post by arguing that AI is a lever that multiplies whoever's holding it — that the better you are, the better your AI is. I still believe that. I just hadn't followed the thought all the way to the end.

A lever doesn't only multiply your skill. It multiplies your sloppiness, your fatigue and your bad mood too. Push vague, angry, contradictory input through a very obedient model and you get vague, confused, contradictory output — at speed, and with total confidence.

The models really are getting smarter. Smart enough, maybe, to settle a Millennium Prize problem while the mathematicians check their work. Which makes it all the more embarrassing that the bottleneck in my setup turned out to be a guy typing status? into nine terminals at once.

The model is not the product. The harness around the model is the product. And four months on, I'd add one line to that: you are part of the harness, and you're the part nobody's maintaining.

So here's a challenge. Go and read your last twenty prompts. Out loud, if you're brave. Would a brilliant new hire on their first day know what you meant?

Mine wouldn't have. That's the real regression.