Skip to content
Why Reuse Can Be Evil in System Design: Autonomy Over Reusability
Fundamentals 9 min read

Why Reuse Can Be Evil in System Design: Autonomy Over Reusability

This article argues that pursuing reuse as a primary goal in system design often backfires, increasing coupling and maintenance burden; it advocates prioritizing module autonomy over forced reuse, using autonomy and consistency metrics to evaluate design decisions, and warns against over-generalization like excessive microservices or shared business platforms.

Architect's Guide
Architect's Guide
Architect's Guide

In system design and development, the term "reuse" is frequently invoked to justify abstracting classes, functions, UI components, fine-grained microservices, shared business platforms, functional organizational silos, and product features. The perceived benefits are reduced personal effort and higher individual productivity, reinforced by education around the DRY principle, books like Design Patterns: Elements of Reusable Object-Oriented Software , and the habit of using inheritance for reuse in object-oriented languages.

The Flawed Logic Behind Reuse-Driven Efficiency

The typical reasoning chain assumes:

Writing a system requires a large amount of code.

Reusing existing code reduces the amount of new code.

More reuse means less code written.

Less code means faster delivery.

This logic rests on two hidden fallacies:

All code takes the same time to write.

Writing code is the dominant work in delivering a system.

Why Reuse Often Increases Cost

When a module depends on many "reusable" modules, developers must understand each module's interfaces; documentation is often insufficient. If an interface doesn't fit the use case, the team must choose between awkward adaptation and coordination overhead with the module owners. The article notes that most people lack clear criteria for extracting a common business module, turning the platform team into an internal outsourcing bottleneck that lowers overall efficiency.

Moreover, anyone who maintains production systems knows coding is only a small, high-certainty step; ongoing debugging, deployment, and re-debugging consume the most time. A module with many dependents makes these operations significantly harder than a module with few dependents.

Standard Libraries vs. Business-Specific Reuse

Using programming languages (Java, Go), frameworks, and algorithm libraries is unproblematic because they are built on consensus and standards — they are sufficiently "general" and not tailored to a specific business or company. Consensus and standards must precede reuse ; ad-hoc reuse without them is harmful.

The Trap of Over-Generalization

Designing systems to be maximally generic (e.g., splitting into many CRUD microservices) to enable reuse does not yield Lego-like composability. Instead, forced reuse resembles organ transplantation : constant rejection reactions reduce speed and stability. Many startups' system decay during rapid growth stems from forced reuse. Common anti-patterns include:

Tables with hundreds of fields (e.g., order tables) where it's unclear which fields apply in which scenario.

Noun-driven design creating platforms like "order platform" or "e-commerce platform," leading to endless cross-department disputes.

Proliferation of tiny microservices orchestrated by a central gateway/DSL layer, requiring N-module deployments, creating a single point of failure, and hurting both stability and iteration velocity.

"Use a good idea again instead of generalizing it. A specialized implementation of the idea may be much more effective than a general one." — Hints for Computer System Design

Evaluating Design: Autonomy and Consistency

Two primary metrics with priority:

Autonomy : Degree to which a module is insulated from changes in other modules; measured by interface stability. Can be quantified via AutonomyMetrics ( https://autonomy.design/Part1/AutonomyMetrics.html).

Consistency : Degree to which a single module is used wherever that capability is needed; also indicates premature or excessive abstraction. Can be quantified via ConsistencyMetrics ( https://autonomy.design/Part1/ConsistencyMetrics.html).

At the business level, extract a shared module only if the common logic across multiple business modules must change together . If they don't need to change in lockstep, do not abstract.

When torn between consistency (shared module) and autonomy (independent modules), always prefer autonomy .

Summary

Core system complexity rarely disappears; it only shifts. Division of labor is necessary, but:

Don't generalize arbitrarily for reuse. Reuse is not a goal. If you generalize, validate with ConsistencyMetrics.

Don't reuse other modules casually. Autonomy first; measure with AutonomyMetrics. Reuse only when consensus and standards exist; otherwise, don't reuse.

References:

https://autonomy.design/Part1/AutonomyMetrics.html
https://autonomy.design/Part1/ConsistencyMetrics.html
https://zhuanlan.zhihu.com/p/356202989
https://udidahan.com/2009/06/07/the-fallacy-of-reuse/
https://zhuanlan.zhihu.com/p/138145081
https://zhuanlan.zhihu.com/p/410049005
Original Source

Signed-in readers can open the original source through BestHub's protected redirect.

Sign in to view source
Republication Notice

This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactadmin@besthub.devand we will review it promptly.

software architecturemicroservicessystem designmaintenanceDRY principleconsistencyreusecouplingbusiness platformautonomy
Reader feedback

How this landed with the community

Sign in to like

Rate this article

Was this worth your time?

Sign in to rate
Discussion

0 Comments

Thoughtful readers leave field notes, pushback, and hard-won operational detail here.