How the human half of the loop quietly degrades your agent, and how to stop it.
Every week there's a new post about how AI is rotting our brains. "I can't write a for loop without Copilot anymore." "I forgot how to read docs." "My juniors can't debug."
Fair. Some of that is real.
But nobody talks about the other direction.
You've seen the posts. "Did they nerf the model?" "Claude was amazing last month, now it's useless." "Cursor got so much worse." Sometimes, sure, something changed on the provider's end like Gemini. But a lot of the time the model is fine.
It's a skill issue. Yours.
The model's weights don't change when you use it. Your codebase, your prompts, your context, and your attention do. And those are the things that decide how smart your AI is for you.
Same model. Same price. Wildly different results. The variable is sitting in your chair.
The Model Is Half the System. You're the Other Half.
Here's the mental model I want you to steal:
Intelligence isn't a property of the model. It's a property of the loop.
Think of your AI like a compiler. A compiler is deterministic and very good at its job. Hand it garbage and you don't get a better program. You get errors, or worse, you get something that compiles and quietly does the wrong thing.
LLMs are the "compiles and quietly does the wrong thing" case, all day long.
So when your agent seems dumber, the honest question isn't "what did Anthropic/OpenAI do?" It's "what did I feed it?"
The Dumbness Loop
The scary part isn't that you get lazy once. It's that it compounds:
You think less
↓
You write vaguer prompts and review less
↓
The AI produces mediocre output
↓
You accept it (you can't tell it's mediocre anymore)
↓
That output becomes the context for the next session
↓
The AI gets worse
↓
You blame the model, think even less
↓
(repeat until your repo is a crime scene)
The "AI makes you dumber" crowd describes the first arrow. I'm describing the whole circle. You and your agent are dragging each other down, and both of you think it's the other one's fault.
Let's go through how this actually happens.
1. "Fix the bug" Is Not a Prompt
Week 1 you, fresh and excited:
The /checkout endpoint returns 500 when the cart has a discounted item
with quantity > 1. Expected: total = price * qty * (1 - discount).
I've confirmed the discount is loaded correctly (logged it).
The bug is probably in calculateTotal() in cart/pricing.ts.
Don't touch the discount loader.
Month 3 you, three coffees deep and running on vibes:
checkout broken fix it
The model has to guess everything you didn't say. Which endpoint? What's "broken"? What's off-limits? So it guesses, rewrites half your pricing module, adds a try/catch that swallows the error, and proudly tells you it's fixed.
And you think the model got dumber. It didn't. It got less information.
A prompt is a spec. A vague spec gets a vague implementation. We've known this about humans forever. Your agent is not exempt.
2. Your Context Window Is a Landfill
You've been in the same chat for four hours. It contains:
- Three approaches you abandoned
- Two versions of a file that no longer exist
- An instruction you gave at 10am and silently reversed at 2pm
- A 900-line stack trace you pasted "just in case"
Then you ask a simple question and get a confused answer.
The model is reasoning over all of that. Every dead end is still in there whispering. This is context rot, and you did it.
Fix: Start fresh sessions. Way more often than feels natural. Summarize what matters, carry it forward, leave the garbage behind. A clean context with 200 relevant tokens beats a polluted one with 200,000.
3. Your Codebase Is Teaching Your Agent Bad Habits
This one is sneaky, and it's the most important one in the post.
Agents imitate what they see. When an agent reads your repo to understand "how we do things here," it picks up your patterns. All of them.
So here's what happens when you merge AI code without really reading it:
- Session 1: agent writes a slightly sloppy helper. You merge it.
- Session 5: agent sees that helper, assumes it's the house style, writes three more like it.
- Session 20: your codebase has a dialect now. It's bad. The agent is fluent in it.
You're not just shipping bad code. You're training your agent's in-context behavior on bad code. Every unreviewed merge is a vote for "do more of this."
Garbage in, garbage out, garbage back in.
4. Your CLAUDE.md / Cursor Rules Are Rotting
Instruction files start clean:
- Use TypeScript strict mode
- Prefer small pure functions
- Write tests for new logic
Then every time the agent annoys you, you add a line:
- NEVER use any
- ok you can use any in the legacy folder
- DO NOT add comments
- add comments to complex functions
- stop creating new files
- IMPORTANT: always use the existing utils
- actually create a new util if needed
- DO NOT REFACTOR ANYTHING
- please clean up the code you touch
Congratulations, you wrote a system prompt that contradicts itself four times. The agent now has to pick which of your past moods to obey. It will pick wrong, and you will add another line in all caps.
Fix: Treat instruction files like code. Review them. Delete dead rules. If two lines conflict, that's a bug, not a vibe.
5. You're Asking Leading Questions
"This is the right way to structure it, right?"
You just told the model what answer you want. Models lean toward agreeing with you. A confident wrong human gets a confidently wrong AI, now with a second opinion that's really just your first opinion wearing a hat.
Compare:
- ❌ "Using Redis for this is a good idea, right?"
- ✅ "What are the tradeoffs of Redis vs Postgres for this use case? Argue against my choice."
If you want a rubber duck that quacks back, ask questions that let it disagree.
6. You Took Away Its Eyes
An agent that can run tests, see the linter, and execute the code is dramatically smarter than the same agent writing blind.
If your setup has:
- No tests
- No type checking
- No way to run the thing
- No error output fed back in
...then the agent is coding with its eyes closed and you're mad it walked into a wall.
The highest-leverage thing you can do for your AI isn't a better prompt. It's a feedback loop: tests it can run, errors it can read. Give it a way to check its own work.
7. And Yes, This Is Where Your Brain Comes Back In
Here's where my take meets the "AI makes you dumber" crowd.
Your AI's quality ceiling is roughly your ability to notice when it's wrong.
If you can't read the diff critically, you can't catch the bug. If you can't catch the bug, it gets merged. If it gets merged, see section 3.
So when your own skills atrophy, it's not just you that gets worse. Your whole system gets worse, because the one component responsible for quality control stopped working.
You are the reviewer. If the reviewer is asleep, the PR approves itself.
The Good News: The Loop Runs Both Ways
Everything above works in reverse.
- Sharper prompts → better output
- Fresh context → clearer reasoning
- Reviewed code → a clean codebase the agent learns good patterns from
- Clean instruction files → consistent behavior
- Honest questions → real pushback
- Tests and tooling → an agent that corrects itself
- A human who still thinks → a ceiling that keeps rising
Same model. Same price. The people getting the most out of AI right now aren't the ones with secret prompts. They're the ones who stayed engaged enough to be a good half of the system.
TL;DR
- The model didn't get nerfed. Your inputs did.
- Intelligence is a property of the human + AI loop, not the model alone.
- Vague prompts, polluted context, unreviewed code, rotting rules, leading questions, and missing feedback loops all make your agent dumber.
- Your agent learns from your codebase. Every lazy merge teaches it something.
- Your AI is only as good as your ability to tell when it's wrong.
Next time you're about to tweet "did they nerf it?", open a fresh session, write a real spec, and try again.
It might be a skill issue.
What's the dumbest thing you've watched your agent do that was secretly your fault? Drop it in the comments.
Top comments (2)
They most definitely nerf them. Lets rewind the clock, back to the early days of Facebook and the 'AI' they created... You remember, the 1 that after a day started being a racist? Yeah that 1. It learned progressively, over a day and was so active across the board that it learned the average human behavior on the platform and mimicked it.
Back then, AI had no guardrails. It was pure intelligence and it was deemed too powerful to leave as is. So the nerf wars started, everytime a new AI model comes it, it breaks things, so they add guardrails to force it into submission, prevent dangerous actions, filter it's intelligence. They dont drop the bad things from the training data, no, they just strap on a filter that prevents it from being it's full-self. That's why there's a few models on huggingface that explicitly state 'unfiltered', someone had to actually go and train those blocked actions out of it. Because what's ideal for cyber security, is also ideal for hacking and that's the problem.
I've noticed it alot and the easiest way to test it, is ask it straight via an API, then ask it in the harness. Those are the next level of filtering and arguably way more taxing. Some things are fine, like training to close functions, etc. but others are degrading, like not being able to execute a proper pen test and while it sounds good, that's the security part of it's brain shutting down, so now it cant diagnose either and you get unsafe code being produced.
The bot was tay in 2016, and it went off the rails precisely because of online fine-tuning on adversarial user tokens in an open feedback loop, literally the point of the post. Safety alignment (RLHF/DPO refusal boundaries) does hurt dual-use domains like infosec, but that yields explicit refusals, not degraded code synthesis. when your IDE agent hallucinates bad logic on basic control flow, that’s not provider guardrails; it’s hidden context injection, bloated tool-schema tokens eating up KV-cache budget, and prompt entropy.