Spaghetti code: what it is, why it happens, and how to untangle a repo

Spaghetti isn't one flaw — it's several structural ones compounding. The ingredients are consistent: giant files and functions that do too many things at once; the same logic duplicated in several places so no single piece is the source of truth; deep nesting that buries the real behaviour under levels of conditionals; and no separation of concerns, so data, UI, and business logic tangle together instead of living in their own layers. Any one of these is manageable; together they produce code where every change risks breaking something unrelated.

The defining symptom is fear. In tangled code, you can't predict the blast radius of an edit — so changes get slower, more cautious, and more bug-prone, and the codebase calcifies. That's the real cost of spaghetti: not that it's ugly, but that it makes the code expensive and risky to change, which is the thing that actually slows a project down.

A coding agent optimises for the prompt in front of it: make this feature work. It doesn't hold the whole architecture in mind the way a maintainer does, so it takes the locally-fastest path — add to the existing file rather than split it, generate a fresh copy of a block rather than find and reuse the existing one, nest another condition rather than restructure. Each decision is individually reasonable and collectively produces tangle.

Our scan of 549 self-described vibe-coded repos shows the fingerprints: deep nesting in 53.6%, files past ~600 lines in 56.1%, cross-file duplication in 46.4%, and more than half carrying at least one duplication finding. None of it stops the app working — which is exactly why it accumulates. The app runs, the preview looks done, and the tangle only announces itself later, when a change that should take an hour takes a day.

You can't untangle what you can't see, and "this whole repo is a mess" isn't actionable. The first move is to measure: which files are oversized, which blocks are duplicated where, which functions are nested past the point of readability. clean·vibes does this from a GitHub link — a structure-and-size subscore, a duplication subscore, and a ranked list of the specific files and functions dragging them down, so "spaghetti" becomes a short list of concrete targets.

Then refactor the worst offenders in small, behaviour-preserving steps: extract a duplicated block into one function, split a giant file along its real seams, flatten the deepest nesting, and re-check after each so you're never guessing whether you made it better. clean·vibes gives each finding a ready-to-paste Claude prompt with a "smallest change, keep behaviour identical" constraint, so an AI tool can apply the untangling the same way it wrote the tangle — one reviewable diff at a time. Fix, re-scan, watch the structure score climb.