Ask an AI coding tool for a function and it often hands back an interface, a plugin system, and three implementations you never requested. That gift is not free. It just hides its price until later.
The Details:
Writing speculative abstractions used to cost real time, which forced developers to justify the effort before building a plugin architecture nobody needed yet. AI removes that friction, so scaffolding for imagined future cases now arrives instantly and fully formed, trained on mature codebases where those patterns actually earned their place through years of real complexity.
Sophisticated-looking code is not the same as correct code for the moment. A clean set of composable abstractions reads as senior work while a short function with one conditional reads as junior work, but that aesthetic instinct is being applied before any evidence exists that generalization is warranted.
A concrete test cuts through the trap: can you name the second and third caller of this abstraction, specifically, not hypothetically. If not, the interface was designed in ignorance of the problem's real shape, and it will quietly block the changes you actually need once reality shows up.
The old rule of three still applies here: the first example never contains enough information to generalize safely, so abstracting from one instance is mostly decoration rather than a response to genuine signal. A useful habit is asking the tool to show the version without the abstraction and identifying which specific line gets worse. Often none does.
Bottom Line: Treat AI's first draft as something to argue with, not accept, because the elegant system it offers today is often the year-long workaround you'll be writing tomorrow.
Enjoy this article?
Listen to the Claude Code Conversations radio show or join the community.
