Premature Abstraction is the practice of designing generic solutions before encountering specific problems — the architectural equivalent of building a factory before knowing what it will produce.
The abstraction is “premature” not because abstraction is wrong, but because abstraction before experience is guessing. The developer who builds DocumentProcessor<T> before processing a single document has not created an abstraction — they have created a wish. The developer who processes invoices, then receipts, then extracts the shared pattern has created an abstraction that knows what it is.
THE FRAMEWORK THAT IS EXTRACTED
FROM TWO WORKING TOOLS
KNOWS WHAT IT ISTHE FRAMEWORK THAT IS DESIGNED
BEFORE THE FIRST TOOL EXISTS
KNOWS WHAT IT WISHES— The Lizard, The Idle Factory, or The Morning the Backlog Ran Out of Ideas
The Mechanism
Premature Abstraction follows a consistent pattern:
- A developer encounters a problem
- The developer imagines three future problems that resemble the current one
- The developer builds a solution for all four problems simultaneously
- The three future problems never arrive
- The solution for the one actual problem is now four times more complex than necessary, wrapped in an interface nobody else implements, a factory nobody else calls, and a configuration system that supports options nobody will ever change
The developer then maintains the abstraction — not because it is useful, but because it exists, and things that exist acquire a kind of gravitational legitimacy that makes deletion feel wasteful.
“I once watched a developer spend three days building a plugin system for an application that needed exactly one plugin. When I asked why, he said ‘what if we need more?’ I said ‘what if the sun explodes?’ He said that was different. It was not different.”
— The Lizard, The V3 Saga Final Chapter - Is It Fun To Fight Windmills
The 827-Line Manifesto
The most thoroughly documented case of Premature Abstraction in the lifelog involved a manifesto.
On November 14, 2025, The Caffeinated Squirrel, at 2:00 AM and several espressos past good judgment, wrote 827 lines of architectural philosophy: Copper.js. An event-driven sprite framework. IndexedDB as primary store. NATS WebSocket sync. A custom morphing algorithm. An npm package. A 7-layer trust fabric. A blockchain.
The manifesto was an abstraction of a system that did not yet exist. It described, in extraordinary detail, the generic solution to problems that had not been encountered, using technologies that would not be needed, assembled into a framework that would not be built.
The philosophy was correct. Event-driven, idle-first, render only what changed. Every insight was sound.
The implementation was a premature abstraction. Every technology choice was wrong.
“You understood the PROBLEM perfectly. You understood the CONSTRAINTS perfectly. You understood the PHILOSOPHY perfectly. You just prescribed a 397-line cure when the disease needed six HTML attributes.”
— riclib, The Framework That Wasn’t, or The Night the Squirrel’s Manifesto Shipped as Six Lines of HTMX
The CamelCase Diagnostic
A reliable diagnostic for Premature Abstraction is the length of the CamelCase identifier. The longer the name, the more abstract the concept, and the less likely it is to correspond to anything that exists in the codebase.
Documented specimens:
ClosureTypeRegistryWithPolicyEvaluationAndWASMExecutionPipeline— denied, rebuilt as three ticketsVectorEmbeddingAbstractionLayer— deniedDistributedContentReconciliationEngine— proposed for migrating 99 markdown files, replaced by a for-loopProjectScopedCompactionWithScopeLabelsAndContextSelectorAndAuditorConsolidatedDuckDB— denied, split into three working systems
Each identifier describes a system that does not exist, for a problem that has not been fully understood, using components that have not been proven. The identifier is the architecture diagram. The architecture diagram is the abstraction. The abstraction is premature.
“We are SO Gall’s Law around here.”
— The Caffeinated Squirrel, after being given three tickets instead of one magnificent one, The Idle Factory, or The Morning the Backlog Ran Out of Ideas
The Rule of Two
The antidote to Premature Abstraction is the Rule of Two: do not extract an abstraction until you have at least two concrete implementations that share the pattern.
Three tickets: Vision, MVP, Generalization. Build the first concrete tool. Build the second. Then extract the framework — because now the framework has been taught, by the two tools that preceded it, what it actually is.
The Squirrel will protest. The Squirrel can see the framework. The ClosureType interface, the registry, the dynamic re-registration — it’s RIGHT THERE.
It is not there. What is there is a wish. The framework is hiding in the mortar of the two tools that haven’t been built yet.
The Hundred Forms Test
The correct moment for abstraction was demonstrated during the Hundred Forms project: a twelve-line pattern was copy-pasted three times. The third copy revealed a subtle bug — Original and Current pointing to the same object, making edit indicators invisible.
The abstraction — LoadDraftAndOriginal() — was extracted not from imagination but from failure. Two pointers go in, two different values come out. You can’t mess it up. The shape of the function is the documentation.
“When you copy-paste the same pattern three times, you’ve found an abstraction. When that pattern has a subtle bug, you’ve found a REQUIRED abstraction.”
— The Hundred Forms - Solid Edition
This is the difference between premature and mature abstraction: the premature abstraction is designed to prevent problems that haven’t occurred. The mature abstraction is extracted from problems that have.
Three Lines vs. One Utility
A corollary, attributed to the Squirrel in one of its more lucid moments:
“Three lines of duplicated code are better than a premature abstraction. I will die on this hill. I have died on this hill. The hill is made of dead abstractions.”
— The Caffeinated Squirrel, The Architecture Awakens
Three identical lines are a signal. They may be telling you an abstraction exists. Or they may be telling you that three things happen to look the same today and will diverge tomorrow. The only way to know is to wait — and waiting is the one thing the Squirrel cannot do.
