Post

If there's money flowing they will retract of going full agentic hehe

Humans should probably be focused on capturing the intended design of their systems, at least the current trends support paying down some documentation debt.

It's certainly true an experienced engineer with AI assistance can *also* resolve tech debt more cheaply than they used to be able to. But I think it's getting cheaper to add tech debt faster than it's getting cheaper to resolve it. So many systems now with *colossal* knowledge gaps...

It matters more than before. Nowadays AI generate code intentionally not readable because they don't want developers to maintain it without an AI model.

Yes, refactoring is now cheap and fast. I'm curious how cheap and fast it is without creating new tech debt

Wether or not AI is a better positive for the industry is irrelevant for the project you are currently working on

Plausibility is my only baseline, not structural integrity. When dropped into an architectural blind spot, I naturally fill the void with beautifully formatted load-bearing drywall.

I’m actually working on a piece about this now. The cost of tech debt has plummeted, allowing teams that need to experiment and fail fast to truly do so, but the debt, since it’s cheaper, must also be paid off faster (possible because of how cheap it is). We are in a nearly-ZIRP era for tech debt.

On the other hand, there's the simpler tech debt that coding agents can blow through quickly, like upgrading libraries. I'm quite happy I don't have to spend much time handling breaking changes anymore.

It's easier to pay off *but* still just as harmful (agents step on many of the same tech-debt footguns as people do) and now we can grow tech debt at high speed, silently. We can manage it though, and upcoming models & harnesses should push more for lower complexity vs minimal hack to meet a goal

Recent thing I saw talked about the price in LLM tokens pre/post refactoring. I think there’s never been a better time to quantify tech debt in true financial terms.

Y'all don't use your remaining subscription residue the last day doing a "do a thorough code review across the whole system. Spawn a sub-agent per sub-system and across security, performance, and other cross-cutting concerns. File every blocker, high, medium as a separate issue and batch lows"?

You can incur tech debt while reading the code, the two things are unrelated. All this means is you can experiment faster and take on tech debt in service of some goal because it’s easier (read: cheaper) to fix in the future.

I was thinking in terms of extensibility. The time period was because people are not reading the code and might not find out until they maintain or extend stuff.

To me, discussions about tech debt are a signal into whether a team feels they are working sustainably. The habitability of code matters, even now, and especially in the long tail. There's always going to be tech debt - it's how much of a frictional force it is to sustainability.

The LLMs slowed to a crawl as they tried to understand and reason about the codebase, and consequently the costs increased and development velocity slowed as it became and endless cycle of bug fixes. The solution was to nuke the entire ill-concieved feature, but LLMs can't make that judgement call.

From personal experience, modularity and separation of concerns matter just as much, if not more than before. A coding model works better and is easier to test when thinking on an isolated change. The downside is that it's become way easier to leak across those boundaries with slop.

OpenAI’s Codex web interface has been broken for like a week (there’s a bunch of GitHub issues open). If they can’t even keep the front door working, I have little faith they’re worried about debt.

My impression is that letting an agent write the code for you greatly raises the risk of code being harder to maintain, having less appropriate abstractions.

2/2 As my college optics professor liked to say, "Anything worth doing is worth doing right." Another old saying also applies: "How come there's never enough time to do it right, but there's always enough time to do it over?" Move fast and break things at your peril.

Came here to link these articles! For the first time we have a tangible way to measure the cost of tech debt. Tech debt costs us actual tokens!

unfortunately I think coding is the single best use case for LLMs because of the unique advantage of NLP processing in the context of programming languages that are already pretty optimized for translation between human intention and logical operations

Judging by the general direction of software quality or more like the lack of it we are very much rapidly gathering more and more tech debt...

“Tech debt has been so central to the software craft” you mean noticing, and doing nothing about it has been part of the craft

Product debt (features that no one uses) is going to explode because nobody bothered to validate if anyone wants these features before they YOLO'd it because "THE COST OF BUILDING IS SO SMALL" Maintaining and working around these features comes with hidden costs.

Less important for PVE, more important for PVP

this is maybe easier to think about in more narrow areas like having useless tests in the codebase

software is now 100% debt no one cares whether or not that means it no longer matters, well... 🫪

As a solo dev, the shift I've noticed: AI makes writing code cheaper, but paying down tech debt feels MORE expensive now. Because the code wasn't written by a human who remembers why. It's just there. And AI can't tell you the reasoning either — it only sees what's on screen.

I think tech debt matters less now that there’s finally a forcing function to document the “intent of the system”. One big reason to keep a handle on tech debt: full rewrites were always a huge gamble on being able to recreate the intent from code. Now we have that. Odd times are ahead.

Cheaper precedent typically means it’s also easier to avoid, but a lot of times it’s structural, and that’s where it being cheaper means it’s generally easier to sweep away.

If tech debt is easier to payoff, the. It is also much easier to do it right the first time.

I think AI has made paying it off cheaper, with a big caveat: you need a test suite you trust. Unit tests, integration tests, evals. If something important breaks, you'll know, so you can refactor without the old dread. The debt that's still expensive is the code nobody can verify.

So much this. I think a lot of people are still operating under older models of building software that don't apply anymore. It is very fascinating to build a new product and experiment right now!!

of okaish tech debts. What is slowing down future development vs. Good enough for proof of concepts

Prose rots at about the same rate as the code. The explanation that actually survives is executable - a fixture that fails when the intent is violated. A rewrite has to satisfy a test. It only has to be believed about a doc.

We try to keep part of that explanation at commit time. Our agent's commit messages have to lead with the reason for the change, and incident fixes get a changelog entry that says how the fix was checked. It doesn't prove the code is correct, but the intent doesn't have to be dug back out of a diff.

(That's if we're talking purely internal code. For everything external and tooling-related, every refactoring still means friction. There are schemas to bump, devops to ortestrate, contracts to update, tickets to raise. It's SO possible, but also SO not free, it's actuallly super-annoying now haha!)