Technology
Technical Debt Is Really a Social Problem Born from Learning by Doing
As AI speeds up software production, technical debt shifts from a technical fix to a sociotechnical challenge where teams must close the gap between code and collective understanding.
InfoQ
Technical debt doesn't necessarily signal incompetent engineering. In many cases, it reflects the deliberate cost of learning—releasing imperfect software to gather real-world feedback that shapes better design. Yet as AI tools accelerate code production beyond teams' capacity to comprehend it, this challenge is becoming fundamentally social rather than purely technical, Xin Yao argued at GOTO Copenhagen.
Debt as a Learning Strategy#
Ward Cunningham originally described technical debt as "not-quite-right code," but Yao reframed the concept as a calculated business move rather than a failure. Shipping software with known limitations—to test assumptions against actual user behavior and market conditions—can justify the cost:
If we release the code now, well knowing it's not perfect for the future yet, we'll get some business feedback, we'll get some user feedback, we'll probably get paid for something, and that's good as a business strategy.
The core insight is that software design necessarily begins with incomplete knowledge. Teams release code, observe its real-world impact, and then integrate what they've learned back into the system. Debt becomes a problem only when the software falls out of sync with evolved understanding—when yesterday's sound design becomes today's liability.
Framing Debt for Business and Architecture#
Debt provides a useful language for communicating with leadership: it translates architectural needs into economic terms, making the case for why postponing improvements has a cost. However, viewing debt solely as something to eliminate sidesteps its strategic role. The real question is whether the learning enabled by incurring debt justifies its expense, and whether teams actually repay it.
Kent Beck's work on earning and learning illustrates the tension: features deliver immediate value, while futures represent the flexibility to adapt those features later. Each line of code shipped reduces future optionality. When teams rely heavily on AI-driven feature production, they risk a scenario where all capacity goes toward servicing technical interest rather than building new capabilities.
Balancing feature delivery with architectural breathing room requires discipline. Sometimes delaying design decisions preserves options until teams have more information—a form of waiting that, as Beck notes, is holding an asset rather than procrastinating.

