From general-developer
Big Design Up Front — identify over-designed, under-iterated code and architecture, and distinguish it from appropriate upfront planning.
How this skill is triggered — by the user, by Claude, or both
Slash command
/general-developer:bdufThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
**Big Design Up Front** is the anti-pattern of completing exhaustive design before any implementation — producing more design than the current state of knowledge warrants. The name is intentionally pejorative.
Big Design Up Front is the anti-pattern of completing exhaustive design before any implementation — producing more design than the current state of knowledge warrants. The name is intentionally pejorative.
BDUF manifests as: designing for hypothetical requirements, deferring feedback too long, and treating design as finished rather than evolving.
BDUF is not: appropriate upfront design for high-risk, high-cost-of-change areas. The goal is not to avoid design — it is to design at the right time with the right level of detail.
Design carefully before building when the cost of changing later is high:
| Area | Why design first |
|---|---|
| Database schema | Migrations are expensive; data transformations are risky |
| Public API contracts | Breaking changes affect external consumers |
| Security architecture | Retrofitting security is harder and riskier than building it in |
| Distributed service boundaries | Changing boundaries requires data migration and service refactoring |
| Regulatory / compliance requirements | Non-negotiable constraints that won't change |
For everything else — especially in uncertain domains — prefer iterative design.
These are the patterns to detect when auditing:
# ❌ BDUF: Plugin system, strategy pattern, and 5 extension points
# for a feature with one known implementation
class NotificationService:
def __init__(self, provider_registry, formatter_factory,
channel_router, retry_strategy, fallback_chain):
...
# ✅ Design for what exists now
class NotificationService:
def send(self, user, message): ...
# ❌ BDUF: 30 config options for a system with 2 known use cases
class UserPreferencesSystem:
# 50+ options, complex inheritance, multiple backends
pass
# ✅ Start with what users actually need
class UserPreferences:
def __init__(self):
self.preferences = {}
def set(self, key, value):
self.preferences[key] = value
def get(self, key, default=None):
return self.preferences.get(key, default)
# ❌ BDUF: Built a workflow engine when you needed two sequential steps
class WorkflowEngine:
def register_step(self, name, handler, conditions, rollback): ...
def define_transition(self, from_state, to_state, guard): ...
# ✅ Just the two steps
def process_order(order):
validate(order)
save(order)
# ❌ BDUF residue: Interfaces, base classes, and abstractions
# with exactly one implementation and no extension planned
class AbstractOrderProcessor(ABC):
@abstractmethod
def pre_process(self): ...
@abstractmethod
def validate(self): ...
@abstractmethod
def execute(self): ...
@abstractmethod
def post_process(self): ...
class ConcreteOrderProcessor(AbstractOrderProcessor):
# Only implementation; never extended
...
Too much BDUF:
Too little design:
✅ Decide upfront: ⏸ Let emerge during development:
- Layer boundaries - Specific class structures
- Data flow direction - Method signatures
- Technology choices - Internal algorithms
- Security approach - Helper utilities
High risk → design first: Low risk → design later:
- Security mechanisms - UI layout
- Public API contracts - Reporting logic
- Data models - Admin features
- External integrations - Internal tooling
When entering uncertain territory — a new integration, an unfamiliar domain — build a throwaway prototype first. Design after learning, not before.
| Scope | Time limit |
|---|---|
| System architecture | 1 day |
| Module / service design | 2 hours |
| Class / component design | 30 minutes |
If the time box runs out and uncertainty remains, build a spike.
Before investing in detailed design, ask:
npx claudepluginhub messeb/skills --plugin general-developerGuides scalable system architecture covering structure, coupling, boundaries, concurrency, observability, state management, and conventions during build phase.
Reviews software designs using deep modules, information hiding, and strategic vs tactical programming. Applies when discussing module design, API complexity, class depth, or abstraction tradeoffs.
Identify and avoid common architectural mistakes. Recognize patterns of failure. Use when reviewing designs or learning from mistakes.