Initial commit

2025-11-30 09:00:08 +08:00
commit dccefb2050
10 changed files with 5088 additions and 0 deletions
--- a/skills/using-systems-thinking/behavior-over-time-graphs.md
+++ b/skills/using-systems-thinking/behavior-over-time-graphs.md
@@ -0,0 +1,843 @@
+
+# Behavior-Over-Time Graphs
+
+## When to Use This Skill
+
+Use behavior-over-time (BOT) graphs when:
+- **Predicting future states**: "What will customer count be in 6 months?"
+- **Comparing scenarios**: "With intervention vs without intervention"
+- **Communicating urgency**: "Look how fast debt is growing!"
+- **Demonstrating time-to-crisis**: "We have 14 months before capacity saturated"
+- **Validating models**: Overlay actual vs predicted behavior
+- **Explaining delays**: "Why solutions take 3 months to show results"
+
+**Don't use BOT graphs when**:
+- You don't know the structure yet → Start with causal loop diagram (CLD)
+- You need to show feedback loops → Use CLD with polarity markers
+- You want current state only (no trajectory) → Use stock-flow diagram
+- Data too uncertain to plot → Use qualitative archetype analysis
+- Audience needs WHY not WHEN → Use CLD to show causal logic
+
+**Key insight**: BOT graphs answer "What happens over time?" with concrete numbers and dates. Use them AFTER you've mapped structure (CLD) and calculated values (stock-flow), to communicate dynamics visually.
+
+
+## The 7-Step Construction Process
+
+**Build BOT graphs systematically. Never jump to the final graph without validating each step.**
+
+### Step 1: Identify What to Plot (Stock vs Flow)
+
+**Rule**: BOT graphs typically show STOCKS (accumulated quantities), not flows (rates).
+
+**Why**: Stakeholders care about "How bad is the problem?" (stock level) more than "How fast is it changing?" (flow rate).
+
+**Test**: Can you measure this at a single instant without reference to time?
+- YES → Stock (plot it)
+- NO → Flow (consider plotting the stock it affects instead)
+
+**Examples**:
+- ✅ Plot: Customer Count (stock)
+- ❌ Not: Customer Acquisition Rate (flow) - unless specifically analyzing flow behavior
+- ✅ Plot: Bug Backlog (stock)
+- ❌ Not: Bug Arrival Rate (flow)
+- ✅ Plot: Technical Debt Points (stock)
+- ❌ Not: Debt Accumulation Rate (flow)
+
+**Exception**: Plot flows when analyzing flow behavior itself (e.g., "Development Velocity over time")
+
+
+### Step 2: Determine Time Scale (Granularity and Range)
+
+**Two decisions**: How fine-grained? How far forward?
+
+**Granularity** (X-axis intervals):
+- **Hourly**: Real-time monitoring, very fast dynamics
+- **Daily**: Operational metrics (deployments, incidents)
+- **Weekly**: Sprint-level analysis
+- **Monthly**: Business metrics (MRR, customer count)
+- **Quarterly**: Strategic planning
+- **Yearly**: Long-term trends
+
+**Decision criteria**:
+- Match measurement frequency (if customers tracked monthly, use monthly)
+- Show intervention timeframe (if intervention monthly, don't use yearly)
+- Avoid unnecessary noise (daily SaaS revenue too volatile, use monthly)
+
+**Range** (how far forward to project):
+
+**Rule of thumb**: Show **2-3× the time constant** of the system
+
+**Time constant (τ)** = Time for system to reach ~63% of equilibrium (from stocks-and-flows-modeling)
+
+**Examples**:
+- Customer growth τ = 8 months → Plot 16-24 months
+- Bug backlog τ = 2 weeks → Plot 4-6 weeks
+- Technical debt τ = infinity (unbounded) → Plot until crisis or intervention
+
+**Practical**:
+- Show intervention point + outcome period (decide at month 3, show months 0-12)
+- Include phase transitions (growth → crisis → stabilization)
+- Don't over-extend (24 months for 2-week problem dilutes insight)
+
+
+### Step 3: Calculate Values (Using Stock-Flow Equations)
+
+**Never eyeball the curve**. Calculate stock levels using formal equations from stocks-and-flows-modeling.
+
+**Standard formula**:
+```
+Stock(t+1) = Stock(t) + Δt × (Inflow - Outflow)
+```
+
+**Process**:
+1. Identify initial condition: Stock(0) = ?
+2. Calculate flows for each time period
+3. Apply formula iteratively
+4. Verify units: Stock in [X], Flows in [X/time], Δt in [time]
+5. Validate: Does equilibrium match calculation? (Set Inflow = Outflow)
+
+**Example - Bug Backlog**:
+```
+Backlog(0) = 50 bugs
+Inflow = 30 bugs/month (constant)
+Outflow = 0.8 × Velocity (bugs/month, stock-dependent)
+Velocity = 40 points/sprint, 2 sprints/month
+
+Month 0: 50 bugs
+Month 1: 50 + (30 - 0.8×40×2) = 50 + (30 - 64) = 16 bugs
+Month 2: 16 + (30 - 0.8×40×2) = -18 bugs → Floor at 0 bugs
+Equilibrium: Inflow < Outflow, backlog drains to 0
+```
+
+**Common mistake**: Guessing values instead of calculating. If stakeholders question, you must defend with math.
+
+
+### Step 4: Select Graph Type
+
+**Decision tree**:
+
+**Is the data continuous or discrete?**
+- **Continuous** (smooth accumulation) → **Line graph** ✓ (default)
+- **Discrete** (step changes) → **Step function**
+
+**Do you want to emphasize magnitude?**
+- **YES** → **Area chart** (fills area under line)
+- **NO** → **Line graph**
+
+**Are you comparing discrete time periods?**
+- **YES** → **Bar chart**
+- **NO** → **Line graph**
+
+**Examples**:
+- Customer growth over time: **Line graph** (continuous accumulation)
+- Headcount changes (hire whole people): **Step function** (discrete jumps)
+- Quarterly revenue comparison: **Bar chart** (discrete periods)
+- Technical debt accumulation: **Area chart** or **Line** (either works, area emphasizes magnitude)
+
+**Default**: When unsure, use **line graph**. It's the most versatile and widely understood.
+
+
+### Step 5: Choose Scale (Y-Axis Range)
+
+**The 70-80% Rule**: Maximum value in your data should occupy **70-80% of the Y-axis range**.
+
+**Formula**:
+```
+Y_max = Data_max / 0.75
+```
+
+**Example**:
+- Data maximum: 60 debt points
+- Y-axis max: 60 / 0.75 = 80 points ✓
+
+**Why 70-80%?**
+- Provides visual buffer (not cramped at top)
+- Makes growth impactful (not tiny slope in vast space)
+- Industry standard for clear visualization
+
+**Common mistakes**:
+- ❌ Y-axis = 120 when data max = 60 (only 50% occupied, wastes space)
+- ❌ Y-axis = 65 when data max = 60 (92% occupied, cramped, hard to see trend)
+- ✅ Y-axis = 80 when data max = 60 (75% occupied, perfect)
+
+**When to start Y-axis at non-zero**:
+- **Use 0 baseline** when showing absolute change (customer count growth 0 → 7,000)
+- **Use non-zero** when showing small variations around large baseline (server uptime 98.5% → 99.2%)
+- **Warning**: Non-zero baselines can mislead. If using, annotate clearly.
+
+**Logarithmic scale**:
+- Use when data spans multiple orders of magnitude (1 → 1,000 → 1,000,000)
+- Use when exponential growth makes linear scale unreadable
+- **Always label** "logarithmic scale" explicitly
+
+
+### Step 6: Add Annotations (Events, Phases, Thresholds)
+
+**Annotations reveal WHY the curve behaves the way it does.**
+
+**Types of annotations**:
+
+**1. Event markers** (vertical lines at intervention points):
+```
+    │
+    ↓
+[INTERVENTION]
+```
+- Product launch, infrastructure investment, policy change
+- Mark the TIME of the decision/event
+
+**2. Phase labels** (text for regions):
+```
+[GROWTH PHASE]    [CRISIS]    [STABILIZATION]
+```
+- Mark distinct system behaviors over time periods
+
+**3. Threshold lines** (horizontal lines for critical values):
+```
+─────────────── Capacity Limit (100 customers/month)
+─────────────── Crisis Threshold (200 bugs)
+```
+- Show when system crosses critical boundaries
+
+**4. Annotations density limit**: **Max 5-7 annotations per graph**
+- More than 7 → Cluttered, unreadable
+- If you need more, split into multiple graphs
+
+**Placement**:
+- Events: Vertical line at X position, label above or below
+- Phases: Text box or bracket spanning time period
+- Thresholds: Horizontal line with label at end or middle
+
+**Priority**: Annotate the 3 most important events/thresholds, not everything.
+
+
+### Step 7: Validate (Quality Checklist)
+
+**Before presenting any BOT graph, check**:
+
+✅ **Units clearly labeled on both axes?**
+- Y-axis: "Technical Debt (story points)"
+- X-axis: "Time (months)"
+
+✅ **Scale follows 70-80% rule?**
+- Data_max / Y_max between 0.70 and 0.80?
+
+✅ **Time range shows full story?**
+- Intervention point + enough time to see outcome?
+- Shows equilibrium or steady state if system reaches it?
+
+✅ **Annotations clear and not cluttered?**
+- ≤7 annotations total?
+- Labels don't overlap?
+
+✅ **Graph type appropriate for data?**
+- Continuous data → Line
+- Discrete changes → Step function
+- Time period comparison → Bar
+
+✅ **Readable at presentation size?**
+- Can you read axis labels from 10 feet away?
+- Are data lines thick enough?
+
+✅ **Validated against stock-flow calculations?**
+- Do plotted values match your calculated spreadsheet?
+- Did you verify equilibrium point?
+
+✅ **Comparison method clear (if multiple scenarios)?**
+- Different line styles (solid vs dashed)?
+- Legend shows which line is which?
+
+**If any check fails, FIX before presenting.** Wrong scale or missing units destroys credibility.
+
+
+## ASCII/Text Visualization Standards
+
+**Character set for text-based graphs**:
+```
+│ ─ ┌ ┐ └ ┘ ╱ ╲ ● ○ ▲ ▼ ┼ ├ ┤
+```
+
+**Axis notation**:
+```
+Y-Axis Label (units)
+│
+80│
+│
+60│
+│
+40│
+│
+20│
+│
+0└───┬───┬───┬───┬───┬───┬───
+    0   2   4   6   8  10  12
+         X-Axis Label (units)
+```
+
+**Data line styles**:
+- **Solid line**: ─── (primary scenario, baseline)
+- **Dashed line**: ╌╌╌ or - - - (alternative scenario, comparison)
+- **Markers**: ● (data points), ▲ (intervention), ▼ (crisis event)
+
+**Multiple scenarios on same graph**:
+```
+80│              ┌───●───  Scenario A (solid)
+  │           ┌─○┤
+60│         ╌─┘  │   ○╌╌╌  Scenario B (dashed)
+  │      ╌─┘     │
+40│   ╌─┘        │
+  │╌─┘           │
+20│              │
+  └──────────────┼──────────
+  0    3    6    9    12 months
+               ▲
+         INTERVENTION
+```
+
+**Spacing and readability**:
+- Leave 2-3 character spaces between axis ticks
+- Align numbers right-justified on Y-axis
+- Keep X-axis labels centered under tick marks
+
+**Template** (copy and modify):
+```
+[Y-AXIS LABEL] (units)
+│
+MAX│
+   │
+75%│                      ┌───
+   │                   ┌─┘
+50%│                ┌─┘
+   │             ┌─┘
+25%│          ┌─┘
+   │       ┌─┘
+0  └───┬───┬───┬───┬───┬───┬───
+   0   1   2   3   4   5   6
+        [X-AXIS LABEL] (units)
+```
+
+
+## Multi-Variable Framework
+
+**When you need to plot multiple variables**, choose strategy systematically:
+
+### Strategy 1: Dual Y-Axis (Same Graph, Two Scales)
+
+**When to use**:
+- ✅ Variables have **causal relationship** (team size drives velocity)
+- ✅ Different units (engineers vs story points)
+- ✅ Similar time dynamics (both change over same period)
+- ✅ Viewer needs to see correlation visually
+
+**Example**: Team Size (left axis: engineers) + Velocity (right axis: points/sprint)
+
+**Limitations**:
+- Hard in ASCII (need clear labeling)
+- Max 2 variables (more is confusing)
+
+
+### Strategy 2: Separate Panels (Stacked, Shared X-Axis)
+
+**When to use**:
+- ✅ Variables from **different domains** (technical vs human)
+- ✅ Very different scales (0-100 bugs vs 1-10 morale)
+- ✅ Want independent Y-axes for clarity
+- ✅ More than 2 variables
+
+**Example**:
+```
+Bug Backlog (bugs)
+200│     ╱───
+   │  ╱──
+100│╱──
+0  └───────────
+
+Morale (1-10)
+10│────╲
+  │     ╲
+5 │      ──╲
+0 └───────────
+  0  3  6 months
+```
+
+**Benefit**: Each variable has appropriate scale, viewer can cross-reference via shared time axis
+
+
+### Strategy 3: Normalized 0-100% (Same Scale)
+
+**When to use**:
+- ✅ Relative trends matter more than absolute values
+- ✅ Comparing variables with very different units
+- ✅ Showing patterns, not magnitudes
+
+**Example**: Customer % vs Revenue % vs Team % (all normalized to 0-100%)
+
+**Warning**: Loses actionability. "Customer % = 75%" doesn't tell stakeholder "we have 7,500 customers."
+
+**Use sparingly**: Only when pattern visualization is the goal, not decision-making.
+
+
+### Decision Matrix:
+
+| Variables | Strategy | Example |
+|-----------|----------|---------|
+| 2 related, different units | Dual Y-axis | Team Size + Velocity |
+| 3+ from different domains | Separate panels | Bugs + Morale + Debt |
+| Need pattern, not magnitude | Normalized 0-100% | Multi-metric dashboard |
+| 2 same units | Single axis, overlay | Scenario A vs B customers |
+
+
+## Comparison Strategies
+
+**Showing "with intervention vs without intervention":**
+
+### Method 1: Overlay (Same Graph)
+
+**Best for**:
+- Similar scales (both scenarios fit 70-80% rule on same Y-axis)
+- Direct visual comparison
+- 2-3 scenarios maximum
+
+**Technique**:
+- Solid line = Baseline
+- Dashed line = Alternative
+- Markers differentiate: ● vs ○
+- Legend shows which is which
+
+**Example**:
+```
+7000│            ○╌╌╌  With Investment (+5%)
+    │          ╌─┤
+6000│        ╌─┘ │  ●──  Baseline
+    │      ╌─┘   ●─┘
+5000│    ╌─┘  ●─┘
+    │  ╌──●─┘
+4000│●─┘
+```
+
+
+### Method 2: Side-by-Side (Separate Graphs)
+
+**Best for**:
+- Different scales (Scenario A: 0-100, Scenario B: 0-500)
+- Many scenarios (4+)
+- Independent analysis
+
+**Technique**:
+- Graph 1: Scenario A
+- Graph 2: Scenario B
+- Shared time axis
+- Separate Y-axis scales
+
+**Use**: When overlay would be cluttered or scales incompatible
+
+
+### Method 3: Stacked Panels (Vertically Aligned)
+
+**Best for**:
+- Showing multiple aspects of same scenario
+- Different variables (customers, revenue, cost)
+- Aligned time for cross-reference
+
+**Technique**:
+- Panel 1: Primary metric
+- Panel 2: Secondary metric
+- Panel 3: Tertiary metric
+- Shared X-axis, independent Y-axes
+
+
+## Phase/Region Marking
+
+**Showing "crisis zone" or "stable region":**
+
+**Technique 1: Vertical bands** (time periods):
+```
+│ [GROWTH] [CRISIS] [STABLE]
+│    ╱──────╲ ──────────
+│  ╱         ╲
+│╱            ╲────────
+└─────────────────────
+ 0   3   6   9   12
+```
+
+**Technique 2: Horizontal regions** (threshold bands):
+```
+│ ───────── 200 bugs ←─── CRISIS THRESHOLD
+│     ╱──────
+│  ╱──          [SAFE ZONE]
+│╱──
+└────────
+```
+
+**Technique 3: Text labels with brackets**:
+```
+│     ╱──────
+│  ╱──    └──[Peak: Crisis Mode]
+│╱──
+└─────
+```
+
+**When to use**:
+- Complex dynamics with distinct phases (growth, plateau, decline)
+- Critical thresholds (capacity limits, SLA boundaries)
+- Multi-phase interventions (before, during, after)
+
+
+## Common Mistakes Catalog
+
+### 1. Y-Axis Too Large
+
+**Mistake**:
+```
+120│
+   │              ┌───── (Data only reaches 60)
+60│           ┌─┘
+   │        ╱
+0  └──────────
+```
+**Problem**: Wastes 50% of space, minimizes visual impact
+**Fix**: Apply 70-80% rule → Y-max = 80
+
+
+### 2. Y-Axis Too Small
+
+**Mistake**:
+```
+65│┌───────── (Data hits 60, cramped!)
+  │││
+60││
+  └──────
+```
+**Problem**: Exaggerates tiny changes, looks volatile
+**Fix**: Provide 20-30% buffer above max value
+
+
+### 3. Missing Units on Axes
+
+**Mistake**:
+```
+│ "Technical Debt" ← What units? Story points? Hours? $$?
+└── "Time" ← Days? Weeks? Months?
+```
+**Fix**: Always label with units: "Technical Debt (story points)", "Time (months)"
+
+
+### 4. Time Range Too Short
+
+**Mistake**: Showing months 0-3 when intervention at month 3 (cuts off outcome)
+**Fix**: Extend to month 6-12 to show result of intervention
+
+
+### 5. Time Range Too Long
+
+**Mistake**: Showing 24 months for 2-week bug fix project (dilutes insight)
+**Fix**: Match time range to problem scale (weeks for bugs, months for customers, years for strategy)
+
+
+### 6. Too Many Annotations
+
+**Mistake**: 15 labels, arrows, boxes → Unreadable clutter
+**Fix**: Limit to 5-7 most important events/thresholds
+
+
+### 7. Wrong Graph Type
+
+**Mistake**: Bar chart for continuous accumulation (treats smooth growth as discrete jumps)
+**Fix**: Use line graph for continuous, step function for discrete, bar for period comparison
+
+
+### 8. Misleading Non-Zero Baseline
+
+**Mistake**:
+```
+99.5│    ╱─── (Looks like 10× growth!)
+    │  ╱
+99.0│╱
+```
+**Reality**: 99.0% → 99.5% is only +0.5% absolute change
+**Fix**: Either use 0 baseline OR annotate "Y-axis starts at 99%" prominently
+
+
+### 9. Overlaying Incompatible Scales
+
+**Mistake**: Plotting Customers (0-10,000) and Revenue ($0-$100) on same Y-axis without dual-axis
+**Fix**: Use dual Y-axis (left: customers, right: revenue) or separate panels
+
+
+### 10. Missing Key Events
+
+**Mistake**: Curve changes slope at month 6, no annotation explaining why
+**Fix**: Mark event: "▲ Infrastructure Investment" at month 6
+
+
+## Audience Adaptation Template
+
+**Create different versions for different audiences systematically.**
+
+### Technical Version (Engineers, Analysts)
+
+**Language**:
+- Use precise terms: "Equilibrium", "Time constant", "Stock-dependent outflow"
+- Show equations: `Debt(t+1) = Debt(t) + 15 - 5`
+- Include units: "story points", "bugs/week"
+
+**Detail level**:
+- All calculations shown
+- Validation checks documented
+- Alternative scenarios with sensitivity analysis
+- Limitations and assumptions listed
+
+**Visual complexity**:
+- Multi-panel graphs acceptable
+- Dual Y-axes if needed
+- Detailed annotations (formulas, thresholds)
+
+**Focus**: HOW and WHY (mechanics, validation, replication)
+
+
+### Executive Version (Board, C-Suite)
+
+**Language**:
+- Use business terms: "Debt stabilizes", "Crisis trajectory", "ROI"
+- Hide equations (show result only)
+- Use business units: "% of team capacity", "months to crisis"
+
+**Detail level**:
+- Key insights only (no intermediate calculations)
+- Single clear recommendation
+- ROI or cost-benefit comparison
+- Risk framing ("Without action, we reach crisis in 6 months")
+
+**Visual complexity**:
+- Single clean graph (not multi-panel)
+- Simple annotations (plain English, no jargon)
+- Clear comparison (with vs without intervention)
+
+**Focus**: WHAT and SO WHAT (outcomes, decisions, impact)
+
+
+### General Audience (Team, Stakeholders)
+
+**Language**:
+- Minimal jargon
+- Clear labels ("Bug Count", not "Defect Density")
+- Intuitive units (days/months, not time constants)
+
+**Detail level**:
+- Enough to understand trend, not full derivation
+- Key events marked
+- Why it matters explained in one sentence
+
+**Visual complexity**:
+- Simple line graph
+- 3-5 annotations maximum
+- Pattern should be obvious (up, down, stable)
+
+**Focus**: UNDERSTANDING (what's happening, why it matters)
+
+
+### Systematic Translation Process:
+
+| Aspect | Technical | Executive | General |
+|--------|-----------|-----------|---------|
+| **Language** | Equilibrium, τ, ΔS | Stabilizes, timeline, change | Levels off, when, difference |
+| **Detail** | All calculations | Key insights | Main pattern |
+| **Visual** | Multi-panel, dual-axis | Single clean graph | Simple line |
+| **Equations** | Show formulas | Hide formulas | Hide formulas |
+| **Units** | Precise (story points) | Business (% capacity) | Intuitive (days) |
+| **Focus** | How/Why | What/So What | What/Why it matters |
+
+**Process**: Create technical version first (complete), then simplify for executive/general by removing detail and translating language.
+
+
+## Integration with Other Skills
+
+### BOT + Stock-Flow Modeling
+
+**Workflow**:
+1. **Stock-Flow**: Build equations, calculate values, find equilibrium
+2. **BOT Graph**: Visualize those values over time
+3. **BOT Graph**: Show trajectory toward (or away from) equilibrium
+
+**Example**: Stock-flow calculates "Bug backlog drains to 0 in 4 weeks", BOT graph shows the decline curve
+
+
+### BOT + Causal Loop Diagrams
+
+**Workflow**:
+1. **CLD**: Map feedback loops, identify reinforcing vs balancing
+2. **Stock-Flow**: Quantify the stocks and flows in loops
+3. **BOT Graph**: Show how loops create growth, decline, or oscillation over time
+
+**Example**: CLD shows "Debt → Slow Velocity → Pressure → Shortcuts → Debt (R loop)", BOT graph shows exponential debt growth
+
+
+### BOT + System Archetypes
+
+**Workflow**:
+1. **Archetype**: Recognize pattern (Fixes that Fail, Escalation)
+2. **Stock-Flow**: Model the specific instance
+3. **BOT Graph**: Show characteristic behavior (symptom relief then return worse)
+
+**Example**: "Fixes that Fail" archetype → BOT shows quick fix working temporarily (months 1-3), then problem returning worse (months 4-6)
+
+
+### BOT + Leverage Points
+
+**Workflow**:
+1. **Leverage Points**: Identify intervention options (parameter vs structure change)
+2. **Stock-Flow**: Model each intervention's impact
+3. **BOT Graph**: Compare scenarios visually (intervention A vs B vs do nothing)
+
+**Example**: BOT shows "Hiring (Level 12): Small improvement, Quality (Level 10): Reaches equilibrium"
+
+
+### Complete Workflow:
+
+1. **Unknown problem** → Start with **Causal Loop Diagram** (map structure)
+2. **Familiar pattern** → Match to **System Archetype** (leverage known interventions)
+3. **Need numbers** → Build **Stock-Flow Model** (quantify stocks, flows, equilibrium)
+4. **Show dynamics** → Create **BOT Graph** (visualize trajectory over time)
+5. **Choose intervention** → Apply **Leverage Points** (rank options)
+6. **Communicate decision** → Use **BOT Graph** + **Leverage Points** (show impact of choice)
+
+**BOT graphs are communication and prediction tools** - use them AFTER structure (CLD) and calculation (Stock-Flow) to show "what happens over time."
+
+
+## Red Flags: Rationalizations to Resist
+
+### "I can eyeball the curve"
+
+**Reality**: Intuition fails on non-linear dynamics, delays, equilibrium points.
+
+**Counter**:
+- Exponential growth looks slow until it's not (then it's too late)
+- Delays create overshoot your intuition won't predict
+- Equilibrium isn't obvious (is it at 5,000 customers or 20,000?)
+
+**Test**: Sketch your intuitive curve, then calculate. If they match, calculation was quick confirmation. If they don't, your intuition would have misled stakeholders.
+
+
+### "Math takes too long"
+
+**Reality**: 10 minutes of calculation vs months of wrong decisions.
+
+**Counter**:
+- Stock-flow calculation: 10-15 minutes in spreadsheet
+- Drawing wrong curve: Stakeholders make $100K decisions based on it
+- Wrong trajectory = wrong intervention = wasted resources
+
+**Test**: Time to calculate vs cost of error. If error >$10K and decision not easily reversed, CALCULATE.
+
+
+### "Let's make it look dramatic for the board"
+
+**Reality**: Manipulated graphs destroy credibility permanently.
+
+**Counter**:
+- Non-zero baseline tricks can be spotted (lost trust forever)
+- Exaggerated Y-axis makes real data look silly when revealed
+- Board members aren't stupid - they'll ask questions
+
+**Test**: If your graph would look different with accurate scale, you're manipulating. Use honest scale, let the real data speak.
+
+
+### "Too many details, keep it clean"
+
+**Reality**: "Clean" without context is ambiguous; "simple" ≠ "simplistic"
+
+**Counter**:
+- Removing intervention annotation: Now curve's slope change is mysterious
+- Removing threshold: Now viewer doesn't know when crisis hits
+- Removing units: Now "60" means nothing
+
+**Test**: Can stakeholder make correct decision with this graph? If annotations are needed for that, they stay.
+
+
+### "It's obvious what will happen"
+
+**Reality**: Equilibrium points, overshoot, phase transitions are NOT obvious.
+
+**Counter**:
+- "Obviously grows forever" → Actually stabilizes at equilibrium
+- "Obviously stabilizes" → Actually oscillates due to delays
+- "Obviously smooth curve" → Actually has crisis dip (infrastructure limit)
+
+**Test**: Ask three people to sketch their mental model. If they draw different curves, it's NOT obvious. Model it.
+
+
+### "We don't have time to calculate"
+
+**Reality**: Presenting wrong trajectory wastes everyone's time.
+
+**Counter**:
+- Meeting starts in 30 min → 15 min to calculate, 15 min to draw
+- Presenting without calculation → "How did you get these numbers?" → Credibility lost
+- Stakeholders make multi-month plans based on your graph → Worth getting right
+
+**Test**: Is this graph for decision-making or just discussion? If decision-making, calculate. Always.
+
+
+### "The actual data won't match anyway"
+
+**Reality**: Models predict DYNAMICS (trends), not exact values.
+
+**Counter**:
+- You're right absolute numbers may be off ±20%
+- But DYNAMICS are accurate: "Growth then plateau" vs "Unbounded growth"
+- Overlay actual data when available, refine model
+- Imperfect model > no model > wrong intuition
+
+**Test**: Model shows "stabilizes at 5,000-7,000 customers in 12-18 months" - even if exact is 6,200 customers at 14 months, you captured the right behavior for decision-making.
+
+
+## Summary
+
+**Behavior-over-time graphs** visualize system dynamics over time:
+
+**7-step construction process**:
+1. Identify what to plot (stocks, not flows)
+2. Determine time scale (granularity and range)
+3. Calculate values (using stock-flow equations)
+4. Select graph type (line, area, step, bar)
+5. Choose scale (70-80% rule)
+6. Add annotations (events, phases, thresholds, max 5-7)
+7. Validate (checklist before presenting)
+
+**ASCII standards**:
+- Consistent character set: │ ─ ┌ ┐ └ ┘ ╱ ╲ ● ○
+- Clear axis labels with units
+- Templates for common patterns
+
+**Key rules**:
+- 70-80% scale rule (data_max = 70-80% of Y-axis)
+- 2-3× time constant for range
+- <7 annotations maximum
+- Always calculate, never eyeball
+
+**Multi-variable strategies**:
+- Dual Y-axis: Related variables, different units
+- Separate panels: Different domains, independent scales
+- Normalized: Pattern focus, not magnitude
+
+**Audience adaptation**:
+- Technical: All details, equations, validation
+- Executive: Key insights, business language, ROI
+- General: Main pattern, minimal jargon, why it matters
+
+**Integration**:
+- BOT + Stock-Flow: Calculate then visualize
+- BOT + CLD: Structure then dynamics
+- BOT + Archetypes: Pattern then trajectory
+- BOT + Leverage Points: Compare interventions
+
+**Resist rationalizations**:
+- "Eyeball it" → Intuition fails on non-linear systems
+- "No time" → 15 min calculation vs wrong decisions
+- "Make it dramatic" → Manipulation destroys credibility
+- "Keep it clean" → Context matters for decisions
+- "It's obvious" → Equilibrium, overshoot, phases aren't obvious
+
+**The discipline**: Calculate values, choose scale systematically, validate before presenting, adapt to audience.
+
+**The payoff**: Show concrete predictions with timelines, compare scenarios visually, communicate urgency effectively, enable data-driven decisions.