Mitchell Hashimoto warns of AI psychosis in software companies: vibe coding fatigue and the Cursor generation

On May 16, 2026, Mitchell Hashimoto—founder of HashiCorp and creator of Vagrant, Terraform, Vault, and other infrastructure tools millions of developers rely on—posted a stark warning: "I strongly believe there are entire companies right now under heavy AI psychosis and it's impossible to have rational conversations about it with them."

Within hours, the X post drew 987 responses from developers sharing war stories: vibe coding fatigue after 1 year with Cursor, tangled codebases that "baffle maintainers and demand rewrites," and the painful realization that AI-generated prototypes don't scale to production-grade software.

This isn't a Luddite rejection of AI tooling. Hashimoto himself uses AI coding tools. The warning is about companies losing the ability to reason about trade-offs—shipping fast but creating brittle systems, burning out engineers who can't explain their own codebases, and mistaking prototype velocity for sustainable engineering.

This post connects the dots: Hashimoto's AI psychosis warning, the vibe coding fatigue epidemic, Jeff Morris Jr.'s 3-month experiment proving AI can't build commercial mobile apps, and what rational AI adoption actually looks like for engineering teams in 2026.

Answer-first: What is AI psychosis and why it matters

AI psychosis (Hashimoto's term) is the organizational delusion where companies are so convinced of AI coding agents' productivity gains that they cannot have rational conversations about limitations, technical debt, or long-term maintainability. Symptoms include:

• Speed worship: Shipping 10× faster becomes the only metric that matters, ignoring code quality
• Rational skepticism = heresy: Developers who question AI-generated architecture are dismissed as "falling behind"
• Maintenance blindness: Nobody can explain how core systems work; "the AI wrote it" becomes an excuse
• Burnout denial: Engineers working 17-hour days with AI agents while leadership celebrates "efficiency"

Vibe coding fatigue is the inevitable crash: developers exhausted from maintaining code they didn't write, can't explain, and struggle to debug when it breaks.

Why this matters now: AI coding tools (Cursor, Claude Code, GitHub Copilot) reached critical mass in 2025-2026. Early adopters are hitting the 6-12 month wall where initial productivity gains reverse into maintenance nightmares. Companies doubling down ("more AI!") vs sobering up ("we need senior reviews") are diverging paths.

Mitchell Hashimoto's warning: AI psychosis in companies

Hashimoto's full X post (May 16, 2026):

"I strongly believe there are entire companies right now under heavy AI psychosis and it's impossible to have rational conversations about it with them. I can't name any specific people because they include personal friends I deeply respect, but I worry about how this plays out."

Why Hashimoto's warning carries weight

Mitchell Hashimoto isn't an AI skeptic yelling at clouds. His credentials:

• Founded HashiCorp (Terraform, Vault, Nomad, Consul—infrastructure tools used by Fortune 500)
• Created Vagrant (standardized dev environments, 100M+ downloads)
• Currently building Ghostty (terminal emulator, from-scratch C systems programming)
• Deep systems expertise: Knows what maintainable infrastructure looks like at scale

When Hashimoto warns about companies unable to have rational conversations, he's describing organizations where:

1. Leadership mandates "AI-first" engineering without understanding technical debt accumulation
2. Questioning AI-generated code quality = career risk (seen as resisting progress)
3. Engineers know the code is brittle but can't convince leadership to slow down
4. Maintenance backlog grows faster than features ship (but only features are celebrated)

The cloud comparison: déjà vu

Hashimoto compares AI psychosis to early cloud adoption mistakes:

• 2008-2012 cloud rush: "Move everything to AWS immediately or die!"
• Quick fixes sacrificed reliability: Lift-and-shift migrations without architecture redesign
• Technical debt emerged later: Systems that worked in data centers failed in cloud (networking, state management, cost explosion)

AI coding parallel:

• 2024-2026 AI coding rush: "10× developer productivity or get left behind!"
• Quick prototypes sacrifice maintainability: Vibe-coded apps ship fast but collapse under load
• Technical debt emerges at 6-12 months: Nobody can debug, extend, or refactor AI-generated spaghetti code

Hashimoto's prediction: Companies in AI psychosis will hit a reckoning when maintenance costs exceed velocity gains. The question is whether they course-correct or double down.

Vibe coding fatigue: The 1-year reality check

LiveOverflow (security researcher, 100k+ YouTube subscribers) posted May 16, 2026:

"my brain after one year of vibe coding" [image of exhausted developer]

The post got 72 🔥 reactions because thousands of developers recognize the feeling. After 6-12 months of using Cursor, Claude Code, or Copilot to generate code via prompts, reality hits:

Symptoms of vibe coding fatigue

1. Codebase incomprehension

   • You wrote 10k lines this month but can't explain how authentication works
   • "The AI did it" becomes your answer to architecture questions
   • Onboarding new engineers is impossible ("just vibe code like me" isn't a strategy)

2. Debugging paralysis

   • AI-generated code breaks in production; you stare at it for hours
   • Can't fix bugs without prompting AI for patches (which introduce new bugs)
   • Stack Overflow can't help because your code doesn't follow standard patterns

3. Maintenance dread

   • Every feature request requires understanding AI-generated spaghetti first
   • Refactoring is terrifying (might break mysterious dependencies)
   • Technical debt compounds weekly; velocity slows to a crawl

4. Cognitive exhaustion

   • Constant judgment calls: "Is this AI code good enough to ship?"
   • Context switching between 10 AI-generated files, none of which you understand
   • Imposter syndrome: "I'm shipping fast but am I even a programmer anymore?"

Developer testimonials (from X thread)

Miguel Salinas (@Vercantez):

"Coming off of this psychosis and it's painful. Not shipping any more features until I can explain every part of our codebase in detail. Especially important to do before we open source."

Translation: Realized codebase is unmaintainable gibberish. Pausing features to rebuild understanding.

UI/UX Savior (@UiSavior):

"Designers before and after vibe coding.😎" [meme showing exhaustion]

Implication: Even designers (not just engineers) feel the burnout of rapid AI-driven iteration without quality checks.

Jeff Morris Jr.: 3 months of vibe coding can't build commercial apps

Jeff Morris Jr. (Chapter One VC, ex-Tinder VP Product) ran a 3-month experiment: build a mobile app using vibe coding (Cursor, Claude, natural language prompts). His conclusion (X, May 16, 2026):

"We've spent 3 months building a mobile app. My verdict is you cannot vibe code a commercial-grade mobile product today. Mass-market apps still need very talented full-stack mobile devs."

Why vibe coding fails for production mobile apps

What worked (prototyping):

• ✅ Shipped MVP in weeks instead of months
• ✅ Tested core user flows with real users quickly
• ✅ Validated product-market fit before hiring full team

What failed (commercial quality):

• ❌ Performance: AI-generated code doesn't optimize for 60fps UI, battery life, memory usage
• ❌ Security: Hard-coded API keys, insecure data storage, no authentication edge cases handled
• ❌ Scalability: Works for 100 users, crashes at 10k (no async/await, blocking operations, memory leaks)
• ❌ UX polish: AI can't design delightful micro-interactions, accessibility, or edge-case error states
• ❌ Platform-specific nuances: iOS vs Android differences require human expertise (SwiftUI vs Jetpack Compose)

Specific failures reported:

• Fintech apps: Need rigorous security audits, compliance (PCI-DSS), and error handling AI doesn't understand
• Healthcare apps: HIPAA compliance, data encryption, audit trails—AI generates insecure code
• Social apps: Real-time performance, content moderation, abuse prevention—too nuanced for AI

Jeff's advice:

• Use vibe coding for side projects, internal tools, prototypes
• Hire talented full-stack mobile devs for commercial apps
• Treat AI as co-pilot, not pilot (developers drive, AI assists)

What went wrong: The AI coding paradox

AI coding tools promised 10× developer productivity. Early adopters saw it: prototypes that took weeks now take days. But 6-12 months later, the productivity curve inverts:

Month 1-3: Honeymoon phase

• ✅ Shipping features 5-10× faster
• ✅ Prototypes impress stakeholders
• ✅ Developers feel like superheroes

Month 4-6: Cracks appear

• ⚠️ Debugging takes longer (can't understand AI code)
• ⚠️ Onboarding new engineers is hard (no docs, AI-generated spaghetti)
• ⚠️ Production bugs increase (AI doesn't handle edge cases)

Month 7-12: The reckoning

• ❌ Maintenance time exceeds feature time
• ❌ Rewrites become necessary (faster than fixing)
• ❌ Developer burnout (can't keep up cognitive load)
• ❌ Velocity crashes (was 10×, now 0.5×)

The paradox: Tools designed to make coding faster make maintaining code slower when used without discipline.

Root causes: Why AI psychosis happens

1. Misaligned incentives

Startups and VCs reward velocity:

• Ship fast → raise funding → hire more → ship faster
• AI coding agents enable this loop
• Technical debt is future team's problem

Result: Companies optimize for demo-able features, ignore maintainability

2. Junior developers skip fundamentals

Pre-AI learning path:

1. Learn language fundamentals (types, control flow, data structures)
2. Read others' code, understand patterns
3. Write code, get it reviewed, iterate
4. Eventually write maintainable code

AI-era shortcut:

1. Prompt AI to generate code
2. Code works (sometimes)
3. Ship it
4. ??? (never learn fundamentals)

Result: A generation of developers who can prompt but can't code without AI

3. Leadership doesn't understand technical debt

What execs see:

• "We shipped 10 features this month (used to be 2)!"
• "AI agents saved us $500k in engineering costs!"

What they don't see:

• Codebase is unmaintainable spaghetti
• Bugs take 10× longer to fix
• Best engineers are quitting (can't stand the mess)

Result: Doubling down on AI instead of course-correcting

4. AI yes-man problem

Humans push back:

• Senior engineer: "This architecture won't scale, let's redesign"
• Designer: "This UX flow is confusing"
• PM: "We need to solve X before Y"

AI agents say yes to everything:

• You: "Build feature Z"
• AI: "Sure!" [generates code]
• AI never says: "This is a bad idea, here's why"

Result: Unchecked bad decisions compound into system-wide failures

How to escape AI psychosis: Rational adoption

Based on Hashimoto's warning and developer testimonials, here's how to use AI coding without losing your mind:

1. Senior code review for all AI-generated code

Rule: Every AI-generated file gets reviewed by senior engineer who must explain the architecture.

Why this works:

• Catches security holes, performance issues, design flaws
• Forces reviewers to understand code (can't just "LGTM")
• Maintains institutional knowledge

Implementation:

• Tag AI-generated PRs clearly
• Require 2 approvals: (1) AI user, (2) Senior reviewer
• Reviewer checklist: "Can you explain how this works to a junior dev?"

2. Read core files weekly

Hashimoto's advice (paraphrased from similar contexts): Developers should regularly read core codebase files to maintain understanding.

Practice:

• Every Friday, pick 1-2 core files (auth, payments, data layer)
• Read them line-by-line, understand logic
• Refactor if needed, add comments, improve clarity

Why this prevents psychosis:

• Maintains "codebase literacy" (you can navigate without AI)
• Catches drift (AI-generated code deviating from patterns)
• Prevents "I have no idea what this does" syndrome

3. Log bugs with root cause, not AI patches

Anti-pattern:

• Bug discovered → prompt AI to fix → AI generates patch → ship
• Result: Band-aid over symptom, root cause lingers

Better approach:

• Bug discovered → investigate root cause → document why it happened
• Fix root cause (might require architecture change, not code patch)
• Write test to prevent regression

Example:

• ❌ Bug: "User logout sometimes fails" → AI patch: Add retry logic
• ✅ Bug: "User logout fails when session expired client-side" → Fix: Sync session state properly

4. 70% AI / 30% human rule

Balance:

• Use AI for 70% boilerplate (CRUD, UI components, tests, docs)
• Hand-code 30% critical logic (auth, payments, algorithms, security)

Why:

• AI excels at repetitive patterns (save time)
• Humans excel at nuanced decisions (security, edge cases, architecture)
• Hybrid approach maximizes both

5. Force architecture design before coding

Pre-AI: Design doc → peer review → code → review → ship

AI era shortcut: Prompt → code → ship (no design)

Rational approach:

• Design doc required for all features >500 LOC
• Explain: data model, API contracts, error handling, security
• Get peer review before prompting AI
• Use AI to implement approved design

Result: AI speeds up implementation, humans ensure soundness

When vibe coding works (and when it doesn't)

✅ Good use cases for vibe coding

1. Internal tools (used by <10 people, not mission-critical)

   • Example: Admin dashboards, analytics scripts, Slack bots
   • Low stakes: If it breaks, fix later

2. Prototypes (throw-away code for testing ideas)

   • Example: MVP to validate product-market fit
   • Expectation: Rewrite before production

3. Boilerplate (repetitive CRUD, API wrappers, tests)

   • Example: "Generate REST endpoints for User model"
   • AI good at patterns, humans review

4. Learning and exploration (experimenting with new tech)

   • Example: "Show me how to use WebSockets in Python"
   • Fastest way to get started, learn by modifying

❌ Bad use cases for vibe coding

1. Production apps at scale (fintech, healthcare, social, SaaS)

   • Requires security, performance, compliance expertise
   • AI generates insecure/slow code

2. Mission-critical systems (payments, auth, data pipelines)

   • One bug = financial loss, data breach, downtime
   • AI doesn't understand edge cases

3. Code you'll maintain for years (core platform logic)

   • Maintainability > velocity
   • AI-generated spaghetti is unmaintainable

4. Team onboarding (teaching juniors to code)

   • Juniors need to learn fundamentals
   • Vibe coding skips learning

Predictions: How this plays out in 2026-2027

Based on Hashimoto's warning and current trends:

1. AI psychosis companies hit the wall (2026 Q3-Q4)

• Startups that shipped fast with vibe coding face maintenance crisis
• Best engineers quit, new hires can't understand codebase
• Rewrites become necessary (lose all velocity gains)

2. "AI-assisted" becomes standard, "AI-first" fails (2027)

• Successful teams use AI for 70% boilerplate, humans for 30% critical
• Companies that fired senior engineers to "go AI" realize they need humans
• Hybrid approach wins

3. New role: AI code auditor (2027)

• Senior engineers specialize in reviewing, refactoring, explaining AI code
• Demand for this skill increases (can't just generate, must understand)
• Bootcamps teach "AI auditing" alongside coding

4. Tools evolve: AI that says "no" (2027-2028)

• Next-gen coding agents push back on bad ideas
• "This architecture won't scale" warnings
• "You need a senior engineer for this" handoffs

FAQ: AI psychosis and vibe coding

Q: Is Mitchell Hashimoto anti-AI? No. Hashimoto uses AI tools. His warning is about irrational adoption—companies losing ability to reason about trade-offs, not AI tools themselves being bad.

Q: Should I stop using Cursor / Claude Code / Copilot? No. Use them intelligently: boilerplate, learning, prototyping. But always review, test, and ensure you understand the code before shipping.

Q: How do I know if my company has AI psychosis? Warning signs: (1) Can't have rational conversations about AI limits, (2) Maintenance backlog growing but leadership celebrates velocity, (3) Engineers burned out but told to "use AI more," (4) Questioning AI code quality = career risk.

Q: What's the difference between AI psychosis and AI enthusiasm? Enthusiasm: "AI helps us ship faster, let's use it wisely with reviews and tests" Psychosis: "AI makes us 10× productive, anyone who questions it is a dinosaur, ship everything the AI generates"

Q: Will AI coding get better and solve these problems? AI will improve (better reasoning, fewer bugs). But fundamental problems remain: AI doesn't understand business context, can't make trade-off decisions, and won't push back on bad ideas. Human judgment always required.

Takeaway: Use AI, don't get used by it

Mitchell Hashimoto's warning isn't "don't use AI coding tools." It's "don't lose the ability to think critically about what you're building."

AI coding agents (Cursor, Claude Code, Copilot) are powerful tools. But like any tool, misuse creates problems:

• ✅ Use AI to go faster on boilerplate → win
• ❌ Ship AI code without understanding it → tech debt bomb
• ✅ Mix AI generation with human expertise → sustainable
• ❌ Fire seniors, go "AI-first" → maintenance crisis

Vibe coding fatigue is real. LiveOverflow's "my brain after one year" post resonates because thousands of developers are hitting the same wall. The solution isn't abandoning AI—it's using it with discipline.

Next step: Audit your last 10 PRs. How many AI-generated files can you fully explain? If <80%, you're accumulating debt. Fix now before maintenance crisis hits.

Related reading:

• Agentic fatigue and vibe coding paradox
• X algorithm open-source
• AI token costs surge

Sources:

• Mitchell Hashimoto X post (May 16, 2026): AI psychosis warning
• LiveOverflow X post (May 16, 2026): "my brain after one year of vibe coding"
• Jeff Morris Jr. X post (May 16, 2026): 3-month mobile app experiment
• Developer testimonials from X thread (987 posts, May 16, 2026)
• Grok AI summary: "Tech Leaders Warn of AI Psychosis in Software Development"