AI Coding Should Reuse More Software

One of the stranger habits of AI coding tools is how quickly they try to build things from scratch. Ask for a feature that already has stable libraries, common framework patterns, or proven building blocks, and the model often starts handwriting a fresh implementation anyway. That looks productive in the moment because code appears fast, but it quietly moves the team in the wrong direction. More generated code means more behavior to review, more bugs to uncover, and more maintenance to absorb later.

This matters because software quality has never been measured by how many lines we can produce. In most engineering contexts, fewer moving parts are an advantage when those parts are well understood and well tested. If an existing library already solves audio recording, authentication, background jobs, validation, or persistence in a reliable way, replacing it with a large AI-generated custom version is usually not innovation. It is often just cost being converted into long-term system entropy.

The problem gets sharper in environments where auditability and compliance matter. In a regulated setting, a human still has to understand the change, justify the design, review the implementation, and stand behind the result. AI does not remove that accountability. It only changes the shape of the first draft. When the draft arrives as a wide custom implementation instead of a thin integration with trusted components, review becomes slower, risk becomes harder to reason about, and the promise of speed starts collapsing under governance work.

There is also a trust issue underneath all of this. Good software engineering has always depended on standing on top of shared foundations: frameworks, libraries, language constraints, testing tools, and patterns refined over time by many people. AI coding can tempt us away from that discipline because generating code feels cheaper than searching for the right dependency or learning the right abstraction. But trusted software is not valuable only because it saves time. It is valuable because somebody already spent the effort to make it stable, recognizable, and easier for others to maintain.

That same pressure is now visible in open source. Maintainers are increasingly exposed to pull requests full of AI-generated code from people who may not fully understand the project they are changing. The issue is not simply that the code came from a model. The issue is that the code often expands the maintenance burden without respecting the norms that made open source useful in the first place: earned trust, careful review, and contribution quality. If AI makes code cheaper to produce but more expensive to maintain, maintainers become the ones paying the hidden bill.

A better direction is to use AI as a system integrator instead of a code fountain. Ask it to find the right extension points in the framework, connect existing components cleanly, explain tradeoffs, draft tests, and adapt code to the project’s conventions. That is very different from asking it to reinvent everything. The best results tend to come when the project already has strong foundations and the model is forced to work within them, not when it is rewarded for inventing a new universe for every ticket.

This is also why quality expectations need to go up, not down. Many engineers can feel themselves accepting code they would not have written by hand, simply because the machine produced it quickly and it seems close enough. That is a dangerous habit. If AI lowers our threshold for custom code, duplicated logic, and awkward abstractions, then the productivity gain is partly an illusion. We are only moving the cost from implementation time into future debugging, refactoring, and operational risk.

The real opportunity in AI-assisted development is not to generate the maximum possible amount of software. It is to make better decisions about what should be generated at all. Teams that win with AI will probably be the ones that keep reusing proven software, keep human judgment close to the review loop, and keep generated code narrow enough to understand. In that model, AI still speeds things up, but it does so by strengthening engineering discipline rather than bypassing it.