Descrição do Conteúdo / Informações:
-------------------------------------------------------------------------
There is an increasing trend on the internet stating that in the AI era, code longevity is "questionable if not problematic". The argument continues, "if AI can rewrite everything at 10x speed, why write long-lasting code at all?"

I believe that's an illusion. And I think it's mostly coming from people who don't maintain anything.



The Pitch Sounds Great If You Squint


The argument is appealing. AI rewrites happen quickly. Messy codebase. Why not just throw it all away and regenerate something cleaner when requirements change?

It's like freedom. It's the sensation of advancement. Nevertheless, it's also the engineering way to say "who cares about savings, just make more money".



Code Isn't Just Instructions


Here is what those who prefer "disposable code" overlook. An established codebase is not only a set of logical operations. It's a fossil record of every weird thing that went wrong.

That strange if statement on line 412? It was needed because during DST transitions, on Tuesdays, a null field is returned by one of our payment providers, still not sure why, nobody wrote that down.

Critics of the disposable mindset keep pointing out the same thing: rewritten systems lose implicit knowledge and edge-case handling. Because each rewrite causes some memory loss. Every rewrite is an amnesia event.

→ Edge cases don't live in tickets. They live in code.

→ Institutional knowledge isn't in someone's head. It's in the diff history.

→ "Just rewrite it" assumes you know what the old code was actually doing. You usually don't.



"10x Speed" Doesn't Mean 10x Understanding


For the sake of argument, let's say AI can rewrite your service in a tenth of the time. Neat. But can it also re-architect the context? Re-create the trade-offs discussion your team had about using eventual consistency instead of strong consistency for that one specific workflow? Redo the three-month-long incident retrospective you iterated on and embedded in your retry logic?

Speed of production is not speed of comprehension. I can generate a thousand lines of code in minutes. Understanding a thousand lines of someone else's code still takes hours. AI doesn't change that ratio as much as people want to believe.

Typing was never the problem. It was about figuring out what to type in the first place. 🎯



Disposable Code Means Disposable Everything


This is what truly bothers me. Considering code as something that can be thrown away works only when you also consider your users, your uptime, and your institutional knowledge as something that can be thrown away as well.

Every rewrite is a risk window. Every risk window is a chance for regressions. Every regression is a user who trusted you and got burned.

If you're building a weekend project, sure, throw it away. You can rewrite it whenever a new model is released. No one will mind.

However, if you manage a product that is essential for people? If you are part of an on-call schedule? If customers are paying you and they expect your product to be functional even at 2 AM during a holiday? The "just rewrite it" philosophy is a luxury you cannot afford.

→ Rewrites don't eliminate tech debt. They reset the clock on discovering it.

→ Uptime isn't a feature. It's a promise. Disposable code breaks promises.

→ Users don't care how your code was generated. They care that it works. Every single time.



Who Actually Benefits?


I keep asking myself: who does the "code is disposable" narrative serve? Not the engineer who gets paged when the rewrite drops a critical edge case. Not the team who has to give up months of accumulated knowledge. Certainly not the users.

It serves people selling the idea that AI makes everything trivially replaceable. It benefits those who only showcase their work and never implement it in real scenarios. It serves people who start projects but don't maintain them. 🔥

Maintenance is the reality of a software product. And "disposable code" is a philosophy that only survives in the absence of maintenance.



The Actual Move


Write code that a human can understand and maintain, but also leverage AI to assist in code generation. Use AI to enhance the durability and maintenance of your software systems, not as an excuse for rebuilding everything from scratch every few months.

Durability isn't the opposite of agility. It's what makes agility sustainable.

The disposable code narrative isn't engineering wisdom. It's a psyop by people who never had to keep the lights on. on a Saturday morning.

What's the oldest piece of code in your codebase that everyone's afraid to touch — and what implicit knowledge would you lose if you rewrote it?