Cursor, Claude Code and Codex all have a BIG problem

Too Long; Didn't Watch — Summary

Modern AI dev tools are becoming buggy 'slop fests' because they were built using early, imperfect AI models, creating a cycle of technical debt that requires aggressive 'sledgehammer' refactoring and stricter architectural discipline to fix.

Main Takeaways

• The Dogfooding Trap: Tools like Cursor and Claude Code were built using early AI models (like Sonnet 3.5/3.7), leading to inconsistent, non-deterministic, and buggy user experiences.
• Codebase Inertia: A codebase's quality typically peaks at the 6-month mark; if it is built on 'vibe-coded' slop initially, it is nearly impossible to fix later without a total rewrite.
• Exponential Slop: Bad code patterns multiply exponentially because they are easy for agents to copy, while good patterns only grow linearly.
• Sledgehammer Development: The cost of rewriting code has dropped so significantly that it is often better to delete thousands of lines and start over than to attempt to fix broken AI-generated logic.
• Parallel Codebases: A future development pattern may involve maintaining a 'slop' version for rapid prototyping and a separate, polished version for production.

Detailed Summary

The Problem with Modern AI Tools (0:00 - 4:19)

AI development tools are currently suffering from a lack of craftsmanship compared to older tools like Sublime Text. The core issue is that these tools were built using the very AI models they provide, which sounds like good 'dogfooding' but has actually introduced significant instability. While writing a C compiler in C is beneficial, writing an AI tool with non-deterministic AI models has led to 'slop'—code that is inconsistent and poorly structured.

The Cursor and Claude Code 'Crash Out' (4:19 - 11:13)

Cursor and Claude Code are specifically criticized for deteriorating UX.

• Cursor: The removal of the agent/editor toggle in favor of 'customization' led to broken layouts and frequent UI shifts. A specific grievance is the 'one-click email leak' button in the editor.
• Claude Code: Despite being a CLI, it is more buggy than traditional IDEs. It suffers from race conditions (e.g., submitting messages before image compression finishes) and input lag that makes it feel 'non-serious.'

Codebase Inertia and the 6-Month Rule (11:13 - 18:16)

Every codebase hits a quality plateau. The quality of a codebase at the 6-month mark is generally the best it will ever be. If a project is 'vibe-coded' (letting agents do their thing without strict steering) during this period, the resulting technical debt becomes permanent. Claude Code is cited as a prime example of a project that felt great for the first six months but has since entered a downward trend of performance issues and RAM bloat.

How Slop Multiplies (18:16 - 22:00)

Agents accelerate the spread of bad patterns. Because agents reference the existing codebase for context, they will happily copy a 'smelly' pattern if it already exists. In a growing codebase, bad patterns expand exponentially because they are often the most 'convenient' to find and replicate. No model can be better than the code it starts with; if the foundation is garbage, the output will be garbage.

Strategies for Maintenance: Sledgehammers and Planning (22:00 - 30:11)

To combat AI-driven slop, engineers must adopt a 'no tolerance' policy for bad code.

• Sledgehammer Style: If a feature smells, delete it entirely. AI has made the cost of replacing 5,000 lines of code negligible.
• Plan Mode: Spend significantly more time in the 'planning' phase with models. Reviewing a markdown plan is more effective than reviewing thousands of lines of generated code.
• Latest Models: Always use the most recent models (e.g., Opus 4.5 or Codex 5.3), as they are better at following complex instructions and avoiding old pitfalls.

Architectural Discipline and the 'Twitch' Lesson (30:11 - 37:27)

Using a personal anecdote from Twitch regarding the 'Artifact incident,' the importance of keeping unrelated features out of a core codebase is highlighted. In the past, developers stuffed features into one repo to avoid deployment friction. Today, AI makes it trivial to spin up new services. Developers should 10x the number of codebases they maintain to keep core projects clean and modular.

The Future: Parallel Versions and Vampire Survivors (37:27 - 44:05)

The game Vampire Survivors provides a model for the future: the creator prototypes in a 'slop' version (Phaser.js) and a team ports successful features to a 'real' version (C++). This 'file twice, merge once' approach allows for high-speed experimentation without ruining the production codebase. Engineering skills are not becoming obsolete; rather, they are being pushed to new limits to manage these complex, agent-driven ecosystems.

Notable Quotes

"The fact that all of these tools were written with these models is not an advantage. In many ways, it's a disadvantage." — Theo

"Later is another word for never in the software development world." — Theo

"I would argue the average human is a worse engineer than the average model at this point... but they all make mistakes." — Theo

"Incentivize new project creation instead of old project sloppification." — Theo