Last week, a developer posted on Hacker News: “Tell HN: Man, AI is killing my brain.” The post hit 50 points and sparked a thread with over 100 comments. Another thread — “Show HN: OzBrain, a shared brain for knowledge between agents and your team” — pulled 92 points and 58 comments from founders building entire workflows around agents.
These aren’t product announcements. They’re developers talking to each other when no marketing team is watching. Here’s what they actually think.
What Happened: Two Threads, Two Different Realities
Thread 1: The Cry for Help (August 27, 2026)
A developer using the handle fnoef described a year-long descent. Started with Claude Code, reviewing every line. Then colleagues shipped 10x more by pushing straight to main. Pressure mounted. Soon they were running 4-5 parallel agents via worktrees, juggling outputs, eventually just accepting Claude’s “Recommended” suggestion without understanding the code.
“Almost one year later and I’m no longer sure I can write code any more. Hell, I’m even struggling to write this post because AI is very good at understanding wrongly spelled words, doesn’t care about punctuation or capital letters. Every single thing that made me think, was taken away from me.”
They’re not asking for advice. They’re sharing misery.
Thread 2: The Power User Playbook (August 21, 2026)
dariusmonsef, a founder who “lost coding skills more than a decade ago,” built a voice AI for seniors using agent workflows. He uses Claude Code locally, Cursor for UI work, Codex for token thriftiness — all feeding a shared knowledge base (OzBrain) that agents read and write via MCP. Out of 75 founder friends surveyed, 26 built custom knowledge systems (Obsidian vaults, markdown repos, cron-jobbed Supabase syncs). 32 felt the pain but had no solution.
Two threads. Same tools. Completely different experiences.
Developer Reactions: The Comment Threads Speak
“It doesn’t matter if I can write code or not. It means nothing.”
One commenter (missingpackage) captured the existential dread: the skill itself feels devalued. Not “I’m tired” — “it means nothing.” When the output is commoditized, the craft loses its anchor.
The “Intern” Analogy — And Why It’s Dangerous
Multiple developers compared agents to interns: delegate the grunt work, review the PR, stay in the loop. dkowalski called it “handing it off to an intern to do the preliminary work.”
But numeri pushed back hard:
“A senior engineer is only able to effectively delegate to interns because of years spent as that intern/a junior engineer. If you’re a junior engineer or an intern doing this, I think it might be harmful long-term.”
The apprenticeship model breaks when the apprentice never does the reps.
Brain Atrophy Is Real — And Documented
chistev linked to their own blog post: “How Artificial Intelligence (AI) Is Making Us Dumber.” The argument: AI atrophies the brain like an unused muscle. The “slow and painful bits” of research — hunting for answers, building familiarity, generating follow-up questions — are where actual understanding forms. Shortcutting them with quick LLM answers trades long-term growth for short-term speed.
MarkusQ extended the analogy:
“The brain damage comes from trusting something other than your own brain to tell you what you understand, believe or know. You wind up thinking you hold positions you can’t articulate, have skills you can’t demonstrate, understand things you can’t explain.”
The “Gym for the Mind” Counter-Argument
curuinor offered a framing that resonated: society automated physical labor; construction workers now go to the gym. Knowledge workers will need “gym things for the mind” — deliberate practice that isn’t productive work, just maintenance.
But dpoloncsak highlighted the structural trap:
“The worry as the OP has pointed out — they will be asked to leave the workforce if they want to hone their craft by handcoding.”
You can’t “go to the mental gym” if the job requires 15 parallel agents just to keep pace.
Identity Crisis: “I Write More Code Than Ever But I’m Less of a Coder”
spottedmarley retired from coding as a career, then started using Claude Code. Now they write more code than ever — but feel “less of a coder than I ever have been.” It’s a new abstraction layer: problem-solving and endless tweaking/debugging instead of syntax and logic.
dkowalski admitted: “I don’t actually write much anymore, AI does it all (but I still say ‘I write’).”
The Depression Angle
One commenter (dpoloncsak again) gently suggested the OP might be dealing with “self-identity and depression issues” more than “AI brain drain”:
“Why even bother doing something by hand when an LLM can get me 90% of what I want in a few minutes? What value can I provide to this project that Claude cannot?”
They compared it to woodworking in the age of 3D printers, or music in the age of Suno. People still do it for the craft. But the pressure is different when your mortgage depends on it.
Health Comes First — But The Market Disagrees
mzajc dropped a literary reference (The Whispering Earring wearers’ brains wasting away) and a blunt reminder:
“Your health is your most important resource. If a thing is dangerous to your physiology, stop doing that, and rearrange your life around this new insight. Literally nothing else should matter above your health.”
Easy to say. Hard when every interviewer asks “how do you use AI daily?” and companies state “we like to move fast, so we use AI as much as possible.”
The Review Bottleneck
othmanosx identified a practical pain point: reviewing agent-generated code is the hard part, made harder by GitHub’s poor PR review experience. They built their own solution (pyor.review). The workflow isn’t “generate → done” — it’s “generate → review → fix → review → merge,” and the review step doesn’t scale.
The Real Insight: We’re Splitting Into Two Species
Reading both threads side by side reveals a divergence that should worry anyone in this industry.
Species A: The Conductors (dariusmonsef types)
- Lost coding skills years ago (or never had deep ones)
- Use agents as force multipliers for system thinking
- Build meta-tools (OzBrain, custom knowledge bases, adversarial review agents)
- Treat agents as autonomous workers they orchestrate
- Outcome: Leverage. Speed. New products from non-coders.
Species B: The Eroding Craftspeople (fnoef types)
- Built careers on writing, reading, debugging code
- Forced by competitive pressure to adopt agents
- Gradually stop understanding their own codebases
- Lose the ability to research, think, even write coherent English
- Outcome: Dependency. Anxiety. Skill rot.
The market rewards Species A. It punishes Species B — or forces them to become Species A, whether they want to or not.
The Junior Developer Crisis Is Already Here
numeri’s point about interns is the sleeper issue. If seniors delegate to agents instead of juniors, juniors don’t get the reps. If juniors use agents to skip the reps, they never become seniors who can delegate effectively. The pipeline breaks at both ends.
One commenter put it starkly: “The worry — they will be asked to leave the workforce if they want to hone their craft by handcoding.”
Knowledge Management Is the Real Bottleneck
The OzBrain thread reveals something the “brain drain” thread only hints at: the developers who thrive with agents externalize their cognition. They build shared brains (markdown, MCP, Supabase, custom tooling) so agents have context. They treat knowledge as infrastructure.
The developers who drown? They keep context in their heads — which overflows when 5 agents run in parallel.
“I was no longer having mental capacity to understand so much context, so I just started to chose the ‘Recommended’ suggestion by Claude.”
That’s not AI killing your brain. That’s cognitive overload from trying to hold 5 agents’ worth of context in a human working memory built for one.
What This Means for You
If You’re a Senior Engineer
Audit your delegation. Are you reviewing agent output with the same rigor you’d apply to a junior’s PR? If not, you’re not “moving fast” — you’re accumulating technical debt you can’t explain.
Build your external brain. The conductors aren’t smarter; they have better knowledge infrastructure. Start an Obsidian vault. Set up MCP. Make your context searchable and agent-readable. Your biological memory doesn’t scale.
Protect your reps. Do one thing per week without AI. Write a module from scratch. Debug a hairy issue manually. Read a paper instead of asking for a summary. Keep the muscle alive.
If You’re a Junior or Mid-Level Engineer
Don’t skip the intern years. Using agents to produce code you couldn’t write yourself is borrowing against your future. You’ll hit a ceiling where you can’t debug, can’t architect, can’t interview.
Use agents to learn, not replace. Ask “why did you choose this pattern?” “What are the tradeoffs here?” “Show me a simpler version.” Treat the agent as a tutor who happens to write code, not a ghostwriter.
Build in public. Write about what you’re learning. The act of explaining forces understanding that copy-pasting never will.
If You’re a Team Lead or Manager
Stop measuring output by commits. The fnoef nightmare — colleagues shipping 10x more via agents — creates a race to the bottom. Reward understanding, not velocity. Ask “walk me through this change” in reviews. Make it safe to say “I don’t know, the agent wrote it.”
Invest in review tooling. If GitHub’s PR view can’t handle agent-scale changes, fix that before demanding more agent usage. othmanosx built pyor.review for a reason.
Create “no-agent” zones. Designated times, projects, or onboarding periods where code is written by hand. Not for luddism — for calibration.
If You’re Building Agent Tools
The OzBrain insight is your roadmap. Developers don’t need more code generation. They need:
- Shared, auditable knowledge bases agents can read/write
- Conflict resolution when multiple agents touch the same context
- Versioned reasoning trails (why did the agent decide X?)
- Token-efficient context compression
- Human-readable audit logs of agent decisions
The winners in this space won’t be the best code generators. They’ll be the best context managers.
The Uncomfortable Truth
The HN threads reveal a split that no tooling solves alone.
Some developers are conducting — using agents to amplify system-level thinking they couldn’t do alone. They’re building new things, and they’re having fun.
Others are eroding — using agents because the market demands it, watching their hard-won skills atrophy, afraid to stop because the mortgage doesn’t pay itself.
Both groups use the same tools. The difference is agency — whether you direct the agents or they direct you.
The fnoef post ended with: “I feel like a mindless blob, floating around, paying mortgage, trying to survive, while my brain is being destroyed.”
That’s not a tool problem. That’s a power problem.
What’s Next
This conversation isn’t over. The “AI killing my brain” thread spawned a follow-up: “I can’t prove it, but I think AI is causing me brain damage” (linked in comments). Researchers are studying cognitive offloading. Companies are building “AI metrics dashboards” (WakaTime now tracks AI vs human lines of code, prompt length, follow-up edit rates).
Meanwhile, the conductors keep building. OzBrain, gBrain, llm-wiki, custom MCP servers — a whole infrastructure layer emerging to make agents manageable instead of overwhelming.
The question for every developer: Which side of the split are you on? And is it by choice?
Related articles
- Claude Code Alternatives in 2026: 12 Options Compared
- Beware: Hermes Agent Security Audit Uncovers Credential Bypass, Sandbox Escape, and Session Hijacking in 5 HIGH-Severity Findings
- Context Engineering for Coding Agents: How to Make Every Token Count
Want to read the source threads?
- Tell HN: Man, AI is killing my brain (50 points, 100+ comments)
- Show HN: OzBrain, a shared brain for knowledge between agents and your team (92 points, 58 comments)
All quotes paraphrased from Hacker News comments. Original authors credited by username where available.