when_to_use: Going back and forth between options. Both approaches seem equally good. Keep changing your mind. About to ask "which is better?" but sense both optimize for different things. Stakeholders want conflicting things (both valid).
Some tensions aren't problems to solve - they're valuable information to preserve. When multiple approaches are genuinely valid in different contexts, forcing a choice destroys flexibility.
**Core principle:** Preserve tensions that reveal context-dependence. Force resolution only when necessary.
## Recognizing Productive Tensions
**A tension is productive when:**
- Both approaches optimize for different valid priorities (cost vs latency, simplicity vs features)
- The "better" choice depends on deployment context, not technical superiority
- Different users/deployments would choose differently
- The trade-off is real and won't disappear with clever engineering
- Stakeholders have conflicting valid concerns
**A tension needs resolution when:**
- Implementation cost of preserving both is prohibitive
- The approaches fundamentally conflict (can't coexist)
- There's clear technical superiority for this specific use case
- It's a one-way door (choice locks architecture)
- Preserving both adds complexity without value
## Preservation Patterns
### Pattern 1: Configuration
Make the choice configurable rather than baked into architecture:
```python
classConfig:
mode:Literal["optimize_cost","optimize_latency"]
# Each mode gets clean, simple implementation
```
**When to use:** Both approaches are architecturally compatible, switching is runtime decision
### Pattern 2: Parallel Implementations
Maintain both as separate clean modules with shared contract:
```python
# processor/batch.py - optimizes for cost
# processor/stream.py - optimizes for latency
# Both implement: def process(data) -> Result
```
**When to use:** Approaches diverge significantly, but share same interface
### Pattern 3: Documented Trade-off
Capture the tension explicitly in documentation/decision records:
```markdown
## Unresolved Tension: Authentication Strategy
**Option A: JWT** - Stateless, scales easily, but token revocation is hard
**Option B: Sessions** - Easy revocation, but requires shared state
**Why unresolved:** Different deployments need different trade-offs