For the last two decades, the software industry has run on a simple bargain: instead of writing code yourself, you pull in someone else's library. Need to parse a date? There's a package for that. Need to left-pad a string? There's (famously) a package for that too. The tradeoff was always assumed to favor reuse — why reinvent the wheel when npm, PyPI, and Maven Central have millions of them ready to go?

Singla and Davis argue that bargain is quietly falling apart, and it's time to rethink how we source code from scratch.

Two forces are colliding. On one side, supply chain attacks have gotten brutal. Malicious packages, typosquatted names, compromised maintainer accounts, and injected backdoors (think SolarWinds, xz-utils, the endless parade of npm incidents) mean that every dependency you pull is a potential attacker foothold. Auditing thousands of transitive dependencies is effectively impossible for most teams.

On the other side, generative AI has crashed the cost of writing code yourself. That utility function you would have grabbed from a library? An LLM can now spit out a tailored version in seconds — one that does exactly what you need and nothing more.

The authors call their alternative use-case-oriented regeneration. The idea: instead of importing a general-purpose dependency with hundreds of features you'll never use (and hundreds of attack surfaces you didn't ask for), you describe the specific behavior you need and have an AI generate a narrow, purpose-built implementation that lives inside your own codebase. No external trust required. No transitive dependencies. No mystery maintainers.

The key insight is that the economic logic of dependencies has inverted. Reuse made sense when writing code was expensive and trust was cheap. Now writing code is cheap and trust is expensive. So the rational move flips: generate locally, own the code, review it once, and skip the supply chain entirely.

The paper isn't claiming every library disappears overnight — you're not going to regenerate PostgreSQL from a prompt. But for the vast middle layer of small utilities, glue code, and single-purpose helpers that dominates most dependency trees, regeneration could plausibly replace importation. It's a provocative reframing that treats the supply chain not as infrastructure to be secured, but as a category to be shrunk.