thinking-triz

What this skill does

# TRIZ Thinking

## Overview

TRIZ is a systematic method for resolving **architecture and API design contradictions** — situations where two requirements seem mutually exclusive. When you're about to accept a trade-off because "you can't have both," TRIZ says: name the contradiction precisely, then try to **separate** the conflicting states in time, space, or condition so you get both — no compromise.

The separation moves are the primary procedure. The 40 Inventive Principles are a reference library, not a required checklist. The skill is scoped to technical design contradictions (architecture, API, system parameters); it is NOT for non-technical problems, ordinary prioritization, or contradictions that dissolve under measurement.

**Core Principle:** Great design doesn't compromise — it separates. Find the dimension where the conflicting states can coexist.

## When to Use

- An architecture or API design decision is stuck between two requirements that seem mutually exclusive (fast vs accurate, stable vs evolving, large cache vs fast invalidation)
- You're about to accept a trade-off because "you can't have both"
- The same weakness shows up in every solution you've considered — the contradiction is structural

Decision flow:

```
Two requirements seem mutually exclusive?
  → Yes → NAME THE CONTRADICTION, TRY SEPARATION
  → No → About to accept a trade-off curve compromise?
      → Yes → APPLY TRIZ FIRST
      → No → This is a routine decision — just pick based on constraints
```

## When NOT to Use

- **Ordinary trade-offs with a correct answer.** If one option is simply better given your constraints (cheaper, simpler, well-understood), just pick it — don't manufacture a contradiction.
- **The "contradiction" dissolves under measurement.** If you can cheaply test which side actually matters, do that instead of inventing a separation.
- **Non-technical or people problems.** Separation principles target system parameters, not organizational dynamics or interpersonal conflicts.
- **The contradiction is already well-solved by standard patterns.** If there's an established pattern (cache-aside, CQRS, feature flags), apply the pattern directly.

## Trigger Card

When stuck between two architecture or API requirements that seem mutually exclusive:

1. **Name the contradiction precisely** — "We need [PARAMETER A] to be [STATE 1] for [BENEFIT 1] BUT also [STATE 2] for [BENEFIT 2]." If you can't write it in this form, it's not a TRIZ problem.
2. **Try separation** — can you satisfy state 1 at one TIME and state 2 at another? In different SPACES (components, layers)? Under different CONDITIONS (context, load, user)?
3. **Test the simplest separation first** — separate in time (feature flags, scheduled behavior) before space (separate services) before condition.

If one option is simply better given your constraints, just pick it. If you can cheaply test which side actually matters, test instead of designing a separation. For standard patterns (cache-aside, CQRS, feature flags), apply the pattern directly.

## Procedure

### Step 1: Name the Contradiction Precisely

Use this template:

```
"We need [PARAMETER A] to be [STATE 1] for [BENEFIT 1]
 BUT also [STATE 2] for [BENEFIT 2]"

Example:
"We need the API to be STABLE for client compatibility
 BUT also EVOLVING to support new features"
```

If you can't write the contradiction in this form, it's not a TRIZ problem — use another skill.

### Step 2: Envision the Ideal Final Result (IFR)

Before solving, describe the outcome where the problem solves itself:

```
"The API supports both old and new clients simultaneously,
without version negotiation overhead,
while maintaining a single codebase."
```

IFR questions: What if the problem solved itself? What if the harmful element became useful? What's the result with zero cost?

### Step 3: Try Separation Moves (Primary Procedure)

For each separation dimension, ask: "Can the conflicting states exist at different [times/places/conditions/scales]?"

#### Separation in Time

"Can we be in state 1 at one time and state 2 at another?"

```
Contradiction: "Cache must be FRESH AND cached"
Separation in Time: TTL-based invalidation — cached now, refreshed later
```

#### Separation in Space

"Can we be in state 1 in one place and state 2 in another?"

```
Contradiction: "Data must be LOCAL (fast) AND DISTRIBUTED (resilient)"
Separation in Space: Multi-region with local reads, distributed writes
```

#### Separation by Condition

"Can we be in state 1 under some conditions and state 2 under others?"

```
Contradiction: "Auth must be STRICT AND frictionless"
Separation by Condition: Strict for sensitive operations, frictionless for low-risk — risk-based authentication
```

#### Separation in Scale/Level

"Can state 1 and state 2 exist at different levels of the system?"

```
Contradiction: "API must be STABLE AND evolving"
Separation in Scale: Stable interface (API contract), evolving implementation — versioned APIs
```

### Step 4: If Separation Fails, Scan the Principles (Reference)

When no separation dimension resolves the contradiction, scan the software-adapted inventive principles for inspiration:

| Principle | Software Pattern |
|-----------|-----------------|
| Segmentation (#1) | Microservices, sharding, chunked processing |
| Preliminary Action (#10) | Pre-computation, caching, warm-up, materialized views |
| The Other Way Round (#13) | Push vs pull, invert control, event-driven instead of polling |
| Intermediary (#24) | Proxy, message queue, API gateway, adapter |
| Copying (#26) | Caching, replication, CDN, read replicas |
| Dynamization (#15) | Feature flags, runtime configuration, adaptive thresholds |
| Another Dimension (#17) | Add metadata layer, versioning, event sourcing |

The full 40 principles are reference material; scan only the most applicable ones.

### Step 5: Resource Analysis

Before adding new components, ask: what already exists that can be used?

```
Before: "We need a new service to track user sessions"
Resource check:
- What data already exists? → Auth tokens carry user identity
- What's already running? → Load balancer sees all requests
- What's unused? → Request headers have room for session ID
Solution: Encode session in existing auth flow — no new service
```

### Step 6: Synthesize and Decide

Combine the separation move with resource reuse into a concrete design decision. Document the contradiction, the separation dimension used, and the resolution.

## Output Contract

A completed TRIZ analysis produces:

1. **Contradiction Statement** — in the precise template form (Parameter A must be State 1 for Benefit 1 BUT State 2 for Benefit 2)
2. **Ideal Final Result** — what the self-solving outcome looks like
3. **Separation Attempts** — which dimensions were tried (time, space, condition, scale) and the result
4. **Principles Scanned** (if separation failed) — which inventive principles were considered
5. **Resources Used** — what existing capabilities were leveraged before adding new ones
6. **Resolution** — the concrete design decision that resolves the contradiction without compromise

## Anti-Patterns

| Anti-Pattern | Symptom | Correction |
|---|---|---|
| **Manufacturing contradictions** | Applying TRIZ to "which database should we use" when one is clearly better | Use it only for genuine "I need both opposite states" tension |
| **Compromising instead of separating** | Accepting a midpoint on the trade-off curve without trying separation | Try all four separation dimensions before compromising |
| **Skipping separation, jumping to principles** | Immediately scanning the 40 principles without trying time/space/condition/scale | Separation is the primary procedure; principles are the fallback |
| **Applying to non-technical problems** | Using TRIZ for org dynamics or interpersonal conflicts | Separation targets system parameters, not people |
| **Over-applying to testable contradictions** | Running full TRIZ when a quick measur