Where Things Go Wrong

Every post about AI coding tools tells you how great they are. This one tells you where they break.

After 338 sessions, I've accumulated a detailed friction log. Not theoretical concerns — actual things that went wrong, cost time, and sometimes killed entire sessions. Here's the unfiltered version.

Buggy Code Shipped Without Adequate Verification

Claude frequently delivers code with runtime bugs that only surface when I test or deploy, forcing me into multiple fix cycles. I could ask Claude to run builds, write quick smoke tests, or verify its own changes more thoroughly before declaring a task done.

Excessive Planning and Exploration Without Producing Output

In multiple sessions, Claude spent the entire available time reading files and writing plans without generating any actual code, forcing me to interrupt. I could front-load context in my prompt (e.g., specifying key files and desired architecture) and explicitly instruct Claude to skip extended planning and start implementing immediately.

Git and Deployment Workflow Missteps

Claude makes errors in git operations and deployment steps — pushing to wrong branches, failing to push changes, and struggling with environment configuration — which derails my shipping flow. I could establish explicit workflow instructions (e.g., always push to main after merge, always verify target branch) in my CLAUDE.md or session prompts.

Buggy Code Shipped Without Adequate Self-Testing

Claude frequently delivers implementations with bugs that I end up catching in production or during testing, rather than Claude catching them itself. I could mitigate this by asking Claude to run builds, lint checks, or write quick smoke tests before declaring a task complete.

Excessive Planning Without Producing Output

Claude sometimes enters extended exploration and planning loops — reading files and writing plans for 8+ minutes — without generating any actual code, forcing me to interrupt. I could address this by setting explicit time or step limits in my prompts (e.g., 'skip planning, just build it') or breaking tasks into smaller implementation-first chunks.

Misunderstood Scope or Overclaimed Completion

Claude sometimes misinterprets the boundaries of my request — placing content in the wrong location, overclaiming what's been accomplished, or building something that doesn't match my actual intent. I could reduce this by front-loading explicit acceptance criteria or asking Claude to confirm its understanding before executing.

Over-Scoping and Unsolicited Expansion

Claude frequently escalates simple requests into full-blown architecture plans, file creation sprees, or comprehensive restructuring efforts, forcing me to interrupt and redirect. I could mitigate this by being explicit about scope boundaries upfront (e.g., 'just do X, don't plan anything else') or by adding instructions to my CLAUDE.md that say 'ask before expanding scope.'

Wrong Assumptions About Data and Codebase

Claude sometimes builds entire implementations based on incorrect assumptions about my data formats, file structures, or project state — resulting in wasted effort and full reverts. I could reduce this by pointing Claude to the specific files or formats it should reference before it starts coding, or by asking it to verify its assumptions before implementing.

Excessive Planning Instead of Executing

In multiple sessions, Claude got stuck in exploration and planning loops — reading files, drafting plans, and structuring approaches — without producing actual output before I ran out of patience and interrupted. I could address this by adding a CLAUDE.md instruction like 'bias toward implementation over planning' or by explicitly telling Claude to skip planning and start building.

The Honest Numbers

53buggy code incidents 47wrong approaches

These aren't edge cases. Across 338 sessions and 256 commits, roughly 1 in 4 sessions hit meaningful friction. The productive output still far outweighs the cost — but pretending friction doesn't exist makes you worse at managing it.

What I've Learned About Managing Friction

The single biggest improvement: make Claude verify its own work before declaring done. Adding npx tsc --noEmit after every implementation pass catches the majority of shipped bugs. It's a 5-second check that saves 15-minute debugging cycles.

The second biggest improvement: interrupt early when Claude starts over-planning. If Claude is reading files and writing plans after 2 minutes without producing code, it's stuck. Kill it, restate the goal more concretely, and tell it to start implementing immediately.