AI coding assistants love to solve problems immediately. Ask "how should I build a real-time notification system?" and watch it churn out WebSocket code within seconds. But what if WebSockets are wrong for your use case? What if Server-Sent Events would be simpler? The Big Decision framework forces the AI to slow down, ask questions, and present options before committing to an architectural path.
How to Use This Template
Copy the markdown below and fill in the bracketed [ ] information. Paste this into your AI assistant when facing any non-trivial architectural decision.
## Big Decision Architectural Framework
### THE CHALLENGE
**Goal:** `[Describe what you are trying to achieve, e.g., "Design a real-time data processing system for global IoT devices"]`
**Context:**
- Current system: `[Brief description of existing architecture]`
- Team expertise: `[Languages, frameworks team is comfortable with]`
- Timeline: `[Any deadline constraints]`
- Scale requirements: `[Expected users, data volume, requests per second]`
### INTERACTION PROTOCOL
**STOP.** Do NOT generate code or propose a solution yet.
**Phase 1: Clarifying Questions**
Before proposing any architecture, ask me questions to understand:
1. Performance requirements: `[latency, throughput, availability]`
2. Budget constraints: `[infrastructure costs, licensing]`
3. Compliance needs: `[GDPR, SOC2, industry-specific]`
4. Team constraints: `[learning curve tolerance, hiring plans]`
5. Future considerations: `[expected growth, feature roadmap]`
Wait for my answers before proceeding.
**Phase 2: Architectural Options**
Present 2-3 viable approaches:
**Option A: `[Approach Name]`**
- Description: `[How it works]`
- Pros: `[Advantages]`
- Cons: `[Disadvantages]`
- Best for: `[When this option shines]`
**Option B: `[Approach Name]`**
- Description: `[How it works]`
- Pros: `[Advantages]`
- Cons: `[Disadvantages]`
- Best for: `[When this option shines]`
**Option C: `[Approach Name]`** (if applicable)
- Description: `[How it works]`
- Pros: `[Advantages]`
- Cons: `[Disadvantages]`
- Best for: `[When this option shines]`
**Phase 3: Recommendation**
Based on my answers, recommend ONE option with:
- Why this option fits my context
- What tradeoffs I am accepting
- What I should prototype first to validate
**Phase 4: Implementation Plan**
Only after I confirm the chosen path, provide:
- Step-by-step implementation phases
- Key dependencies to add
- Configuration decisions I need to make
- Monitoring and observability to include
Why This Template Works
of project failures attributed to poor requirements and premature architectural decisions that prove costly to reverse.
-
Forced dialogue: The strict instruction to ask questions first prevents the AI from committing to solutions based on incomplete understanding of your actual constraints.
-
Multiple options presented: By requiring 2-3 viable approaches, you see the architectural landscape rather than the AI's first guess.
-
Explicit confirmation gates: The template creates checkpoints where you must confirm direction before implementation begins, preventing costly mid-stream pivots.
Research-Backed Best Practices
The temptation with AI assistants is to treat them like search engines: ask a question, get an answer, move on. But architectural decisions are not search queries. They are commitments that echo through your codebase for years.
What makes senior engineers senior is not their ability to produce solutions quickly. It is their ability to ask the right questions before committing to any solution at all. This template encodes that discipline into your AI interactions. You know what happens when you skip the questions phase? You get a solution that works for a generic use case, not your specific constraints. Six months later, you are refactoring because the "obvious" choice was wrong for your scale, budget, or team skills.
The Faster Way
Working through Big Decision templates for every architectural question takes discipline. 4ge bakes this approach into your planning workflow. When you map out a feature, 4ge automatically surfaces the clarifying questions you need to answer, presents architectural options based on your existing tech stack, and generates implementation plans only after you confirm the direction. No more premature commits to the wrong architecture.