code-architecture-wrong-abstraction

Prevent premature abstraction by enforcing the Rule of Three: duplicate code first and only refactor to abstract it once the pattern appears in three or more distinct places. This avoids wrong abstractions and reduces maintenance pain.

You should duplicate code instead of applying DRY when patterns have not yet stabilized. Duplication is cheaper to fix than a wrong abstraction, so waiting until clear criteria are met prevents over-engineering and design inefficiencies.

The Rule of Three is a refactoring principle stating you should not abstract code until it has been duplicated in at least three places. This ensures patterns are proven before introducing generalized abstractions.

Fix a wrong abstraction by identifying shared interfaces that create confusion, then refactoring them based on proven patterns. Apply strategies like introducing a facade or reverting to duplication until the actual design patterns stabilize.

You should not use design patterns when code only appears in one or two places. Applying patterns prematurely creates over-engineering and maintenance pain; wait until clear criteria and stable patterns emerge naturally.

Yes, a facade is appropriate to resolve design inefficiencies when you need to simplify complex wrong abstractions. It provides a cleaner interface while you evaluate whether underlying patterns are stable enough for deeper refactoring.