Technical Debt is Not a Metaphor. It's Why Your Migration Failed.

Source: Dev.to

I recently went through Dave Farley’s guide on Managing Technical Debt. It’s a mandatory read because it treats debt strictly as a business risk, not just a developer complaint.

My Take on Farley’s Concepts

• Over the past two decades I’ve been fixing systems that “moved fast and broke things.”
• I’ve applied Farley’s ideas while battling legacy Java monoliths and migrating them to AWS.

Bit Rot

Farley talks about “Bit Rot”—the idea that software degrades over time. Code doesn’t physically rust, but neglect does.

The Kitchen Analogy

If you cook a five‑course meal but never wash a pan or wipe the counter, eventually you can’t cook anymore. You are paralyzed by the mess.

In practice, teams often:

• Lift‑and‑shift a Java application to AWS without refactoring or modularizing.
• Treat a simple JDK upgrade as “modernization.”

Result: A 15‑year‑old monolith runs on expensive EC2 instances, and every security patch risks breaking unrelated modules.

My rule: If you aren’t leaving the code better than you found it, it is already rotting.

Configuration Debt

In the Java world we learned to avoid spaghetti code; now I see “Spaghetti Infrastructure.”

• Security groups defined manually via the UI.
• Lambda triggers set up in the console, undocumented.
• Terraform state out of sync with reality.

This Configuration Debt can be worse than code debt because it can bring down an entire environment, not just a single feature.

If I catch a developer changing infrastructure settings manually in the AWS Console, we have a problem. Not because I’m a purist, but because that manual change is a ticking time bomb for the next person who runs the deployment pipeline.

AI‑Generated Code and High‑Speed Debt

Tools like Copilot or ChatGPT are incredible, but their impact depends on team discipline.

• Disciplined teams: Power tools that boost productivity.
• Undisciplined teams: High‑speed debt generators.

I’m seeing pull requests filled with AI‑generated boilerplate that the author clearly didn’t read closely.

• Does it work? Maybe.
• Is it efficient? Rarely.
• Does it handle edge cases? Never.

Remember: “Bit Rot” comes from neglect. Generating AI code without ruthlessly refactoring and testing accelerates neglect by 10×. You aren’t “coding faster”; you’re automating the creation of legacy code.

My Rule for AI Code

Treat AI‑generated code like code written by a drunk intern—review it twice as hard.

“We will write tests later.”
No, you won’t. I have never seen a team backfill unit tests after a feature ships.

Test Debt

Test debt kills velocity. Without a reliable, fast, automated test suite (not manual QA), teams become afraid to change code. Fear stalls refactoring, accelerating bit rot—a vicious cycle.

Practical Takeaways

• Technical debt is inevitable, but it must be a conscious choice (like a mortgage), not the result of incompetence (like gambling).
• Refactor constantly.
• Codify everything, especially infrastructure.
• Don’t let AI write code you don’t understand.
• Invest in automated testing to keep change velocity high.