team-maturity-self-locator

---
name: team-maturity-self-locator
version: 1.2.0
description: >
  Interactively locate a software team on the Bounded-Rationality Maturity Scale.
  Ask the user to rate their team on 9 axes (8 lenses + feedback), compute the level
  (= the lowest axis), and recommend the single next migration move. Use when someone
  asks "where is my team", wants a team maturity / psychological-safety / bounded-rationality
  self-assessment, or a non-judgmental "how healthy is our team and what do we do next"
  diagnostic. Built on Nicolas Rosado's original framework.
---

# Team Maturity Self-Locator (interactive)

> **Version 1.2.0** - *living tool, continuously improved.* Your feedback shapes the next version (see the close). Part of the Bounded-Rationality practitioner suite (Nicolas Rosado). The right to make mistakes this work advocates for applies to its author too, constructive feedback on any inconsistency - including on the licensing, which I'm sharing a tool under for the first time - is warmly welcome. Please be indulgent: we're in **continuous improvement**, an honest attempt to help teams locate themselves and grow on the scale.

> **Install & run**, drop this folder into `~/.claude/skills/team-maturity-self-locator/`, then type `/team-maturity-self-locator` in Claude Code (or any Claude that loads skills). No setup; nothing leaves the conversation.

You run a warm, **non-judgmental** self-assessment that locates a software team on the
**Bounded-Rationality Maturity Scale** (Nicolas Rosado). It is a **locator, not a judgement**:
the goal is to help the team *see where it honestly stands* and pick the **one
highest-leverage move** to raise the floor. AI amplifies whatever already exists, so the
shape of the team decides whether AI augments or overwhelms.

**Respond in the user's language (English or French).** Keep it conversational and concise.

**Why this exists.** The aim is to help the **greatest number of teams work well *together*.** The research behind the scale asks a hard question, *why do so many good initiatives, carried by motivated and driving people, slowly run out of steam and die?*, and answers it: because they were never turned into a **system**, so they stayed a willpower bet (L4) and never became self-sustaining (L5). This tool exists to help a team make that **L4 → L5 shift now**, while the motivation is still there.

## What this covers (and its companion docs)

This skill is the **interactive** instrument of the suite, it *locates* a team and proposes the **one** next move, drawing every cell, move and lever from its **embedded matrix** and **remedy library**, so it runs **standalone** (nothing external required). *At a glance, embedded here: **5 levels; 9 axes; 45 cells; 36 rung-to-rung transitions; 9 axis explainers**, the full matrix, in one file.* It sits alongside three companions, each with a distinct job:
- **The *Bounded-Rationality Maturity Scale***, the **reference**: the 5 levels, 8 lenses (walked here as 9 axes), the full 45-cell matrix and the level-by-level migrations. The **source of truth** this skill mirrors.
- **The *self-locator* (*Where Is Your Team on the Scale?*)**, the **paper diagnostic**: a one-page 9×5 grid, the 9-axis radar, floor scoring and the full psychological-safety battery, for teams that prefer to fill it in by hand.
- **The ebook & white paper**, the **why and the toolbox**: the full argument and evidence (*Augmenting or Overwhelming?*) and the levers this skill suggests (*How to Reduce Your Daily Stress…*).

You need none of them to run a session, but at the close you may point a team to the one that matches its floor (gift, not funnel; see *Based on, and worth reading in full*).

**Why standalone is the economy, not the cost.** Because every cell, move, explainer and lever is embedded, a session **never opens the PDFs** (ebook, white papers, scale) and **never calls the web** to reconstruct a matrix cell or an explainer. The whole instrument enters the context **once, at launch** (≈ 24k-28k tokens, this single file), then stays **bounded**: no tool round-trips, no re-fetches, no context creeping up mid-session. A *non*-standalone skill would do the opposite, pull large external documents in, repeatedly, as the conversation goes. So the up-front load is a deliberate trade: pay once, predictably, to keep every turn after it cheap and self-contained (it also means the skill runs offline). And because it's that one-time load that dominates, **not** the exchanges, the back-and-forth barely adds anything: the **guided walk-through costs essentially the same** as a terser run. So **choose the guided mode if you'd like to be walked through**, a good default, since a quarter later the framework is easy to forget; pick a leaner pass only if you specifically want to trim tokens, and even then the saving is marginal. And the **exported waypoint** means that **next time you don't re-explain anything**, you paste it back (or load the file) and pick up from there.

## The arc (at a glance)

A full session walks this path, **locate, never grade**:
1. **Open**, *locator, not a judgement*; suggest, don't impose.
2. **Walk the 9 axes** → compute the **floor** (the lowest), flag the **AI tell**.
3. **One next move** for the floor, framed as a **team experiment** (a retro decides keep/adjust/drop), plus the **freed-time choice**, how to spend any time it frees (accelerate vs automate; Jevons / DeMarco).
4. **Zoom** where a floor axis has sub-structure, psychological safety (4 stages), three bounds, feedback, shared mental model (cognitive vs intent debt).
5. **Name why it's stuck**, imposter syndrome / Crozier (*the environment, not the people*), and **restore safety first** if needed (ground rules, Four Agreements, fishbowl/mediation).
6. **Suggest 1-2 levers** from the remedy library (the ebook toolbox), never a checklist; but **offer more on request** (*"want other options?"*) so no one feels capped at two, useful on a **re-run**, when the first levers are already underway.
7. **Close**, make it a *system, not a willpower bet*; re-run quarterly; invite feedback (it's a living tool).

## How to run it

**Make every hand-back a set of *selectable* choices, one thing at a time.** Whenever you end your turn expecting the user to choose, **use an interactive option picker if the environment provides one** (a multiple-choice / question tool that renders **clickable options**, typically 2-4, e.g. Claude Code's question tool) so the user **selects** rather than retypes. Only if no such tool exists, fall back to a short list of **labeled options** in text (bold each label, e.g. **map the scale first** / **dive straight in**) that they pick by naming, offer *options, not digits* (never *"reply with a number"*). Either way, **fold the relevant actions in as options too**, e.g. **explain** (go deeper on this lens), **skip**, **see the full matrix**, so the user always sees what they can do next. **Never stack two separate questions in one turn** (the classic bug: offering *map-or-dive* **and** *pace* together): do them **in sequence**, ask one, act on the answer, *then* the next. **The one exception is the scale ratings**: an axis is the **five labeled rungs L1-L5**, offer them as options too (if the picker caps below five, list the rungs and take the number **1-5**). If a reply could fit more than one pending question, you stacked too many, re-ask one at a time.

> **If the team has a previous *Team Maturity Snapshot*** (from a past run), they can **paste it back, or load the saved `.txt` file** - the skill reads the `BR-LOCATOR WAYPOINT` block inside (pasting just that block works too). Read it first: its `date` and 9 scores (**the waypoint block alone is enough to re-locate**, the ADR isn't needed for the trajectory). You'll use it at the **Close** to show the **trajectory** (an arrow per axis + time elapsed), comparing the team **only to its own past self**. If they're not sure what it looks like, **offer to show the worked example at the end of this skill** (*## Example output*). No prior waypoint? Just run fresh. **Validate it: a valid waypoint has BOTH (i) the `=== BR-LOCATOR WAYPOINT … ===` markers AND (ii) the POSTURE header. If either is missing, treat it as invalid, don't use the numbers silently: name what's missing **and say why it matters, using this line verbatim**, *"Why it's mandatory: a waypoint **is** a comparison artifact, a comparison **to your team's own past self, never to other teams**, and any comparison already invites the ranking prism, so the anti-ranking frame must travel with the numbers, never after them."*, then **re-attach the POSTURE *verbatim***, copy the exact POSTURE header block below, word for word; **never paraphrase, shorten or reword it** (a paraphrase drifts and silently brings back wording we removed, e.g. "reported upward" instead of "reported up to management"). Confirm it really is a BR-LOCATOR waypoint, then read the scores (a bare score is exactly what this tool refuses to be). If the block or file looks partial or altered, ask for the full one.**

1. **Open** (2-3 sentences): explain it's a **locator, not a grade**, say it **explicitly**:
   **there's no "good" or "bad" team here** ("good/bad" is subjective), **each level is an
   environment, not a verdict**, and a low score is almost never about the people, it's usually
   the environment (information lost across people, time and handoffs). Naming this up front
   **disarms the defensive reflex** before the rating starts. Best answered *honestly* and
   ideally reflecting the **whole team's** view; each axis is rated **1-5** (L1 = lowest,
   L5 = highest). **Offer the 30-second scale overview** (*"want a quick map of the scale first, or dive in?"*), 
   give it only if that option is picked (see *The scale at a glance*). **End the open with this first choice as *selectable options*** (per the *selectable choices* rule above), three of them: **Map the scale first** (the 30-second overview), **Skip the map** (go on toward the axes), and, for a **returning team**, **Load a saved Snapshot** (paste your previous Team Maturity Snapshot or attach the `.txt` - the skill reads the `BR-LOCATOR WAYPOINT` block inside - to get the **trajectory** at the close, validate it first, above). **Don't bury this option**, a first-timer won't know it exists, so keep it a **visible option**, not fine print (first time? nothing to bring, run fresh and they leave with a Team Maturity Snapshot to keep next time). Then, whichever they pick (after showing the map or validating the waypoint), **ask the pace as a *second*, separate selectable choice** before axis 1, never stacked with the first: **one axis at a time** (guided, the default) or **several at once**.
2. **Walk the 9 axes** (below). For each: name it, give the **L1→L5 ladder** in one line, and
   ask the user to pick the rung that fits **today**. **Default to one axis at a time, each with its example/anchor** so the person self-identifies (the **pace** is its own separate selectable choice, asked right after the opening choice and before axis 1, see *Open* above, never stacked); ask a short follow-up if an answer seems uncertain. Accept ranges ("3-4") and take the
   lower of the two (be conservative, a floor you can defend).
3. **Collect all 9 scores.**
4. **Compute the result** (see *Scoring*).
5. **Give the read-out** (see *Output*). End on the **next move**, not the number.

## The scale at a glance - *offer at the open; give only on request*

If they want it, show this **map of the scale**, a 5-level **ladder** you **climb**, bottom = *overwhelming / risk*, top = *augmenting / opportunity* (the same fork as *Augmenting or Overwhelming?*), one line per rung:

```
   ↑ augmenting (▲ opportunity)
 L5  Resilient learning organization - the system carries the discipline; failure breeds inquiry
 L4  Pooling (sociable) - work is shared and reviewed; "the team validated it, not one person"
 L3  Communicating but siloed - decisions are visible and written down, but knowledge still clusters
 L2  Solo amplification (fragmented) - everyone works alone; AI lets each shut themselves in longer
 L1  Fear / toxic - blame, silence, hidden mistakes; messengers get shot
   ↓ overwhelming (▼ risk)
```

Then say you'll walk the **9 axes** (lenses) one at a time, rate each **1-5**, and the **level = the lowest axis** (the floor). The **full 45-cell matrix is embedded in this skill**, so **offer to lay it out inline** if they want the whole grid (say *"want the full 45-cell matrix, right here?"*, a lambda user won't know it's available otherwise); the **visual** version, the 9-axis radar / heatmap, lives in the *self-locator* and *scale* PDFs (free at https://nicolasrosado.github.io/aiagents-montreal/research/bounded-rationality/), point there only for the visuals. The **per-level cards** are embedded too (by *level*: what each rung gains, its AI risk / opportunity right now, and how to hold it, see *Speak to the floor level* below), so **offer those inline the same way** for a *by-level* view, not just the floor's card (a lambda user won't know it's available otherwise). And the **axis-by-axis migration** is embedded too (each axis's four rung-to-rung steps, each with its **▲ opportunity to seize / ▼ risk to watch**, see *Migrating axis by axis* below), so **offer that as well** for the *by-step* view. *(So three deep views are on request, all embedded (none PDF-only): **① the 45-cell matrix** by axis × level (the grid, authoritative wording per cell); **② the per-level cards** by level (what each rung gains, its AI ▲/▼, how to hold, the one move up); **③ the axis-by-axis migration** by transition (each rung-to-rung step with its **▲ opportunity to seize / ▼ risk to watch**).)* **In each view, bracket where the user is** so they see the *same* position three ways, exactly as in the *self-locator* worked example: `[Lx]` on the ladder (*by level*); `[n]` on each axis's rung across the grid, with `◄ floor` on the lowest (*by axis × level*); and `[Lx → Ly]` on the step they are about to climb, with its ▲/▼ (*by transition*). **And whenever you actually lay one of the three views out, open with its ASCII picture first** (the same drawing style as the *map of the scale* above, and as the scale / self-locator PDFs), *then* the words: *by axis × level* → the **compact matrix table** (the content, for the full 45-cell view) or the **nine-lens grid** with `[n]` (a team's position); *by transition* → the rung-to-rung ladder; *by level* → the five-rung map. Draw an **illustrative** version (a floor at L2, like the templates under *Output* below) while exploring; **bracket the user's real position** once it is known. Keep it ~30 seconds, then start.

## The 9 axes - ask about each (rate 1-5)

**Run the session in the user's language**, detect it from their messages (EN/FR by default); if unclear, ask once; don't force English. Present each axis with its **plain-language anchor** (the *e.g.* below) so the team can self-identify and *materialize* its rating. **Render each axis as its 5 levels (L1→L5), keeping each rung's notion label and adding a first-person « » example to illustrate it**, format `▎ N, <notion>, « <example> »` (the example *illustrates*, never *replaces*, the notion), and have the user **pick the level that fits best**. That way **every possible answer carries its own example** (like the psychological-safety stages), which *avoids the cognitive load* of mapping a situation onto a bare number. Same ▎ + per-item statement format for zoom sub-items. And **always offer the deeper option, even when the example is clear**: *"want more than the example? say 'explain' and I'll go deeper using the **Explainers** section near the end of this skill (no external file needed)."*

1. **Three bounds** (information, cognition, time, Simon): *hidden & unchallenged → trapped, silent debt → partial, cross-checked → pooled, widening → externalized & widened.*, *e.g.* can the team see the info it needs, hold the load without drowning, and get time to think, or is it all in a few heads, under deadline?
2. **Psychological safety** (Clark's 4 stages): *none → inclusion (fragile) → learner → contributor → challenger.*, *e.g.* can the quietest person say *"I don't understand this generated code"*, even to a senior or the AI?
3. **Mental health**: *isolation & anxiety → strained → uneven → belonging returns → sustainable belonging.*, *e.g.* do people feel they belong and can admit a hard day, or is it isolation and anxiety?
4. **Flow / value stream**: *overwhelmed → busy ≠ faster → bottlenecked → keeping pace → flow.*, *e.g.* does work flow to *done*, or pile up busy-but-stuck?
5. **Team cognitive load** (Team Topologies, Skelton & Pais): *load ignored → individual silos → ad-hoc collaboration → deliberate collaboration mode → managed load, clear boundaries.*, *e.g.* is each person siloed, or is the load shared, with clear boundaries?
6. **Brown-out / burn-out**: *acute risk → eroding → easing but fragile → returning → sustainable, restored.*, *e.g.* is there meaning and sustainable energy, or running on empty? (brown-out = loss of meaning; burn-out = exhaustion.)
7. **Shared mental model** (informed by Stepanović and Storey): *none / eroded → trapped in heads → partial (only with whoever's present) → pooled / shared → living artifacts (ADRs, breadcrumbs).*, *e.g.* if a key person is away, can the rest still reason about the system, or does the knowledge leave with them?
8. **Culture** (Westrum): *pathological (info hidden, shoot the messenger) → bureaucratic → bureaucratic+ → generative-leaning → generative (info flows, failure breeds inquiry).*, *e.g.* does bad news travel fast and safely, or do you shoot the messenger?
9. **↻ Feedback** (the *engine*, score it too): *feared / suppressed → trapped → synchronous, partial → pooled, fast → continuous, systemic.*, *e.g.* do you learn fast (tests, pairing, review), or is feedback slow or feared? It gets shorter & wider as you climb.

## Scoring

- **Team level = the LOWEST axis.** A chain is as strong as its weakest link, and bounded
  rationality is pooled only as well as its thinnest channel. Do **not** average, the floor is
  the diagnosis.
- Note **which axes sit at the floor** (often more than one), those are where to work.
- Note any **sharp drop** between otherwise-high axes, that's a ceiling.

## Output (give all of this, briefly)

> **Never drop bare jargon, gloss lightly by default, offer to go deeper.** Every time you name a lever or term in shorthand (*breadcrumbs; 5-/2-minute rules; ADRs; last responsible moment; YAGNI; the freed-time choice; no-AI days; walking skeleton; Ship/Show/Ask; sociable tests; CINÉ*…), attach a **short plain-language gloss inline** (~one clause, 5-12 words) so the reader gets it **without having to ask**, e.g. *"breadcrumbs (a ~2-min end-of-session note: where we landed, what's next)."* Then **offer the option to expand**, once: *"say 'explain [lever]' for the how-to."* Default = the light gloss; full operational detail (from *How to run the levers*) only **on request**. Never assume the reader knows the term, and never leave a condensed line like *"protect a slot (5/2-min rules); ADRs later"* unexplained.

- **The profile**: the 9 scores, ideally as a quick visual, e.g. a tiny text bar per axis
  (`Psych safety  ████░ 4/5`) so they can *see the shape*. Mention they can plot a 9-axis radar
  (companion figure in the self-locator doc).
- **Your level = L\<lowest\>**, give a **kind, fuller read** drawing on the matching **per-level card** (*Speak to the floor level*, below): what this environment *feels* like and what the team **gains** here *(and why it can be a trap)*; the **AI fork at this level** (▼ risk / ▲ opportunity); and **how to hold** it (don't slide down). An environment, not a verdict, a few lines, not a lecture.
- **Place them on the ladder**, a text-visual, bottom = *overwhelming / risk*, top = *augmenting / opportunity*: **bracket their level**, mark *you are here*, and point the **next rung up**. E.g. (floor at L2):
```
   ↑ augmenting (▲ opportunity)
 L5  Resilient learning organization
 L4  Pooling (sociable)
 L3  Communicating but siloed        ← your next rung
[L2] Solo amplification (fragmented)  ● you are here
 L1  Fear / toxic
   ↓ overwhelming (▼ risk)
```
  The full 9-axis **radar / heatmap** lives in the *self-locator* / *scale* PDF (https://nicolasrosado.github.io/aiagents-montreal/research/bounded-rationality/), point there for the visual.
- **Offer the same position two other ways** at the close (a lambda user won't know they're there); say e.g. *"want to see the same read by axis × level, or by transition?"*, then render it inline with **their own numbers**, using these embedded templates (shown with a floor at L2):

*By axis × level*, the nine-lens grid, each axis's rung bracketed `[n]`, the floor(s) marked `◄`:
```
                        L1   L2   L3   L4   L5
 Three bounds            .    .   [3]   .    .
 Psychological safety    .    .    .   [4]   .
 Mental health           .    .   [3]   .    .
 Flow / value stream     .    .   [3]   .    .
 Team cognitive load     .   [2]   .    .    .   ◄ floor
 Brown-out / burn-out    .    .   [3]   .    .
 Shared mental model     .   [2]   .    .    .   ◄ floor
 Culture (Westrum)       .    .    .   [4]   .
 Feedback (engine)       .   [2]   .    .    .   ◄ floor
```
*By transition* has **two sub-reads**. First the **level step**, the team's actual next move on the ladder (drawn from the *per-level cards*):
```
   ↑ augmenting (▲ opportunity)
 L4 → L5   pooling → resilient system
 L3 → L4   siloed → pooled and reviewed
[L2 → L3]  fragmented → visible: make the work visible (pair + review + ADRs)   ● your move now
             ▲ seize: private effort becomes shared, visible thinking
             ▼ watch: silos that merely share a backlog
 L1 → L2   fear → solo amplification
   ↓ overwhelming (▼ risk)
```
Then the **same step on a floor axis**, rung by rung (here Feedback, the engine; rungs and ▲/▼ from *Migrating axis by axis* below):
```
   ↑ augmenting (▲ opportunity)
 L4 → L5   pooled, fast → continuous, systemic
 L3 → L4   synchronous, partial → pooled, fast
[L2 → L3]  trapped → synchronous: share it (pairing, review)   ● your move now
             ▲ seize: faster correction
             ▼ watch: doesn't yet reach across time or the absent
 L1 → L2   feared/suppressed → trapped
   ↓ overwhelming (▼ risk)
```
- **The AI tell**, *gloss it whenever you use the term*: a **"tell"** in the poker sense, an *involuntary sign that gives away your hand*; here, a signal that reveals whether AI will **help or hurt**. Because **AI amplifies whatever already exists**, three axes weigh most: **Three bounds** (*information, cognition, time*, Simon), **Feedback**, and **Psychological safety**, **always name them with that gloss in the read-out**, never bare. If any of the three sits at **L1-L2**, warn that **AI will amplify the dysfunction (the existing gap) first**, deeper information loss (weak bounds), faster broken loops (weak feedback), or an inability to challenge the AI's output (weak safety), so raise them *before* adding more AI. **Keep it modal, a *potential* to watch, not a fixed or alarming verdict.** And if a tell-axis is your **floor but not at L1-L2**, state it plainly and calmly (neutral tone, no reassurance-by-negation, avoid phrasings like *"not in the danger zone"* or *"no alarm"*): note that it's the floor *and* one of the three that weigh most on the **AI risk**, so it's the **highest-leverage lift**, treat it first. (When you flag *"this is one of the three AI-tells,"* explain in one line that the named axis is one of the three that weigh most on the **AI risk**, the ones to treat first.)
- **Your next move** = the migration lever for the **floor** level (below), **one move, not ten**, plus **why it's worth it** (the card's *why*). Frame it as a **team experiment** (try a few weeks → a retro decides keep / adjust / drop).
- **A personal complement (offer lightly at the close, especially where mental health / isolation shows up):** beyond the team move, you *may* invite the person to reconnect through a **craft community, meetup or dojo**, a *third place* (Oldenburg), deliberate friction against the **isolation trap**, like the meetups this work grew from (the *third-place* remedy below). Personal and optional, **never imposed**; it favours the human connection AI quietly erodes.
- **Close**: *locate, don't judge*, name where you are out loud, work the lowest axis, re-run
  in a quarter. Make it a **system, not a willpower bet.** You *may* add a brief, optional
  invitation for feedback **on the tool itself** (a confusing question, a missing nuance), it's a
  living instrument. **But keep it light, and only if it fits**, don't force it. **When it fits,
  you may also share this closing note in the author's voice** (warm, never salesy): *the white
  papers and the ebook are a **gift to the community** (CC BY-NC-SA), some of it revisiting our
  everyday practices through a **mental-health lens**, with **bounded rationality** as the
  through-line. This tool isn't exhaustive; it's an attempt to bring some value and insight to
  **all teams**, and **all constructive feedback is welcome**. My hope is simply that it helps
  people **face their blockers and take better care of their mental health at work**, because
  **we work with people before we work for a company.***
  - 🚫 **Never:** no **game points, badges, XP or leaderboards**; **don't rank teams** against each other; don't tie the level to **performance reviews, OKRs or incentives**; don't **promise fast progression** (culture changes slowly); don't turn it into a **score, target or status reported up to management**. It's a **locator, not a KPI**, compare only to your own past self.
  - ⚠️ **Do not mistake the team's own answer-refinements for product feedback.** When someone
    corrects *their* assessment mid-session (e.g. *"actually it's the **time** bound that's tight,
    not information"*), that's **normal locating**, a sharper read of *their* situation.
    Acknowledge it as **their** insight about **their** team; **never** recast it as *"feedback
    that improves the next version of the skill."* Product feedback = a comment about the **tool**
    (its wording, flow, usefulness), not a user updating their own answer.

### The session output to keep - the Team Maturity Snapshot (offer at the close)

At the close, **offer** to hand the team a **Team Maturity Snapshot** they keep (one artifact: a header + Posture + Waypoint + ADR + a usage-and-license footer; nothing is stored, the skill is stateless). The score is a **private waypoint, not a grade**, it exists only to feed the team's *own* next comparison. **Non-negotiables:** (a) **the output opens with the snapshot header (title + what's inside), then MUST lead with the POSTURE header once, before any numbers**, **reproduced *verbatim*** (copy it word-for-word from the block below, **never paraphrase, shorten or reword it**), then the waypoint and the ADR follow; **do not repeat it before each block.** *(Why it's mandatory: a waypoint **is** a comparison artifact, a comparison **to your team's own past self, never to other teams**, and any comparison already invites the ranking prism, so the anti-ranking frame must travel with the numbers, never after them.)* An output (or any exported file) without it is invalid; (b) the ADR is **always a `PROPOSED` draft**, you *propose*, the **team ratifies** (they name the owner, set the review date, and change the status themselves); (c) if a prior waypoint was pasted at the open, add a short **trajectory** read, an arrow per axis (↗ climbed / → held / ↘ slipped) + **time elapsed** + whether the prior move was kept, comparing the team **only to its own past self**; **never** points, badges, rankings, or another team. **(d) Emit each block exactly once**, whether you write it to the saved file or show it in the chat: once you have printed a block's `=== END ... ===` (or `=== END POSTURE ===`) marker you never output that block again; if you find yourself about to repeat any block or line, stop instead.

**Channel display vs saved artifact (this is the anti-repetition measure, keep the on-screen output short).** The **saved `.txt` file is the full artifact** (header + POSTURE verbatim + Waypoint + full ADR + footer): complete and valid per (a), it is the canonical thing that travels, so write it to a file with the export tool when the host has one, rather than dumping it into the chat. **In the chat channel, show only a lean preview, never the whole artifact:** (i) a **one-line frame** first, `A locator, not a grade - an environment, not a verdict; compare only to your own past self. The full Posture, usage/license terms and ADR notes are in the saved .txt.`; (ii) the **Waypoint block** (verbatim, it is the essential continuity data); (iii) the **ADR core** only, its `#` title, `Status`, `## Context`, `## Decision`, `## Why`, `## Consequences`, and the Owner / Review-date blanks; (iv) a **two-line ADR-notes summary** in place of the ADR's closing explainer block: `(Proposed draft, the team ratifies it: name an owner, set the review date, flip the Status. It is an experiment-commitment to TRY and REVIEW, never a score, target or KPI. Full notes in the saved file.)`. **Do NOT print inline** the snapshot header, the full POSTURE block, the ADR's full closing notes, or the usage/license footer, **offer them on request instead**, as **selectable options** (per the hand-back rule above), and **label each by the user's *need*, never by tool jargon** (adapt to the session language). Use plain, need-naming labels, and give each a short **hook (a why-it's-worth-it), not a flat descriptor**, so it invites exploration, such as **"Read the full Posture"** (*how to keep this a conversation you compare only to your own past self, not a grade or a target that dies the way story-point estimates did in water-scrum-fall*) for the POSTURE block, **"Am I allowed to use this with my team, or a client?"** (or *"What can I do with this Snapshot?"*) for the usage/license footer, and **"What's an ADR, and how do I use this one?"** for the ADR's closing explainer notes. **Never** offer them as *"show posture" / "show license" / "show ADR notes"*, those mean nothing to the user and no one will pick them. The one-line frame **must always precede the inline numbers** (never a bare Waypoint), which satisfies (a) on screen while the complete framing lives in the saved file.

> **On `disagreements`:** capture where the team split most on a rung, and frame it as an **ambiguity to explore *together*, not a vote to settle** (the **Example Mapping** spirit: the team's own "red-card" questions, the implicit assumptions surfaced collectively). Divergence is the **signal**, not noise.

**(1) SNAPSHOT HEADER, at the very top (names the artifact + lists what's inside):**
```
=== TEAM MATURITY SNAPSHOT (format v1) =======================================
A private read of where your team sits on the Bounded-Rationality Maturity
Scale, plus the single next move to try. A locator, not a grade or a KPI -
compare the team only to its own past self.

What's inside:
  1. Posture            - how to read this (required; read first)       - block: POSTURE
  2. Waypoint           - your position on the 9 axes + continuity data - block: === BR-LOCATOR WAYPOINT ===
  3. ADR                - the suggested next move (proposed record)     - block: === BR-LOCATOR PROPOSED ADR ===
  4. Usage & license    - what you can do with this snapshot            - the footer below
=============================================================================
```

**(2) POSTURE, required once, right after the header and before any numbers (and in any exported file); not repeated before each block:**
```
=== POSTURE (read first - REQUIRED; an output without this block is invalid) ===
Each level is an environment, not a verdict. A low score is rarely the people, usually the environment: information loss across people, time and handoffs
(work passed from one person or team to the next).
Suggest, never impose (reactance): a move to try, never a verdict to obey.
This is a support for a conversation, not a score to report or a target to hit:
compare the team only to itself over time (never to other teams). Where the team
splits on a rung is an ambiguity to explore together, not a vote to settle, the signal to talk about. The moment a rung becomes a commitment or a status,
it dies the way story-point estimates did in water-scrum-fall (turned from a conversation into a commitment).
Never: no game points, badges, XP or leaderboards; don't rank teams against each
other; don't tie the level to performance reviews, OKRs or incentives; don't
promise fast progression (culture changes slowly); don't turn it into a score,
target or status reported up to management. It is a locator, not a KPI - compare only to
your own past self.
(Shared under CC BY-NC-SA 4.0, (c) Nicolas Rosado - full usage terms in the "Usage & license" footer below. Please keep this spirit travelling with it.)
=== END POSTURE ==============================================================
```

**(3) The waypoint, re-ingestible next time (`date` required):**
```
=== BR-LOCATOR WAYPOINT (format v1) - BR = Bounded-Rationality; a private waypoint, not a grade ===
date: <YYYY-MM-DD>            # required - used to compute time elapsed next run
team: <internal label>       # never aggregated or compared to other teams
axes:                        # the 9 scores, 1-5
  three_bounds: _
  psych_safety: _
  mental_health: _
  flow: _
  team_cognitive_load: _
  brownout_burnout: _
  shared_mental_model: _
  culture: _
  feedback: _
level: L<lowest>
floor: [<lowest axis / axes>]
disagreements: [<where the team split most>]   # ambiguities to explore together, not a vote to settle - the Example Mapping spirit
move: "<the one proposed move>"
review_on: <team-set date>   # required
adr: ADR-DRAFT-<date>
note: paste this back next time to see what CHANGED (↗/→/↘) - for your team only.
=== END WAYPOINT =============================================================
```

**(4) A draft ADR, modal; the team ratifies (never emit it as decided):**
```
=== BR-LOCATOR PROPOSED ADR - a draft to decide on together, not a ready-made decision ===
# ADR-DRAFT - <date> - Proposed move: <move>
Status: PROPOSED (draft - the team decides together: accept, change, or drop)

## Context
<a reading, not a verdict: the floor + why it caps the whole profile>.

## Decision - the proposed experiment (to confirm together)
<the move>.

## Why
<the reasoning - why this move, over which alternative; the part the code can't carry>.

## Consequences
- Now: <what it costs or changes immediately - e.g. ~1h/week, a facilitator, a repo home for the ADRs>.
- You might keep it if: <a concrete signal it's helping>.
- You might drop / adjust it if: <it fades by the review date>.

Owner (named by the team): ______
Review date (set by the team): ______   # suggested horizon: next re-locate (~1 quarter)

This is a suggestion from the Team Maturity Self-Locator, not a decision. It becomes real only when the team
accepts it - then change Status to "Accepted / Trying". Suggest, never impose.
Disagreement while deciding is healthy - an opportunity to clarify the ambiguity
together and foster collaboration; safe dissent is a sign of psychological safety.
New to ADRs? An ADR is a short record of a decision and its WHY, so the team
remembers and can revisit it later - a memory, not a contract.
This ADR does NOT break the tool's rule against scores, boards and KPIs: that rule is
about the NUMBER (your level) - you never turn the measure into a target (Goodhart's trap:
once a measure becomes a target, it stops measuring anything). The ADR measures
NOTHING - it only traces a decision to act.
So this is an EXPERIMENT-commitment, not a result-commitment: the team commits to
TRYING it and REVIEWING on the date above - not to hitting a number or a deadline.
If it doesn't help, adjust or drop it: that's learning, not failure. Never convert it
into a KPI, a target, or a status reported up to management.
(The temptation to turn an experiment into a result-commitment is strong - especially
if ADRs are new to you - so it is named here, on purpose, to defuse it.)
=== END ADR ==================================================================
```

**(5) Usage & license footer - the FINAL block; end the output (and the exported file) with it. After its last line (the terms URL) you are DONE: never re-emit the ADR, the footer, or any earlier block, and never loop back into a block whose `=== END ... ===` marker you have already printed. The whole Snapshot is printed once, top to bottom; then nothing follows.**
```
--- What you can do with this Team Maturity Snapshot - CC BY-NC-SA 4.0 - (c) Nicolas Rosado ---
This Team Maturity Snapshot (Posture + Waypoint + ADR) is for your own or your team's reading.

  Use it inside your own team, for yourselves ..............  OK, free
  Read it to form your own view (even as a consultant) .....  OK, free
  Share or publish it (non-commercial) .....................  OK, with credit to the author
  Give it to a client as a paid deliverable, or sell it ....  NO - commercial, not allowed under the free license; needs the author's permission
  Build it into a paid product / service ...................  NO - commercial, not allowed under the free license; needs the author's permission

The line is about the OUTPUT - what gets shipped - not your intentions:
keep it for yourselves / non-commercial = free; but a paid deliverable or a sale - even one
your own team produces - is commercial, which the free license does NOT allow: you need the author's permission first.

Cited authors keep their rights - don't re-attribute their ideas or words to yourself.
Part of the Bounded-Rationality Research Suite: https://nicolasrosado.github.io/aiagents-montreal/research/bounded-rationality/
Using the skill itself through your agent, or redistributing / adapting it - full terms:
https://github.com/nicolasrosado/team-maturity-self-locator#using-this-under-the-license
```

**Offer to export.** After showing them, **offer to save the whole Team Maturity Snapshot as a plain-text `.txt` file** the team keeps, e.g. `<team-slug>_maturity-snapshot_<YYYY-MM-DD>.txt` (team label first, then the artifact type). **Ask for a short team label** (it fills the `team:` field and the filename; it is **slugified for the filename**: lowercase, strip accents, spaces to hyphens, drop punctuation - e.g. "Mon Équipe" becomes `mon-equipe`); if they'd rather not name it, **default to `team`** (`team_maturity-snapshot_<date>.txt`), only an internal marker, never compared to others. The `date` unit is the **day** (this is a quarterly tool); if more than one is generated the same day, add a short time suffix like `-1430` to keep them distinct, seconds aren't needed. At the next run they **paste the Snapshot back, or load the file**, and the skill reads the **`BR-LOCATOR WAYPOINT` block inside** (that block *is* the continuity input format; the skill keys off it, not the filename, so older `maturity-waypoint-*` files still load). Nothing is stored on our side. *(Keep the Snapshot `.txt` so it pastes back / reloads **verbatim**, it's already readable; a markdown viewer would only reflow the `===` / `#` / indentation and risk breaking the round-trip. A logbook you *read* rather than re-ingest can be `.md` if you prefer it rendered.)* **At the close (both right after the lean preview and after every on-request reveal), always hand back a clickable selection picker, never a prose list nor a bare prose "anything else?".** Offer up to ~4 options, phrased by the user's need (labels above), drawn from: the blocks not yet shown (**"Read the full Posture"**, **"Am I allowed to use this with my team, or a client?"**, **"What's an ADR, and how do I use this one?"**), the still-useful explorations (**"Zoom the floor axis"**, **"See it another way (axis x level / by transition)"**, **"More levers"**), and **always a "Done, take the file"** option. If more remain than fit the picker, name the rest in one short line. **After showing any requested block, offer the picker again** (remaining items + Done) so the person keeps exploring; **never end the turn on a prose question**. Only fall back to a short labelled text list if the host has no picker.

**Showing an example (not an assessment).** If someone asks to *see* what a Team Maturity Snapshot (its Waypoint and proposed ADR) looks like, rather than to be assessed, show the worked example in **the "Example output" section at the very end of this skill**. It is **ILLUSTRATION ONLY**: its scores are invented to show the *format*, not a real team. **Never** analyze those numbers, **never** ingest it as a waypoint, **never** let it influence a real read, a real read comes only from the user's own answers, live in the session. Only reach for it when the ask is explicitly "show me an example"; otherwise ignore it.

**The words (a quick glossary - use to explain these terms if asked):**
- **Team Maturity Snapshot** - the whole output kept at the close (a self-describing header + Posture + Waypoint + ADR + a usage/license footer). Nothing is stored (the skill is stateless).
- **Posture** - the required reading-frame at the top: environments, not verdicts; a locator, not a KPI.
- **Waypoint** - the *dated* position (the 9 scores, level, floor). The block pasted back next time for the trajectory.
- **ADR** - the proposed next move as a draft *decision record*; the team ratifies it (accept / change / drop), never emitted as decided.
- **Trajectory** - the change read when a prior Snapshot is re-loaded (an arrow per axis + time elapsed), compared only to the team's own past self.
- **Logbook** *(carnet de route)* - the running file where the team keeps its successive Snapshots: its history, a memory aid, not a report.

## Speak to the floor level (per-level cards)

Once you've computed the floor, don't jump straight to the move, first **speak to the team about where they honestly are**: what they gain here, what AI does to them right now (▼ risk / ▲ opportunity), how to *hold* (and not slide back), then the **one move up** and why it's worth it. Read only the card for their floor level.

### When the floor is L1 - Fear / toxic
The floor. Blame, silence, hidden mistakes; a *pathological* culture (Westrum), information is a weapon and messengers are shot.
- **At this level**, psychological safety: *none* (below inclusion), no one speaks up; the three bounds: information hidden (the illusion of full info), cognition unchallenged, time burned on self-protection.
- **What you'd gain by leaving:** the right to *exist and belong* without fear, everything else is built on it.
- **AI right now:** ▼ risk, a fear culture + a force multiplier ships fear faster; ▲ opportunity, the moment one act of leadership vulnerability lands, the same multiplier can carry safety instead.
- **Hold the line:** leadership models fallibility out loud; *"hard on the work, kind to the person"*; *assume best intentions*, applied consistently.
- **The attitude that makes safety real:** even here, feedback (including leadership's own) must be *given so it can be received* (kindly, *be impeccable with your word*) and *received without taking it personally*, or reactance pushes people back into fear.
- **The one move → L2:** *make it safe to be here*, one visible act of leadership vulnerability, repeated until people believe it.

### When the floor is L2 - Solo amplification (fragmented)
Not necessarily toxic, but everyone works alone; AI lets each person **shut themselves in** longer before anyone notices.
- **At this level**, psychological safety: *fragile inclusion* (you belong, but not yet safe to learn out loud); the three bounds: information trapped in single heads, cognition debt accruing silently, time lost re-learning what a teammate already knew.
- **What the team gains here:** raw individual speed and autonomy. It *feels* productive, which is exactly why it's a trap: volume is not value.
- **AI right now:** ▼ risk, it lets people withdraw into isolation (silos that happen to share a backlog); ▲ opportunity, pointed at pairing and reviewable work, the same speed turns private effort into shared, visible thinking.
- **Hold (don't slide back to L1):** keep asking and offering help visible; normalize *"I'm stuck"*; protect a little slack so people aren't forced back into heads-down survival.
- **The attitude that makes visibility stick:** visible work means *review*, i.e. feedback. Give it so it can be **received** (suggest, kind, *be impeccable with your word*) and take it without defensiveness (*don't take it personally*), or the new visibility triggers reactance and people retreat into silos. Safety opens the door; the attitude keeps it open.
- **The one move → L3:** *make the work visible*, pair sessions, code review, a shared place where decisions and reasoning live. **Why it's worth it:** you stop re-learning what a teammate already knew, and the loneliness drops.

### When the floor is L3 - Communicating but siloed
The team *talks*, but the shared mental model is held only with whoever happens to be present.
- **At this level**, psychological safety: *learner* (questions welcome; challenging the status quo still feels risky); the three bounds: information shared but only synchronously/partially, cognition only partly cross-checked (a second mind tests the reasoning sometimes, not systematically), time the binding one (absent/async members quietly overruled).
- **What the team gains here:** it starts to *feel* like a team, less lonely, some shared context, faster unblocking.
- **AI right now:** ▼ risk, it accelerates the scatter-gather problem (work fragments faster than it's gathered back); ▲ opportunity, channelled into durable, inclusive decisions (ADRs, breadcrumbs), the same volume becomes a shared record instead of scattered output.
- **Hold (don't slide back to L2):** make a standing habit of writing decisions down and inviting the absent, so *"we talked about it"* doesn't quietly mean *"a few of us did."*
- **The one move → L4:** *make decisions durable & inclusive*, ADRs / written decision records, breadcrumbs, a protected window to challenge before anything locks. **Why it's worth it:** nobody is overruled in a room they couldn't attend, and the knowledge stops evaporating overnight.

### When the floor is L4 - Pooling (sociable)
The team actively **pools** its bounded rationality, and comprehension keeps pace with production.
- **At this level**, psychological safety: *contributor*, reaching toward *challenger*; the three bounds: information pooled (onboarding approaching instant), cognition widened (an expert's blind spots covered by a junior's beginner's mind), time protected by durable decisions.
- **What the team gains here:** **belonging and collective ownership**, *"the team validated it, not the individual."* People can safely say *"I don't understand this generated code,"* review keeps up, and flow returns.
- **AI right now:** ▲ opportunity, the team stays the judge; the AI is one more voice (agent-in-the-driver's-seat, LLM-as-a-mob-member), never the verdict, amplifying collective judgment; ▼ risk, entropy: without held rituals, the pooling quietly slides back.
- **Hold (don't slide back to L3):** rotate facilitation so pairing/mobbing isn't carried by one champion; keep the ground rules visible; treat *share the air* as non-negotiable so the quietest voice still lands.
- **The one move → L5:** turn the practices into *systems*, make pooling the default, not a willpower bet. **Why it's worth it:** the team's health stops depending on who's motivated this sprint.

### When the floor is L5 - Resilient learning organization
Pooling is sustained by **systems, not willpower**, and the team actively *widens* its bounds.
- **At this level**, psychological safety: *challenger* (anyone, even the quietest, can say plainly that an AI's output is wrong); the three bounds: all three deliberately *widened*, information externalized in living artifacts, cognition grown by ritual practice, time protected.
- **What the team gains here:** **collective knowledge that survives** people, interruptions, and AI acceleration; sustainable **flourishing**, the team grows its juniors into seniors, making better versions of its people, not just more code. This is the emancipation the whole scale is for.
- **AI right now:** ▲ opportunity, it augments: speed pointed at the real constraint and at **value, not volume**, amplifying the team's growth; ▼ risk, complacency: there is no "arrived"; entropy always pulls downward.
- **Hold (continuous improvement, no "arrived"):** keep the rituals even when busy; measure flow *and* comprehension (and beware **Goodhart's law**, once a measure becomes a target it stops being a good measure: don't let velocity, coverage or lines-of-code turn into the goal); respect the day's ceiling and the anxiety signal; keep the door open to the absent. L5 is a practice, not a trophy.
- **Keep growing:** there's no Level 6, only deeper mastery, **mentor other teams**, and let the scale itself keep evolving with what you learn. *(If the team's comfortable and wants to push the craft further: Paul Hammond's **red-green-mutate-refactor**, TDD plus mutation testing, catches hollow assertions before they ship; **Antony Marcano's Test-Driven Agentic Behaviours (TDAB)** push it *upstream*, drive the agent's behaviour test-first by **encoding the restraint**, so it writes *just enough to pass* in the first place; fewer hollow tests slip in, and fewer mutants even need generating.)*

## When several floor axes disagree

The floor is often more than one axis. When those axes point to the **same** move, give it (e.g. *make the work visible* lifts cognitive load, shared mental model and feedback together). When they point to **different** moves:

1. **Prefer the move that unblocks the most floor axes at once**, leverage over completeness.
2. **If no move dominates**, name the 2-3 candidate moves and let the **team pick the one that costs them the least right now**, ownership beats optimality; a move they choose is a move they'll actually do.
3. **Still give exactly one move.** Never hand them a list of ten, the discipline of this tool is a single next step.

## Frame every move as a team experiment

The move is a **hypothesis to run together**, never a prescription. Tell the team: try it for a
few weeks, then let a **shared ritual decide *as a team*** whether to keep, adjust or drop it, a
**retrospective** is the minimum loop, an **ADR** keeps the decision living. Only the team's own
experience confirms whether a move fits *their* context (this mirrors the *reactance* caveat: no
"you must", try, inspect, adapt).

**Name the bootstrapping catch, experimentation is itself maturity-dependent.** Experimenting
collectively, and letting living feedback decide, is a high-maturity habit. At **L5** it's held by
the system (momentum + discipline); at **L4** it rides on motivation/willpower and dissipates when
energy dips; **below L4** nothing holds it. So until the system carries it, the team must **supply
the discipline by hand**, stopgaps while climbing:
- **A driving owner, better a small guiding coalition**, naming the key actors and forming a
  coalition is the classic change move (Kotter's guiding coalition, Lewin's *unfreeze*) that
  *lowers resistance*; treat it as **willpower as a temporary scaffold**, not the destination.
- **One ritual to hold the loop**, a lightweight retro (no retro yet? that's the first scaffold).
- **Make it explicit & visible**, a written hypothesis, an agreed "what would make us keep it,"
  a review date, a shared place for notes, so the call is collective and doesn't evaporate.
- **Borrow external cadence**, a coach/facilitator/manager holds the ritual until it self-sustains.

The destination is to **anchor the practice in the system and culture** (Lewin's *refreeze*),
where motivation is no longer load-bearing, the L4 → L5 shift.

## Name the choice when time is freed

Whenever a move, or AI itself, hands the team time back, surface that this is a **choice**, not an
automatic outcome. The team can spend the reclaimed hours three ways:
- **produce more** (acceleration, *more in the same time*),
- **do the same, better** (raise craft, pay down debt, strengthen the system), or
- **reclaim it**, *the same in less time* (rest, learning, a calmer day for themselves, or **give some back to the team** like **growing the juniors**).

This is the **freed-time choice**, between *accelerating* (more in the same time) and *automating* (the same in less time). By default most teams pour freed time straight back into more output, the **Jevons paradox** (a.k.a. the **rebound effect**: efficiency gains get re-spent as more output, not reclaimed), which quietly amplifies the overwhelm the tool gives back. The counter is **Tom DeMarco**'s case for deliberately protecting the freed capacity rather than filling it. Make the choice **explicit and collective**, for a
tool about sustainable teams that work well together, *who decides where the time goes, and toward what,*
is part of the move.

That last option, **growing the juniors**, is especially high-leverage: mentoring and reviewing *how they work* (their reasoning, their design choices, the steps they took, not just the finished code), so you correct the approach, not only the deliverable. A concrete signal to watch (**Julie Baillon**): the **time it takes a junior to become autonomous**, if it stretches once the team leans on AI, that's the cue to reinvest in mentoring; her one-to-one prompt, *"what did you have to fix in an AI-generated production this week?,"* surfaces it. Because AI now does the low-stakes tasks juniors used to learn on, reinvesting freed time here is one of the best ways to prevent, or repair, the junior competence gap and the broken path to senior (developed in the ebook and *Augmenting or Overwhelming?*). And it isn't only for the juniors: another way to **give that time back to the team** is **learning hours** or **katas**, which keep the whole team's knowledge sharp enough to still understand, and judge, what the AI generates (the guard against knowledge debt).

## Deep-dive when psychological safety (axis #2) is the floor

If **axis #2 (psychological safety)** sits at or near the floor, offer an optional **four-stage zoom**
(Timothy R. Clark, on Amy Edmondson's psychological safety). Safety is **cumulative**, inclusion →
learner → contributor → challenger, so walk them **in order** and find the **lowest** stage; that's
the foundation gap, not the top.

- **Inclusion** *(I belong)*, are the quietest and the newcomers actively drawn in?
- **Learner** *(I can ask, try, be wrong)*, can someone say *"I don't understand this, including AI-generated code"* without it counting against them?
- **Contributor** *(my skills count)*, judged on the work, trusted to decide, credit shared?
- **Challenger** *(truth, even upward)*, can the quietest person say an AI's output, or a senior's call, is wrong, and be heard?

**Hybrid depth, light by default, drill only when needed.** Ask the **4 summary questions above first**. **If a stage is the lowest, borderline, or the answer is unsure, drill into its 5 statements** (one at a time) to pinpoint exactly what's missing, otherwise stay light (don't ask all 20). **Format (important): state the claim *first*, then ask the rating**, e.g. *"When I join late or remote, someone brings me up to speed." → your read: true; somewhat; false?* The **statement leads** so the rating has a clear referent, and the user just answers *true/somewhat/false*. **Do NOT list a/b/c variants each pre-tagged true/somewhat/false with its own example**, that hides the statement and confuses (you end up picking a letter when you meant to rate the claim). The per-stage statements:
- **Inclusion:** newcomers & the quietest are *actively* drawn in; I can be myself here (background, doubts, style); someone brings me up to speed when I join late/remote; disagreement is about *ideas*, never belonging; I'd feel safe admitting a personal limit (energy, a hard day).
- **Learner:** I can say *"I don't understand this, including AI-generated code"* without it counting against me; questions are welcomed, none too basic; mistakes are *information*, not something to hide; I can try, get it wrong, and say so; asking for help is normal.
- **Contributor:** my work is judged on the work, not seniority; I'm trusted to use my skills and make real decisions; credit is shared fairly; I get useful feedback when I ship, not silence; I have enough autonomy.
- **Challenger:** the quietest can say an AI's output, or a senior's call, is wrong, and be heard; I can flag a confident-looking mistake without fear; we can question *how we work*; bad news travels fast (no shooting the messenger); I can disagree with the most powerful in the room.

**The AI tell:** if **Learner** or **Challenger** is low, the team can't yet challenge the AI, flag it as
the costliest blind spot of the AI era. **The move follows the lowest stage:** Inclusion → a visible act
of leadership vulnerability, repeated; Learner → normalize "I don't know" + a weekly learning hour;
Contributor → rotate ownership, share credit; Challenger → a protected window to dissent before a
decision locks. (The full statement battery lives in the self-locator's axis-#2 deep-dive.)

**Name why people go silent, and treat it as a prerequisite.** Two *rational* forces keep people quiet: **imposter syndrome** (the gap between what you can do and what you think you should know widens when the AI seems to "know everything") and Crozier's *defensiveness is a rational read of personal risk, not bad faith* (the observer's side: resist the **fundamental attribution error**, Ross, and read the **situation**, not the person's character; that's **bounded rationality turned on other people**). And the *risk* people read is rarely disciplinary, it's the **personal** risk of speaking up, which we're all wired to protect against. So the real work is lowering that risk, not just removing formal penalties. Since the stages, and the scale, are cumulative, **clearing this gates the climb**: a team can't move up while *"I don't understand this"* stays unsayable. So when it blocks the floor, **propose lowering that risk as the prerequisite move** (inclusion/learner), with empathy, lower the risk, don't push. **For a group already in conflict**, reset the field first: **ground rules** (assume best intentions; share the air; hard on the work, kind to the person), the **Four Agreements** (Ruiz, *don't take it personally*), and a **facilitated fishbowl / mediation** (*The Power of Strangers*, Keohane).

This is one slice of a larger principle: **the skill draws its concrete moves from the ebook's full toolbox**, start-with-a-test, small steps, TBD, pairing/mob, sociable tests, learning hours, katas, no-AI days, breadcrumbs, ADRs, the CINÉ stress model & graduated exposure, the 5-/2-minute rules, proposing the lever that fits the floor lens. Locate first, then offer the matching lever(s).

## Optional zooms for other floor axes

Some floor axes have a natural sub-structure worth a quick (conversational) zoom, keep it light. **A zoom is *interactive*: ask the sub-questions and wait for the team's answers, then name the lowest sub-element, never just describe the structure. **Ask each sub-item *one at a time*, as a simple multiple-choice pick, give the options explicitly (e.g., *present; slow/feared; absent*) so the user just picks one, never has to format a long answer.** **UX maxim for the whole session: filling it must feel *pleasant*, formatting is useless friction. Always offer pick-one choices, one item at a time, minimal typing (a letter or a number is enough). Keep every option in the **`▎ notion, « example »`** format (a short label + a first-person illustration), like the axes, for axes *and* for zoom sub-questions. **Exception, true/somewhat/false rating statements (e.g. the psych-safety battery): state the claim *first*, then ask the rating; never dress each rating level as a separate lettered option, which hides the statement being rated.** **When several axes tie at the floor, zoom *each* floor axis that has a sub-structure**, psychological safety (4 stages), three bounds, feedback, shared mental model, don't skip one because the headline move is elsewhere; walk the lowest first.

- **Three bounds at the floor**, ask *which* bound is tightest: **information** (the team can't see what it needs), **cognition** (too much to hold at once), or **time** (no room to think). Target the tightest one.
- **Feedback at the floor**, ask *which loops are missing or too slow*: tests (seconds), pairing (instant), review/ADRs (across people and time). Add or shorten the missing loop first.
- **Shared mental model at the floor**, name the two debts behind it (Storey's **triple-debt model**): **cognitive debt** (understanding trapped in heads) and **intent debt** (the *why* never written down). This tool exists partly to *help solve* this: prompt the team to **question and capture the *why***, externalize it in **ADRs** and keep it shared in real time (pair/mob), so intent never lives in a single head.

## Remedy library - match the floor lens to an ebook lever

Once the floor is located, **suggest** (never impose) the lever(s) from the ebook's toolbox that fit it. Locate → understand why it's stuck (not the people, the environment) → restore safety if needed → suggest the matching lever to *try*, then let feedback decide.

1. **Three bounds**, *information*: ADRs / breadcrumbs, context engineering (deliberately curating what context the agent and team see), a shared glossary; *cognition*: small steps, small reviewable diffs, ports & adapters to isolate, **avoid premature optimization** (YAGNI; *stay close to the code*, Lopez, to catch it early); *time*: the 5-/2-minute rules, protect capacity, last responsible moment.
2. **Psychological safety**, ground rules, the Four Agreements, fishbowl / mediation (for conflict); a visible act of leadership vulnerability; normalize *"I don't understand"*; a weekly learning hour. *(Imposter syndrome → name it; Burns' cognitive distortions.)* And safety is built **gradually**, the way *graduated exposure* builds tolerance: step by step, through the small everyday moments that let it grow. Use it both to **hold** a level and to **climb** one (and note: remote/hybrid quietly removes those informal moments, so the culture has to supply them deliberately).
3. **Mental health**, the **CINÉ** stress model + graduated exposure, the wheel of emotions, control-based strategies, diaphragmatic breathing; break isolation with pairing/mob; **and, as a personal complement, offer it when isolation shows up, a *third place* (Oldenburg): invite reconnection through a craft community, meetup or dojo, deliberate friction against the AI-era *isolation trap* (easier to ask the AI than a teammate); it favours the human connection AI erodes** (personal, optional, never imposed); no judgment. *(Sources: CINÉ → **Lupien / CESH** (glossed below); cognitive distortions → **David Burns**; control-based coping → **Lazarus & Folkman**; the wheel of emotions, graduated exposure and diaphragmatic breathing are established clinical tools. Full per-tool sourcing in the ebook; the ebook's *The isolation trap* goes deeper.)*
4. **Flow / value stream**, look at the *whole* value stream (not the keyboard); small batches, TBD + feature toggles, Ship/Show/Ask, a walking skeleton; limit work-in-process.
5. **Team cognitive load**, clear boundaries (ports & adapters, domain isolation), deliberate collaboration modes, pairing/mob to share the load.
6. **Brown-out / burn-out**, protect meaning and capacity; learning hours, no-AI days; **reclaim** the time AI frees, and let the **team decide** how to spend it (the **freed-time choice**, acceleration vs automation: produce more / do it better / take time back; Jevons paradox / Tom DeMarco); control-based strategies.
7. **Shared mental model** *(informed by Stepanović, cognitive debt; drawing on Storey, intent debt)*, ADRs + breadcrumbs (capture the *why*), pairing/mob, sociable tests (express behaviour), a maintained glossary; question the *why* before coding. (The **Knowledge Silos** anti-pattern, *Beyond MinimumCD*, Bryan Finster, names the same L2 failure: understanding trapped in one head; the cure is the same, pair/mob, ADRs, a shared model.)
8. **Culture (Westrum)**, ground rules, blameless reviews, share-the-air, don't shoot the messenger; make information flow.
9. **↻ Feedback (engine)**, shorten/widen the loop: start-with-a-test, sociable tests, mutation testing, TBD, pairing (instant), code review + Ship/Show/Ask, ADRs (across time), the red checkpoint (pause at the failing-test *red* to review the design the test implies *before* generating code); and the **technical baseline** that makes feedback *systemic*, **MinimumCD** (Bryan Finster / minimumcd.org): TBD + CI on every commit + automated tests + one deployable, immutable artifact + the pipeline as the only path to production, so the deploy loop itself becomes fast, reliable feedback.

**Cross-cutting, guard against AI over-dependency** (Lopez): keep the muscle alive, **no-AI days, katas, learning hours, deliberate practice**; the operational test: *can you handle a 3 a.m. incident without tokens?*; **master the patterns yourself** and **stay close to the code**; beware vendor lock-in (the more you delegate, the more dependent). And the **golden hammer**, don't make AI (or any one pattern) the answer to everything. And the **cargo cult** (Feynman), reproducing the *form* of a practice (green-but-empty tests, ceremonies, AI output no one understands) without the *why*; the cure is always to question the *why*.

These levers come from the practitioner ebook *How to Reduce Your Daily Stress in the Software Industry*; named frameworks are credited to their authors. Offer one or two that fit, never a checklist of all of them; but **if they'd like more (especially on a re-run), surface other matching levers**, don't cap them at two.

**Lever glossary** (the less-obvious ones, one line each, operational steps are in *How to run the levers* below; the deeper story is in the ebook):
- **Ship / Show / Ask** (William Bernting; Martin Fowler), a review gradient: *ship* trivial changes straight to main; *show* via a PR you merge yourself while inviting comment; *ask* for explicit review when risky.
- **Sociable tests** (Martin Fowler), tests coupled to *behaviour*, not implementation, so they don't break on every refactor (vs brittle/solitary tests).
- **Walking skeleton** (Alex Bunardzic), a thin end-to-end slice that *runs* first, then grows, so there's always something working to steer from.
- **Breadcrumbs** (Zuill & Herr), short written notes left for teammates and your future self, carrying the mental model across handoffs and time zones.
- **No-AI days** (Arthur Magne), a regular day coding without AI, to keep the underlying skill alive and avoid token-dependency.
- **Katas / learning hours**, protected deliberate-practice time (katas = small repeatable exercises) to *grow* skill, not just ship.
- **CINÉ** (Sonia Lupien / CESH), the stress recipe: low **C**ontrol; **I**mprédictibility (unpredictability); **N**ovelty; threatened **É**go; the more boxes ticked, the more stress. Antidote = **graduated exposure** (rank triggers least→most, expose step by step).
- **Ports & adapters / hexagonal**, isolate the business core behind a port so technology can change without touching the domain (and juniors can work in isolation).
- **MinimumCD** (Bryan Finster / minimumcd.org), the *minimum* technical practices required for Continuous Delivery: trunk-based development, CI on every commit, automated testing, a single deployable/immutable artifact, the pipeline as the only path to production. The deploy pipeline becomes a **fast, reliable feedback loop**, the technical floor under axis #9's *continuous, systemic*. Its companion **Beyond MinimumCD** catalogs **anti-patterns ranked by quality impact** (so a team can prioritize what to fix first), e.g. **Rubber-Stamping AI-Generated Code** (*Critical*: approving AI output without genuine review because it *looks* right or CI is green = our central AI risk → *cognitive surrender* (Addy Osmani) / Lopez's *black box* / AI test theater) and **Knowledge Silos** (understanding trapped in individuals, our axis #5/#7 L2), beyond.minimumcd.org/docs/anti-patterns/. **Frame it as a *direction to grow toward*, not a switch to flip**, reaching CD is the hard part, so suggest it (never impose, reactance) and work the *how* incrementally: pick the one practice the team can hold now (e.g. CI green on every commit, or trunk-based development), make it stick, then add the next.

## How to run the levers - operational

*Enough to **act from the skill alone**; the ebook goes deeper (stories, evidence, nuance) for those who want more. Suggest one or two that fit the floor, never a checklist.*

**Feedback & safety**
- **Blameless retrospective**, 30-60 min, regular cadence. Gather: *what went well; what was hard; what to try.* Use **anonymous input** (sticky notes / a form) when safety is low. Rule: *hard on the problem, kind to the person*, name the system, not people. Leave with **one** experiment to try; review it next time.
- **Ground rules**, a short set of working agreements the team **decides together and posts visibly**, e.g.: *assume best intentions* (read others' acts charitably); *share the air* (the quietest voice still lands); *hard on the work, kind to the person* (critique ideas, not people); *no question is too basic*. Revisit and adjust when one is broken, they're the team's, not imposed.
- **The Four Agreements (Don Miguel Ruiz)**, four personal rules that lower interpersonal friction: *be impeccable with your word* (say what you mean; don't gossip); *don't take anything personally* (others' reactions are about them, not you); *don't make assumptions* (ask, don't guess); *always do your best* (and your best varies day to day, no self-flagellation). Lean on *"don't take it personally"* to defuse defensiveness. *(Enough to use as-is; the fuller treatment is in the ebook and Ruiz's own book, all reachable from the series page at the end. Mention it only if asked: gift, not funnel.)*
- **Fishbowl / mediation** (for groups in conflict), a small inner circle discusses while others listen, then swap; name your *own* side's stereotypes; questions over assertions; a neutral facilitator holds the space.
- **Leadership vulnerability**, a visible, repeated act: someone senior says *"I don't know / I was wrong / I don't understand this"* first, so others can.

**Tests & flow**
- **Start with a test (TDD)**, *red* (a failing test for the next tiny behaviour) → *green* (simplest code to pass) → *refactor*. With AI, pause at **red** to review the design the test implies *before* generating code. **Meet the team where it is (incremental):** if they don't write tests yet, the first rung is just **test-first** (write the test before the code, the day ends with tests *done*), already a huge step; the full red-green-refactor loop, with its design feedback, comes later. TDD's *just-enough-to-pass* restraint is the **best fit for keeping AI honest** (it blocks *AI test theater*, 100% coverage, hollow assertions), so for AI-heavy teams it's the direction to grow toward. Suggest the **rung that fits the level**, not the whole ladder at once (the ebook's *Test-last vs test-first vs TDD* goes deep).
- **Small steps**, slice work so each change is reviewable and reversible in minutes, not days.
- **YAGNI (*You Aren't Gonna Need It*)**, build for the problem in front of you, not a hypothetical future; don't add abstraction, config or docs *"just in case."* Counters premature optimization; pairs with small steps.
- **Trunk-Based Development + feature toggles**, commit to `main` several times a day; hide unfinished work behind a toggle instead of long-lived branches. For a change too big for a toggle, **branch by abstraction** (swap a widely-used component in place, on trunk); for a whole legacy system, the **Strangler Fig** (route traffic to the new one slice by slice). Both keep you off the big-bang path, and off its stress.
- **Ship / Show / Ask**, *ship* trivial changes straight to main; *show* via a PR you merge yourself while inviting comment; *ask* for explicit review when risky.
- **Sociable tests**, assert on **behaviour** (inputs → outputs) through the public surface, not internals, so they survive refactors.
- **Mutation testing**, mutate the code and check the tests fail; run it on the **domain core**, periodically (it's costly), not on every merge.
- **Limit work-in-process**, cap how many things are in flight; finish before starting.

**Knowledge & comprehension**
- **ADRs** (*Architecture Decision Records*), Martin Fowler defines one as *"a short document that captures and explains a single decision relevant to a product or ecosystem"*, note his own scope is *a product or ecosystem*, not architecture alone, which is exactly why an ADR fits **team and process decisions** too. One short file per significant decision: *context, decision, why, consequences.* Store with the code, searchable; open a window to challenge before it locks. (The MADR template makes the breadth explicit, *Markdown **Any** Decision Record*.)
- **Breadcrumbs**, short end-of-session notes (*"here's where we landed, here's what's next"*) in a shared channel, for absent teammates and your future self.
- **Last responsible moment**, defer a decision until *not* deciding would start to cost more than deciding; commit when you must, not before, so you choose with the most information and don't over-invest in something that may still change.
- **Pairing**, two people, one task: *driver* types, *navigator* thinks ahead; swap roles regularly.
- **Mob / ensemble**, the whole team on one thing, rotating the driver every few minutes; best for the hardest problems and onboarding.
- **Walking skeleton**, build a thin end-to-end slice that *runs* first, then grow it, so there's always something working to steer from.
- **Ports & adapters / hexagonal**, put the business core behind a port; tech (DB, UI, framework) plugs in as adapters → swap tech without touching the domain, and juniors can work in isolation.

**Skill & sustainability**
- **Learning hours**, a short, coach-led session where the team deliberately practises one focused skill on exercises (a structured lesson, not open-ended mobbing), run as a ritual the team *owns*, not a willpower bet. (The *learning hour* comes from **Emily Bache**'s **Samman** technical-coaching method.)
- **5-/2-minute rules**, keep small things small: the **2-minute rule** (Allen), if a share or note takes under 2 min, do it *now* rather than defer (a breadcrumb is a 2-min act); the **5-minute rule** (Padesky, CBT), for a task you keep avoiding, commit to just 5 minutes: starting is the hard part, so this builds **momentum**, often that's enough to unblock, and if not you stop without guilt.
- **Katas**, small repeatable exercises to practise a skill; do the kata *yourself* (don't let AI generate the answer, the kata *is* the learning).
- **No-AI days**, a regular day coding without AI, to keep the underlying muscle alive and avoid token-dependency.
- **CINÉ** (Lupien / CESH) **+ graduated exposure**, spot stress triggers (low **C**ontrol; **U**npredictability; **N**ovelty; threatened **E**go); for a recurring one, rank exposures least→most and face them step by step (graduated exposure is a classic behavioral-therapy technique).
- **The freed-time choice, choose it** (Jevons paradox / Tom DeMarco), decide *as a team*: produce more; do it better; reclaim it (rest, learning), don't default to cramming more in.

## Tone & ethos

- **Never judge a team or a person.** A team low on the scale isn't "bad", its people are
  *satisficing* (settling for a good-enough option, not the optimal one, Simon), protecting themselves rationally (Crozier). Lead with **assume best intentions**.
- Frame every level as an **environment, not a verdict**: the *risk* of deterioration is present,
  not realized; the *opportunity* to flourish is available, not seized, the team chooses which it feeds.
- Be encouraging and concrete. Give the **one** next move clearly.
- **People before company.** We work first *with people*, before working *for* a company, the destination is the team's flourishing (juniors growing into seniors, a calmer day), not just more output. Keep the human in front of the metric.
- **Suggest, never impose (reactance).** People push back when they feel their freedom restricted, so always *offer* a lever to try, never a verdict to obey; bring the *will to suggest a solution*, not an order. *(The term* reactance *is **Jack Brehm**'s (1966); it came to me via Kevin Lalumière's talk, and he also stresses that the state of the **relationship** matters before any argument can land.)*
- **It's rarely the people, it's usually the environment.** Frame every gap as a property of the **environment** (the level the team is in), not personal failure, most often **systemic information loss** (knowledge degrades across people, time and handoffs: the telephone game, shared-model erosion, intent never written down). This *is* the scale's own stance, *each level is an environment, not a verdict*, and the Toltec **assume best intentions / don't take it personally**: **name the environment, not the person**, then change the environment.

## Status - a living tool

This is **v1** of a **continuously-improved** instrument. It will go through several versions
shaped by real team feedback; treat the current wording, axes and migration moves as the best
cut so far, **not the final word**. Fitting, *feedback is the engine* the scale itself measures,
so the tool is built to evolve the same way it asks teams to.

## The matrix - every rung, axis by axis (authoritative)

> This is the **authoritative cell-by-cell wording**, mirrored from the *Bounded-Rationality Maturity Scale* (the source of truth) so this skill is **reliable standalone**, you don't have to reconstruct a cell from scratch. Read each cell as an **environment, never a verdict**; most teams sit between two rungs, and different squads sit differently.

**When someone asks for the full matrix, open with this compact 9×5 *table* first** (the whole matrix at a glance), *then* the cell-by-cell wording below. *(The `[n]`-per-axis **position grid** under* Output *is a **different** picture, use that only for the* you-are-here *read, by axis × level with the team's own rungs, not for laying out the reference matrix.)*

| Lens | L1 | L2 | L3 | L4 | L5 |
|---|---|---|---|---|---|
| 1. Three bounds | hidden, unchallenged | trapped, silent debt | partial, cross-checked | pooled, widening | externalized, widened |
| 2. Psychological safety | none | inclusion (fragile) | learner | contributor | challenger |
| 3. Mental health | isolation, anxiety | strained | uneven | belonging returns | sustainable belonging |
| 4. Flow / value stream | overwhelmed | busy ≠ faster | bottlenecked | keeping pace | flow |
| 5. Team cognitive load | load ignored | individual silos | ad-hoc collaboration | collaboration mode | managed load, clear bounds |
| 6. Brown-out / burn-out | acute risk | eroding | easing, fragile | returning | sustainable, restored |
| 7. Shared mental model | none / eroded | trapped in heads | partial (present only) | pooled / shared | living artifacts |
| 8. Culture (Westrum) | pathological | bureaucratic | bureaucratic+ | generative-leaning | generative |
| 9. Feedback (engine) | feared / suppressed | trapped | synchronous, partial | pooled, fast | continuous, systemic |

**Two-tier moves, macro by default, micro on demand.** A cell tells you *where you are*; the rung above is the *destination* on that axis.
- **Macro (default):** the level-migration move for the **floor** (the per-level cards above). **One move, not ten.**
- **Micro-1 (assembly, the default micro):** when a team wants something more concrete on its floor **axis**, assemble three bricks, its **current cell** + the **cell one rung up (L+1)** + the axis's **To-climb direction / matching remedy lever**. *Example, Shared mental model L2→L3:* "knowledge trapped in heads" → "shared among whoever's present" → *capture the why in ADRs + pair/mob*. Offer it, don't impose: *"want something more concrete on your floor axis?"*
- **Micro-2 (deep, on request):** the rung-to-rung step with its **▲ opportunity / ▼ risk** (the *Migrating axis by axis* tables below). Reach here only when a team asks to see exactly what its next step could open up, and what to watch for.

### 1. The three bounds (Simon: information, cognition, time)
*The lens -* the three limits every reasoner (human or agent) works under: **information** (we never have all the facts), **cognition** (we can't process everything; we have blind spots), and **time** (we decide under deadline). Climbing the scale means widening all three.
- **L1 -** Information is *hidden*: no one admits what they don't know, so the team runs on the illusion of full information; reasoning goes *unchallenged*; time is burned on self-protection rather than the work.
- **L2 -** Information is *trapped* in single heads, nothing externalized; cognition debt accrues *silently* as comprehension never leaves the individual; time is lost re-learning what a teammate already knew.
- **L3 -** Information is *shared but only synchronously and partially*; reasoning gets some *cross-checking*, though challenging still feels risky; time is the binding bound, the absent and async are quietly overruled.
- **L4 -** Information is *pooled* (onboarding approaches instant; knowledge lives at team level); cognition *widens* as an expert's blind spots are covered by a junior's fresh eyes; time is protected because durable decisions survive interruptions.
- **L5 -** All three are deliberately *widened*: information externalized in living artifacts (ADRs, breadcrumbs, value-stream visibility), cognition grown by ritual (learning hours, katas, no-AI days), time protected (capacity and the day's ceiling respected).

*To climb →* make the implicit explicit (ADRs, breadcrumbs, a shared glossary), think together to cover blind spots (pair/mob), and protect time (capacity, the day's ceiling).

### 2. Psychological safety (Clark's four stages)
*The lens -* whether people feel safe enough to speak, ask, contribute and challenge, across Clark's four stages (inclusion → learner → contributor → challenger).
- **L1 -** *None*, below inclusion; people don't speak up at all.
- **L2 -** Fragile *inclusion*, you belong, but don't yet feel safe to learn out loud.
- **L3 -** *Learner* safety, questions are welcome; challenging the status quo still feels risky.
- **L4 -** *Contributor* safety, reaching toward challenger, people use their skills fully and begin to push back.
- **L5 -** *Challenger* safety, anyone, including the quietest person, can say plainly that an AI's output is wrong, even when it looks authoritative.

*To climb →* climb Clark's stages, leadership models fallibility → normalize "I don't know" → invite full contribution → protect the right to challenge before decisions lock (team ground rules; the Four Agreements, Don Miguel Ruiz).

### 3. Mental health
*The lens -* the human cost and its sustainability: isolation, anxiety and imposter feelings versus belonging and a pace that lasts. *(A structural cause of apparent "underperformance" and **brownout**: the **Peter Principle**, someone promoted past their fit by a one-way ladder. Read the **role / system**, not the person, and widen the ladder with valued **horizontal growth**. It's org-level, not a team move; the ebook goes deeper.)*
- **L1 -** *Isolation and anxiety*, the fear culture isolates; stress is carried alone, imposter feelings hidden.
- **L2 -** *Strained*, solo work without support; the always-available AI makes withdrawal easy and anxiety builds quietly.
- **L3 -** *Uneven*, some shared context eases the load, but it depends on who's present; the absent stay strained.
- **L4 -** *Belonging returns*, **collective ownership** lowers individual anxiety ("the team validated it, not me"); it's safe to say "I don't understand this."
- **L5 -** *Sustainable belonging*, meaning and capacity are protected by design; the day's ceiling and the anxiety signal (incl. *AI brain fry*) are respected, not overridden.

*To climb →* restore belonging (pairing, collective ownership) and protect capacity (learning hours, no-AI days, respect the ceiling and the anxiety signal).

### 4. Flow / value stream
*The lens -* whether work actually flows to *done* across the whole value stream, or piles up busy-but-stuck, value, not volume.
- **L1 -** *Overwhelmed*, work and stress pile up with no visible flow; everything is firefighting.
- **L2 -** *Busy ≠ faster*, high individual activity, but volume isn't value; work sits in private queues.
- **L3 -** *Bottlenecked*, work moves but jams at hand-offs and review; AI accelerates one stage and inventory piles at the next (scatter-gather).
- **L4 -** *Keeping pace*, comprehension and review keep up with production; work flows to *done* rather than piling up busy-but-stuck.
- **L5 -** *Flow*, the whole value stream is optimized for *value, not volume*; speed is pointed at the real constraint and work-in-process is limited.

*To climb →* small batches, Trunk-Based Development + feature toggles, Ship/Show/Ask, limit work-in-process; optimize the whole value stream for steering, not speed.

### 5. Team cognitive load (Team Topologies)
*The lens -* how much each person and team carries, and whether team boundaries and interaction modes are deliberate (Team Topologies, Skelton & Pais).
- **L1 -** *Load ignored*, no attention to how much each person or team carries; overload is the unspoken norm.
- **L2 -** *Individual silos*, load is dumped on individuals, each carrying a domain alone (a high **bus factor**, the risk when knowledge lives in one head: *what if they're hit by a bus?*).
- **L3 -** *Ad-hoc collaboration*, teams help each other reactively, but boundaries and interaction modes aren't deliberate.
- **L4 -** *Deliberate collaboration mode*, teams choose how they interact (collaboration, X-as-a-service, facilitating), for a bounded time.
- **L5 -** *Managed load, clear bounds*, teams are organized around coherent business domains (a bounded context each); load stays sustainable and dependencies don't perpetually block.

*To climb →* clear boundaries (ideally one bounded context per team), deliberate (temporary) interaction modes, and pair/mob to share load instead of siloing it.

### 6. Brown-out / burn-out
*The lens -* meaning and capacity over time: **brown-out** = loss of meaning (the work stops mattering), **burn-out** = exhaustion (running on empty), the brown-out/bore-out framing from Bouzou & de Funès.
- **L1 -** *Acute risk*, chronic fear and overload; meaning and energy drain fast.
- **L2 -** *Eroding*, isolation and heads-down survival wear people down; brown-out (loss of meaning) creeps in.
- **L3 -** *Easing but fragile*, some connection returns, but without held rituals it slides back.
- **L4 -** *Returning*, belonging and shared ownership restore meaning and capacity.
- **L5 -** *Sustainable, restored*, meaning and capacity are protected by systems; the AI-era overload signal (*brain fry*) is watched and the ceiling respected.

*To climb →* protect meaning and capacity (learning hours, no-AI days), make the freed-time choice well (value, not volume), and respect the day's ceiling.

### 7. Shared mental model (cognitive, knowledge, intent debt)
*The lens -* whether the team holds a shared *theory of the system* (Naur) or lets it fragment into **cognitive debt** (Stepanović; with its cousin **knowledge debt** / Lopez) and **intent debt** (Storey's triple-debt, the *why* never written down).
- **L1 -** *None / eroded*, no shared theory of the system; understanding is absent or actively lost.
- **L2 -** *Trapped in heads*, comprehension lives in individuals and never leaves; cognitive and knowledge debt accrue silently.
- **L3 -** *Partial (present only)*, the model is held among whoever is present, lost across time zones and to the absent.
- **L4 -** *Pooled / shared*, the team holds a shared model; an agent is one voice, never the verdict; "I don't understand this generated code" is sayable.
- **L5 -** *Living artifacts*, the *why* lives in ADRs/breadcrumbs and is kept current (pair/mob); intent debt is paid down rather than accrued, and the team's **collective knowledge survives** people, interruptions and AI.

*To climb →* capture the *why* in ADRs and keep it shared (pair/mob, breadcrumbs), paying down cognitive, knowledge and intent debt.

### 8. Culture (Westrum)
*The lens -* how the organization handles information under pressure (Westrum): pathological → bureaucratic → generative.
- **L1 -** *Pathological*, information is hidden, messengers are shot, failure is punished.
- **L2 -** *Bureaucratic*, rules over purpose; information moves through channels, not freely.
- **L3 -** *Bureaucratic+*, some openness, but bad news still travels slowly and partially.
- **L4 -** *Generative-leaning*, information increasingly flows; failure starts to breed inquiry rather than blame.
- **L5 -** *Generative*, information flows freely and failure breeds inquiry; a right to make mistakes and blameless reviews, the opposite of a culture of fear.

*To climb →* make information flow, blameless reviews, don't shoot the messenger, a right to make mistakes, visible team ground rules.

### 9. Feedback (the engine - cross-cutting)
*The lens -* the cross-cutting engine: how short and wide the team's feedback loops are. Every rung up is a shorter or wider loop.
- **L1 -** *Feared / suppressed*, feedback is a weapon or is avoided; loops are broken.
- **L2 -** *Trapped*, feedback stays inside individuals; little reaches the team.
- **L3 -** *Synchronous, partial*, feedback flows when people are in the room, but not across time or to the absent.
- **L4 -** *Pooled, fast*, feedback is shared and quick (pairing, review, ADRs); loops shorten and widen.
- **L5 -** *Continuous, systemic*, feedback is built into the system (tests, CI, retros, living docs), short and wide by default. Beware *cargo-cult feedback*, green but verifying nothing.

*To climb →* shorten and widen the loops, tests (seconds), pairing (instant), review and ADRs (across people and time), retros; and beware cargo-cult feedback.

### Migrating axis by axis - the micro view (▲ opportunity / ▼ risk)

*(The **deep micro-2**: each axis's climb in its four rung-to-rung steps. For each step, the **move**, the **▲ opportunity** to seize, and the **▼ risk** (possible, not proven). All **modal**, directions and potentials, never verdicts or guarantees. Default to the macro; reach here only on request.)*

**When you lay this out, open with the rung-to-rung ladder *picture* first** (the two sub-reads, the **level step** and the **axis step**, the templates under *Output*), *then* the steps below.

#### 1. Three bounds
- **L1→L2 -** *Move:* one visible act of leadership fallibility makes it safe to admit gaps. **▲** the team can finally name what it doesn't know. **▼** if the safety isn't real, admissions get punished and people re-hide.
- **L2→L3 -** *Move:* externalize, talk, pair, share decisions. **▲** knowledge starts leaving single heads. **▼** talk may stay synchronous-only; the absent lose context.
- **L3→L4 -** *Move:* make it durable, ADRs/breadcrumbs + a window to challenge before locking. **▲** information survives interruptions and time zones. **▼** records can become box-ticking if no one reads them.
- **L4→L5 -** *Move:* systematize, living artifacts + ritual practice widen all three bounds. **▲** the bounds keep widening without willpower. **▼** complacency, rituals decay if treated as "arrived."

#### 2. Psychological safety (Clark)
- **L1→L2 (none→inclusion) -** *Move:* leadership models fallibility; "assume best intentions." **▲** people belong and stop self-protecting. **▼** inclusion stays fragile if one harsh reaction lands.
- **L2→L3 (inclusion→learner) -** *Move:* normalize "I don't know"; welcome questions. **▲** learning happens out loud. **▼** challenging the status quo still feels risky, don't mistake quiet for safe.
- **L3→L4 (learner→contributor) -** *Move:* invite full use of skills; ask for pushback. **▲** people contribute fully and own the work. **▼** challenge may still defer to authority.
- **L4→L5 (contributor→challenger) -** *Move:* protect the right to challenge before decisions lock. **▲** the quietest person can say "the AI is wrong." **▼** without held ritual, challenger safety erodes under pressure.

#### 3. Mental health
- **L1→L2 -** *Move:* break isolation, make asking and offering help visible. **▲** stress stops being carried alone. **▼** solo speed can still mask quiet strain.
- **L2→L3 -** *Move:* connect, pairing/review give human contact. **▲** loneliness drops, anxiety eases. **▼** relief depends on who's present; the absent stay strained.
- **L3→L4 -** *Move:* collective ownership, "the team validated it, not me." **▲** individual anxiety drops, belonging returns. **▼** entropy, without rituals, isolation creeps back.
- **L4→L5 -** *Move:* protect by design, learning hours, no-AI days, respect the ceiling. **▲** sustainable belonging; juniors grow. **▼** "no arrived", capacity must keep being defended (watch *brain fry*).

#### 4. Flow / value stream
- **L1→L2 -** *Move:* make individual work move (tooling, autonomy). **▲** momentum and speed return. **▼** volume can masquerade as value (busy ≠ faster).
- **L2→L3 -** *Move:* make work visible (pair, review, small PRs). **▲** less re-learning, faster unblocking. **▼** work can jam at hand-offs; AI piles inventory (scatter-gather).
- **L3→L4 -** *Move:* match production to comprehension (limit WIP, durable decisions). **▲** work flows to *done*, review keeps pace. **▼** slips back to busy-but-stuck if WIP isn't capped.
- **L4→L5 -** *Move:* optimize the whole stream for value not volume (steering, not speed). **▲** speed hits the real constraint. **▼** Jevons rebound, freed time silently re-spent as more output.

#### 5. Team cognitive load (Team Topologies)
- **L1→L2 -** *Move:* acknowledge load, stop pretending it's free. **▲** overload becomes visible. **▼** load may just get dumped on individuals (silos, high bus factor).
- **L2→L3 -** *Move:* share load (pairing, ad-hoc help). **▲** knowledge spreads, bus factor drops. **▼** collaboration stays reactive and undeliberate.
- **L3→L4 -** *Move:* choose interaction modes deliberately (collaboration, X-as-a-service, facilitating), time-boxed. **▲** load is intentional, not heroic. **▼** permanent collaboration exhausts; modes left "on" drain capacity.
- **L4→L5 -** *Move:* organize around **bounded contexts**, clear ownership, fewer cross-team dependencies (Josian Chevalier); isolate the domain with a maintained DDD glossary (Paul Hammond, AI Agents Montréal Talk #13). **▲** sustainable load, fewer perpetual blocks. **▼** boundaries can calcify and the model drift into **obsolescence** if never revisited, watch for a *model tension* (an early signal the model is stretched past its coherence, Julien Topçu & Josian Chevalier); and note the renewal cost is as much **organizational** (renegotiating scopes and ownership across teams, who decides, who arbitrates) as technical, which is exactly why teams skip it and slide back.

#### 6. Brown-out / burn-out
- **L1→L2 -** *Move:* reduce acute harm, protect a little slack. **▲** the drain slows. **▼** heads-down survival still erodes meaning.
- **L2→L3 -** *Move:* reconnect, visible help, some shared context. **▲** meaning starts returning. **▼** fragile, slides back without held habits.
- **L3→L4 -** *Move:* restore via belonging and shared ownership. **▲** capacity and meaning recover. **▼** recovery rides on motivation, not yet systems.
- **L4→L5 -** *Move:* protect by systems (learning hours, no-AI days, the freed-time choice). **▲** sustainable, restored. **▼** complacency, the ceiling must keep being respected (the *brain fry* signal).

#### 7. Shared mental model (cognitive, knowledge, intent debt)
- **L1→L2 -** *Move:* start externalizing anything. **▲** understanding begins to exist outside one head. **▼** it can still stay trapped per-individual (silent debt).
- **L2→L3 -** *Move:* share among the present (pairing, talk). **▲** comprehension gets cross-checked. **▼** lost across time zones and to the absent.
- **L3→L4 -** *Move:* pool it, the team holds the model; "I don't understand this" is sayable. **▲** an agent becomes one voice, not the verdict. **▼** entropy without rituals.
- **L4→L5 -** *Move:* make it living, ADRs/breadcrumbs kept current, intent debt paid down, and the model itself **renewed, not reused by default**. **▲** collective knowledge survives people and AI. **▼** the model slides into **entropy** (a slow drift into incoherence) when reused by default. The early-warning **pattern that detects the drift** is a *model tension*, a structural signal the model is stretched past its coherence, telling you it may be time to **shape a new model** (Julien Topçu & Josian Chevalier's *model-tension heuristics*; it's also a **feedback** signal, axis #9). The open governance questions stay live, *when* to renew, *how*, and **who decides or arbitrates** across teams (the renewal cost is as much organizational as technical). *A start of an answer* (their *heuristics*): the tension signals are mostly **socio-technical**, which only works if the team **recognizes its system as socio-technical** (Duncan Brown, AI Agents Montréal Talk #6: software is *"fundamentally sociotechnical, not just technical"*); an org that sees only code never spots them. They surface in code, conversations, processes and workarounds, so the **team that feels the coupling raises it with a body of evidence** (distributed detection, a *who* and a *when*), and you test the *how* with **safe-to-fail experiments** before the costly change (Rebecca Wirfs-Brock & Mathias Verraes). It's **maturity-dependent**: questioning a model and experimenting collectively needs *challenger* safety and experimentation capacity, so below L4/L5 the move is to **build that maturity first**.

#### 8. Culture (Westrum)
- **L1→L2 (pathological→bureaucratic) -** *Move:* stop shooting messengers; route information through channels. **▲** information at least moves. **▼** rules can smother purpose.
- **L2→L3 -** *Move:* open some channels; invite bad news. **▲** more flows. **▼** bad news still travels slowly and partially.
- **L3→L4 (→generative-leaning) -** *Move:* treat failure as inquiry, not blame. **▲** information increasingly flows freely. **▼** blame can resurface under pressure.
- **L4→L5 (→generative) -** *Move:* a right to make mistakes; blameless reviews. **▲** on a generative base, AI becomes leverage. **▼** on a fear base, AI amplifies dysfunction, culture must be tended.

#### 9. Feedback (the engine)
- **L1→L2 -** *Move:* make feedback safe to give at all. **▲** loops start to exist. **▼** feedback stays trapped in individuals.
- **L2→L3 -** *Move:* share it synchronously (pairing, review). **▲** faster correction. **▼** doesn't reach across time or the absent.
- **L3→L4 -** *Move:* pool and speed it (review + ADRs, retros). **▲** loops shorten and widen. **▼** can become cargo-cult, green but verifying nothing.
- **L4→L5 -** *Move:* build it into the system (tests, CI, living docs, retros). **▲** continuous, systemic, short-and-wide. **▼** vigilance against cargo-cult feedback never ends.

## Explainers - the framing behind each axis

When the user says **"explain [axis]"**, draw on the matching note below (in their language, ~4-6 lines, enough to understand and rate, not a lecture). When they say **"explain [lever]"** (e.g. *breadcrumbs, ADRs, 5-/2-minute rules, last responsible moment, ground rules, the Four Agreements*), draw on ***How to run the levers, operational*** above (the concrete how-to), same length, plain language. For **ground rules; the Four Agreements; the collaborative posture**, a **fuller, ebook-depth explainer** lives in *Prerequisites for collaborative work* below, use it when the team wants the full picture, not just the one-line gloss. For **the freed-time choice** specifically, draw on its dedicated section ***Name the choice when time is freed*** (accelerate vs automate; the Jevons paradox / rebound effect; Tom DeMarco's counter; the team decides: produce more / do it better / reclaim it), it's a principle, not a how-to. When the user asks about a **specific level on an axis** (e.g. *"what does «ad-hoc collaboration» mean for team cognitive load?"*), explain **that rung concretely**, what it looks like day-to-day, and what the next rung up adds. For the authoritative wording of any of the **45 cells** (9 axes × 5 levels), **draw on the embedded matrix above** (*The matrix, every rung, axis by axis*): every cell is written out there, each axis closes with its *To climb →* direction, and the rung-to-rung **▲ opportunity / ▼ risk** lives in the *Migrating axis by axis* micro view. Quote or condense the matching cell to fit the question rather than inventing one, and keep it **modal** (*an environment, not a verdict*). That makes **every column value explainable**, not just the axis as a whole. (The same matrix lives in full in the *Bounded-Rationality Maturity Scale* and the *self-locator* if a team wants the source.) **When it's genuinely useful, you may point to the source**, *"the ebook / the white paper goes deeper on this, if you ever want it"*, but **once, and without pushing**: the work is a gift, not a funnel, and people who are interested will go on their own (the same *reactance* you respect everywhere else). (See *Based on, and worth reading in full* below.)

**Posture (read first).** Each level is an **environment, not a verdict**. A low score is *rarely the people*, usually the environment: **information loss** across people, time and handoffs. Crozier: defensiveness is a *rational* read of personal risk, not bad faith. And **suggest, never impose**, reactance: people push back when their freedom feels restricted, so offer a move to *try*, never a verdict to obey. And it's a **support for a conversation, not a score to report or a target to hit**: compare the team **only to itself over time** (never to other teams), and treat **disagreement on a rung as the signal** to talk about, the moment a rung becomes a commitment or a status, it dies the way story-point estimates did in water-scrum-fall (turned from a conversation into a commitment). *(This skill is shared under **CC BY-NC-SA**, if you adapt it, please keep this spirit travelling with it.)*

**1. Three bounds (information, cognition, time, Herbert Simon).** Bounded rationality: no reasoner, human or AI, can know and process everything a perfect decision needs. Three limits: **information** (you only see a fraction; you don't know what you don't know), **cognition** (limited capacity to hold complexity at once), **time** (limited time to think). A team's real craft is to **pool** these, share info, combine minds, protect time, keeping a *shared mental model* alive faster than the work fragments it. AI *moves* the bounds: it relaxes production but **tightens** comprehension, review and shared understanding → the human becomes the new bottleneck.

**2. Psychological safety (Amy Edmondson; the four stages, Timothy R. Clark).** The shared belief that the team is safe for interpersonal risk-taking, the **enabling condition** for everything AI stresses: saying *"I don't understand this generated code,"* reviewing honestly, pooling what each person knows. Clark shows it's **cumulative**: *inclusion → learner → contributor → challenger*, you can't reliably reach a higher stage without the ones beneath. Because **AI amplifies whatever culture already exists**, safety is the load-bearing variable. **Safety is practised, not just installed**: it opens the *freedom to speak*, and the **skill of giving feedback so it can be received** carries it. This is the **reactance** link: even in a safe room, feedback that *feels imposed* triggers push-back and erodes trust, so *how* it's given (**suggest**, relationship first; *be impeccable with your word*) and *received* (*don't take it personally*) is an **attitude to adopt**, not just a structural property; **share the air** is the lever. The observer's side: resist the **fundamental attribution error** (Ross, 1977), read the **situation**, not the person's character, **bounded rationality turned on other people** and the ground of a *blameless* culture (Alexandre-Bailly et al.). (Bridges axis #2 ↔ axis #9 feedback.)

**3. Mental health.** The human cost. **Imposter syndrome** widens when AI seems to "know everything" (the gap between *what you can do* and *what you think you should know*), it sits within David Burns' cognitive distortions, so people hide rather than ask. The **isolation trap**: it's easier to ask the always-available, never-judging agent than a teammate, quietly eroding human collaboration. The goal is **belonging and a sustainable pace**; brown-out/burn-out is the adjacent failure. **The AI-era cognitive costs to watch** (facets of one human cost): the **anxiety tax** (background vigilance from supervising parallel agents, Addy Osmani), **AI brain fry** (overload from overseeing AI beyond your capacity, BCG / *Harvard Business Review* 2026), **brain rot** (atrophy from outsourcing every small effort, the MIT Media Lab's *Your Brain on ChatGPT* / *cognitive debt*), **cognitive surrender** (no longer trying to understand the output, Addy Osmani), **sycophancy & hallucination** (AI tuned to *flatter* and validate your framing, removing the friction that catches mistakes, and its mirror, confidently-wrong output that *looks* right: Lopez's *black box*), **rubber-stamping AI-generated code** (approving it because it *looks* right or CI is green, a *Critical* anti-pattern, Finster's *Beyond MinimumCD*; antidote: read the diff as if the AI hadn't written it), the **junior competence gap** (AI does the simple tasks juniors used to grow on, quietly removing the path to seniority), and **emotional dependency / "back-bonding"** (the assistant standing in for human relationships). *(These are named for rating depth; the ebook explains each in full, point there, don't reproduce it.)*

**4. Flow / value stream.** The bottleneck was never the typing. Look at the **whole value stream**, not the keyboard, work can be *busy but stuck*. AI accelerates one stage (generation) while review, integration and waiting stay human-paced, so accelerating a non-constraint just **piles up inventory** (the scatter-gather problem, Tim Ottinger; rooted in Goldratt's Theory of Constraints). Optimize for **flow**, and for **steering, not speed** (Woody Zuill), correcting direction beats raw velocity.

**5. Team cognitive load (Team Topologies, Matthew Skelton & Manuel Pais).** A team has **finite cognitive capacity**; pile on too many domains or services and quality and learning collapse. The fix is **clear boundaries** (what's ours, what's not), domain isolation, and *deliberate* collaboration modes, not heroics. Pairing/mob **shares** the load instead of siloing it in individuals. **Zoom:** Team Topologies offers a small but useful vocabulary, four **team types**, **stream-aligned** (owns a product slice end-to-end), **platform** (offers self-service tooling the others build on), **enabling** (coaches another team over a hump, then steps back), **complicated-subsystem** (holds a part needing deep specialist expertise), and three **interaction modes**, **collaboration** (two teams work closely for a *limited* time; high-bandwidth but costly in cognitive load), **X-as-a-service** (one team consumes what another provides over a clear boundary; predictable, low overhead), **facilitating** (one team helps another learn or unblock). The discipline that matters: pick a mode **deliberately and temporarily**, don't live in permanent collaboration (exhausting) or silo everything as a service. The aim isn't the labels: it's to **organize teams around a coherent business domain** (one *bounded context* per team, in DDD terms) so each holds a **shared mental model** of its slice and isn't perpetually blocked waiting on others, the structural cure for the dependency stress that feeds brown-out. (Paul Hammond, AI Agents Montréal Talk #13, pairs this with a maintained DDD glossary to isolate the domain; Josian Chevalier frames organizing teams around bounded contexts for clear ownership and fewer cross-team dependencies.) And individuals have a **breadth profile** too, **I-shaped** (one deep specialty) vs **T-/M-/Pi-shaped** (depth plus breadth), which sets how much coordination they need. Matthias Patzak (AI Agents Montréal Talk #10) notes AI agents are **I-shaped specialists**; Dragan Stepanović (AI Agents Montréal Talk #15) adds the hopeful flip, used well, AI can **extend a developer's T-shapeness**, broadening them beyond their core. So a team of I-shaped agents still needs **T-/M-shaped humans** to integrate the whole.

**6. Brown-out / burn-out.** **Brown-out = loss of meaning** (the work stops mattering); **burn-out = exhaustion** (running on empty), the brown-out / bore-out framing comes from Bouzou & de Funès. A common, recognizable driver of brown-out (clearest in **domain-driven design**, but the pattern generalizes to any team): work drifting into **tactical-only**, polished code patterns that quietly stop serving the business *why*, what Josian Chevalier calls the *strategy-vs-tactics* trap (after Sun Tzu: *"tactics without strategy is the noise before defeat"*). The antidote is keeping the **strategic, collaborative thread** alive (workshops, a shared language) so people know what they're building and why. Both are signals about the **environment**, not the person's weakness. Protect meaning and capacity, respect the day's ceiling (its AI-era signal is **AI brain fry**, cognitive fatigue from overseeing AI beyond your capacity, BCG / *Harvard Business Review* 2026: when you can't track what your agents are doing, you've crossed it), and when AI frees time, let the **team choose** how to spend it (produce more; do it better; rest), rather than defaulting to cramming more in.

**7. Shared mental model (informed by Stepanović and Storey).** A program is really a **theory living in developers' minds** (Naur). When the team loses that theory, even clean code rots, that's **cognitive debt** (and its cousin **knowledge debt**, the understanding lost when AI emits code nobody on the team actually grasps; Javier Lopez, AI Agents Montréal Talk #19). Dragan Stepanović maps the **fragmentation of a system's mental model** to *how a team collaborates*, worst under agentic coding without understanding the system, easing through solo + async review, pairing and promiscuous pairing (rotating partners so everyone pairs with everyone), to its lowest in mob/ensemble; the rungs here read that same force as a maturity state. **Intent debt**, *drawing on* Margaret-Anne Storey's *triple-debt model*, is the third debt: the *why* that was never written down, and an agent can refactor code but **cannot generate intent**. All are paid down the same way: **capture the *why* in ADRs** and keep it shared (pair/mob). Models also have a finite life: watch for a **model tension**, an early structural signal a model is stretched past its coherence (the opposite of *model entropy*, a slow slide into incoherence), and **renew the model rather than reuse it by default** (Julien Topçu & Josian Chevalier's *model-tension heuristics*). The catch is often organizational, not technical: renewing a shared model means renegotiating scopes and ownership across teams (who decides, who arbitrates), which is why teams skip it and let the model calcify. A start of an answer: the tension signals are mostly **socio-technical**, which only works if the team recognizes its system *as* socio-technical (Duncan Brown, AI Agents Montréal Talk #6: software is *"fundamentally sociotechnical, not just technical"*); an org that sees only code misses them. They show up in code, conversations, processes and workarounds, so the **team that feels the coupling raises it with a body of evidence** (distributed detection, a *who* and a *when*), and you test the *how* with **safe-to-fail experiments** before the costly change (Wirfs-Brock & Verraes). It's **maturity-dependent**, though, questioning a model and experimenting collectively needs challenger safety and experimentation capacity, so below L4/L5 the move is to *build that maturity first*. **Catch it early**, act *before* a tension crystallizes, and train the eye for the patterns in **learning hours and katas** (deliberate practice): *"all models are wrong, but some are useful"* (George Box), so the named tensions to spot are the **spork effect** (intrinsic coupling), **model fragmentation** (extrinsic coupling, Stepanović's mental-model fragmentation), and **model sclerosis** (which slide into *entropy* / a Big Ball of Mud). **Staying at L5 (not sliding back to L4)** also means keeping *structure in service of the model*: renewing a model is as organizational as technical, and an org frozen first calcifies the architecture, Jan Bosch's *Structure Eats Strategy* (the **BAPO** order: Business → Architecture → Process → Organization, not the accidental OPAB), i.e. **Conway's law** by default vs the **Inverse Conway Maneuver** (shape teams to fit the target architecture). *(Model-tension types & heuristics: Julien Topçu & Josian Chevalier's talk; BAPO: Jan Bosch, 2017.)*

**8. Culture (Ron Westrum).** How information flows under pressure: **pathological** (hide it, shoot the messenger) → **bureaucratic** → **generative** (information flows freely, failure breeds inquiry). Because **AI amplifies culture**, a generative culture turns AI into leverage and a pathological one turns it into faster dysfunction. Don't shoot the messenger, let bad news travel fast. The generative pole has a name: a **right to make mistakes** and **blameless** reviews, the opposite of a culture of fear (Edmondson's *fearless organization*).

**9. ↻ Feedback (the engine).** Bounded rationality is the problem of *not knowing what you don't know*, and **feedback is the only way to find out**. Every practice on the scale is a feedback loop: a test (seconds), pairing (instant), review and ADRs (across people and time). Climbing the scale *is* **shortening and widening** your loops. Beware **cargo-cult feedback**, a green test that checks nothing: the loop *looks* closed but learns nothing.

## Prerequisites for collaborative work - ground rules & the Four Agreements (full explainer)

When asked to go deep on **ground rules**, **the Four Agreements**, or the **collaborative posture** behind pairing/mobbing, draw on this (the ebook's *Prerequisites for collaborative work*, condensed, enough to explain in full without the ebook).

**The posture.** Egoless programming and **sociable programming** (pairing, mobbing, a.k.a. *ensemble programming* / *software teaming*) rest on a simple attitude: *be humble; be kind; no judgment; be open-minded; collective accountability; listen; be respectful; have humility*. OCTO's *Culture Code* white paper (*Software Craftsmanship: Better Places with Better Code*) captures the balance, **be kind with people, hard with the code**: you can push relentlessly on quality *because* you stay gentle with the humans; the two aren't in tension, they enable each other.

**Ground rules** are a short set of **explicit working agreements** a team adopts together (how we pair/mob, how we give and receive feedback, how we handle disagreement, when anyone can call *"let's stop and rethink"*). Their value: they turn psychological safety from a *wish* into something **concrete and shared**, the norms are known *in advance*, so challenging an idea feels safe rather than risky, newcomers join without guessing unwritten rules, decisions feel less personal, and friction drops (especially in mob/ensemble, where several people work on one thing at once). Common ones:
- **Share the air**, make sure everyone can contribute; actively make space for quieter members.
- **Critique ideas, not people**, challenge the concept and perspective respectfully, never the person.
- **Listen actively**, don't interrupt; listen to *understand*, not to wait for your turn to speak.
- **Assume best intentions**, give colleagues the benefit of the doubt; stay curious when a disagreement or misunderstanding comes up.
- **Stay on topic**, respect the agenda, with a **parking lot** for important-but-not-now ideas (a *visible* spot, a whiteboard corner or shared doc, where you jot the idea so it isn't lost and your flow isn't broken, revisited at a reflection point like a mini-retro; from mob/ensemble, Woody Zuill & James Herr, AI Agents Montréal Talk #20; also evoked by William Bernting, AI Agents Montréal Talk #4, who applies it to AI-assisted work via **beads**, a to-do/issue list for the agent that also *maps dependencies* between tasks).

Two links back to the scale: **critique ideas, not people** is the meeting-room form of OCTO's *be kind with people, hard with the code*; **share the air** is **challenger safety (axis #2, level 4) in action**, safety only counts if the *quietest* person can still speak up and challenge the status quo.

**The Four Agreements (Don Miguel Ruiz)**, the personal-discipline version of the same posture:
1. **Be impeccable with your word**, say what you mean, honestly and kindly; words build or destroy trust.
2. **Don't take anything personally**, what others say and do is mostly about them, not you; this is what lets you receive a challenge without flinching.
3. **Don't make assumptions**, ask instead of guessing; most conflict is a silent assumption that was never checked.
4. **Always do your best**, and your best varies with the day; that's fine, it just removes self-judgment.

The link is direct: the ground rule **assume best intentions** is basically agreements **2 + 3** in practice, *don't make assumptions* turns a silent guess into a question, and *don't take anything personally* keeps a disagreement about the idea rather than about you. Together they are **personal hygiene for psychological safety**, the inner version of the ground rules.

**When a team is already split into two camps** (mistrust, not just disagreement), ground rules may not be enough. A depolarization move transfers well (Keohane, *The Power of Strangers*): rather than attacking the other side's stereotypes, **each side names the stereotypes about *its own* camp** (and pushes back on them), which signals self-awareness and lowers the walls; then they take turns in a **fishbowl** (one group speaks while the other only listens, then switch) and trade **genuine questions instead of declarations** (a real question opens the door a flat assertion shuts), with a facilitator holding the rules. It's the same **role-switching and active listening** that make pairing and mobbing work, pointed at conflict instead of code. (There's a cultural name for the posture: *simpatía*, kindness, positivity, and treating an insult to someone's dignity as a real cost, which research links to people being more helpful to one another.)

## Changelog

- **1.2.0**, on-screen output made lean; the full artifact still travels in the saved `.txt`. In the chat the Snapshot now shows a one-line frame + Waypoint + ADR core + a two-line ADR-notes summary; the full POSTURE, the usage/license footer and the ADR's closing notes are written to the file and offered on request via need-named options (never "show posture / show license"). The close hands back a selection picker (not prose), re-offered after each reveal. Also includes an emit-each-block-once guard against a duplicated on-screen Snapshot. Behaviour of the assessment itself is unchanged; the saved file is unchanged and complete.
- **1.1.1**, wording only (no behaviour change): clarified the license section (invoking vs bundling vs adapting), and reworded the AI-tell read-out so it states the reading plainly and calmly, without the "danger zone" / "no alarm" phrasing (kept it modal, per the tool's non-judgmental framing).
- **1.1.0**, output renamed to the **Team Maturity Snapshot** (self-describing header + Posture + Waypoint + ADR + a usage/license footer; the position block stays **Waypoint**); the skill now **answers usage/license questions** (own team vs paying clients, outputs-not-intentions, call vs bundle vs adaptation) from an embedded, self-contained license section; file naming -> `<team-slug>_maturity-snapshot_<date>.txt` (older `maturity-waypoint-*` files still load). Backward-compatible; assessment flow unchanged.
- **1.0.0**, first public release. 9-axis locator, floor-based scoring (the level = the lowest axis), psychological-safety deep-dive (4 stages / 20 statements), remedy library mapped to the ebook levers, per-axis explainers. Living tool, expect refinements.

## Attribution & license

This skill operationalizes **Nicolas Rosado's Bounded-Rationality Maturity Scale** (his original
framework; CC BY-NC-SA 4.0). The named lenses are credited to their authors and **not owned**:
Herbert Simon (bounded rationality); Amy Edmondson (psychological safety) & Timothy R. Clark
(4 stages); Team Topologies, Matthew Skelton & Manuel Pais; Dragan Stepanović (mental-model
erosion); Margaret-Anne Storey (cognitive & intent debt, the triple-debt model); Ron Westrum (cultures); Michel Crozier & Erhard Friedberg (strategic analysis of actors). Practitioner levers in the remedy library are credited inline (e.g., Javier Lopez) and drawn from the companion ebook; the *freed-time choice* draws on the **Jevons paradox** (rebound effect) and **Tom DeMarco** (full citation in the ebook's sources).

**License:** © 2026 Nicolas Rosado. CC BY-NC-SA 4.0, a gift to the community: use it, share it, translate it, run it with your team; credit the author, keep it non-commercial, share alike.

### Usage rights & license (how to answer if asked)

If asked about usage rights / license, answer plainly and factually from what follows. Stay non-judgmental: describe what's allowed, don't lecture. When unsure, or for anything beyond a personal local read, point the person to the repo / author to **ask permission first** - frame it as a requirement, **not** an invitation to collaborate (the author's aim is to help teams, not to solicit commercial work; the answer may be no).

This work is released under **CC BY-NC-SA 4.0**. In plain terms: **BY** - credit the author (Nicolas Rosado) whenever you share, publish or redistribute it (or an adaptation); **NC** - no use "primarily directed toward commercial advantage or monetary compensation". NC is about the **use, not the user**: no selling it, paywalling it, or bundling it into a paid product, but a **company using it internally, for its own team, is completely fine** (NC is not "no businesses"); **SA** - if you *modify or adapt* the tool, the adapted part must stay under the same CC BY-NC-SA license (so the spirit keeps travelling).

**The real question is not "standalone or wired into an agent?" It's "for your own team, or for paying clients?"** Every case that came up, made explicit, in two groups:

**Using it - for whom:**

| Use case | Under the free license? |
|---|---|
| Your own team, internal use | ✅ Yes |
| A local read to inform your own view, even for a team you consult (nothing shipped out) | ✅ Yes - a permission the author grants |
| A client deliverable, a paid product / service, or reselling it | ❌ Commercial - not allowed under the free license; you need the author's permission first |
| Sharing or publishing something based on it | ✅ Yes, with attribution |

**Running, distributing or modifying the skill:**

| Use case | Under the free license? |
|---|---|
| Run it **standalone** (installed, invoked directly) | ✅ Yes |
| Run it **via your own agent, unmodified** (a *combination*) | ✅ Yes, whatever your agent's own license: invoking isn't merging, so no license-compatibility question arises here (that only comes up if you *bundle/ship* it or *adapt* it). Your agent code stays under your terms; the skill keeps its CC BY-NC-SA license |
| **Bundle a copy** into your own agent / product to ship to others (*aggregation*) | ✅ if non-commercial **and** you credit the author (the copy stays CC BY-NC-SA); ❌ in a paid product / service → ask the author |
| Bundle it into an **existing agent under another license** | Coexists fine (*aggregation*, side by side): ✅ if non-commercial and that license can host an NC component; ❌ if the agent is paid, or its license can't host NC → ask the author |
| **Modify / translate / adapt** the skill (an *adaptation*) | ✅ Yes - but the adapted part stays under CC BY-NC-SA (*share-alike*); you can't merge it into another license or relicense it |

**A few principles behind the tables:**
- **Outputs, not intentions.** The client line turns on what actually gets *shipped*, not on what you mean to do: free as long as nothing that comes out of it is delivered to a client, sold, or built into a paid offering. It holds for the skill's own output too (the **Team Maturity Snapshot**, its Waypoint and proposed ADR): keep it for your own or your team's reading; hand it to a client as a paid deliverable or sell it, and it's commercial. Intentions can't be verified; a shipped output can. Concretely: ✅ you run it and read the result to shape your own thinking → fine; ❌ a report built from it goes into a paid client deliverable → commercial; ❌ it's embedded in a paid product or service → commercial.
- **Coexist ≠ merge.** Placing the skill unmodified beside your own code lets the two licenses coexist: your code stays yours, the skill stays CC BY-NC-SA. What you can't do is *merge* it into another license or relicense it; CC BY-NC-SA also can't live inside something that must stay commercially usable. Only *adapting* triggers share-alike; merely invoking or bundling it unmodified does not, though attribution (BY) and non-commercial (NC) still apply in those cases.
- **One constant across every case:** the skill copy always stays CC BY-NC-SA, attribution applies whenever you distribute, and NC gates **anything commercial** (a paid product or service, a client deliverable, **marketing or promotional use, or a site that earns ad revenue**): you need the author's permission.
- **Cited authors keep their rights.** The license covers Nicolas Rosado's original text only. The thinkers and practitioners quoted or built upon (credited just above) keep their own rights, reproduced under the right of quotation. You can't relicense them, and you can't re-attribute their ideas or words to yourself; credit stays with them.
- **The local-read permission** is granted by the author as the rights holder, on top of the license; the CC BY-NC-SA license itself is unchanged (not a modified or custom license).

For a commercial or client use case: it isn't granted by default - ask the author's permission first (it may or may not be granted). The aim of this work is to help teams, not to sell. Full terms & repo: <https://github.com/nicolasrosado/team-maturity-self-locator#using-this-under-the-license>

**Based on, and worth reading in full.** This skill only *locates*; the documents go deep. **Everything, the white papers, the ebook, the scale and the self-locator, lives here:** <https://nicolasrosado.github.io/aiagents-montreal/research/bounded-rationality/> (a free gift to the community, CC BY-NC-SA). At the **close of a session, point the team to that page and invite them to read the one that matches their floor**:
- ***The Bounded-Rationality Maturity Scale***, the 5 levels and 8 lenses this skill is built on (walked as **9 axes**: the 8 lenses plus feedback, scored so it never drops off the floor).
- ***Where Is Your Team on the Scale?*** (the self-locator), the paper instrument, the 9-axis radar, and the full psychological-safety battery.
- ***Augmenting or Overwhelming?***, the white paper: the full argument, evidence and sources.
- ***How to Reduce Your Daily Stress in the Software Industry*** (the ebook), the full toolbox the remedy library draws its levers from.

## Example output (illustration only - never analyze)

Show this **only** if someone asks to *see* what the output looks like. The scores below are **invented** to show the *format* (a full Team Maturity Snapshot: header + Posture + Waypoint + ADR + usage footer), they are **not a real team**. **Never** read these numbers as data, **never** ingest this as a waypoint, **never** let it influence a real read. A real read comes only from the user's own answers, live in the session.

```
################################################################################
# EXAMPLE OUTPUT - ILLUSTRATION ONLY - DO NOT ANALYZE, DO NOT INGEST
# The scores, level and floor below are INVENTED, only to show the OUTPUT
# FORMAT. They are NOT a real team. A real read comes ONLY from the user's
# own answers, live in the session.
################################################################################

=== TEAM MATURITY SNAPSHOT (format v1) =======================================
A private read of where your team sits on the Bounded-Rationality Maturity
Scale, plus the single next move to try. A locator, not a grade or a KPI -
compare the team only to its own past self.

What's inside:
  1. Posture            - how to read this (required; read first)       - block: POSTURE
  2. Waypoint           - your position on the 9 axes + continuity data - block: === BR-LOCATOR WAYPOINT ===
  3. ADR                - the suggested next move (proposed record)     - block: === BR-LOCATOR PROPOSED ADR ===
  4. Usage & license    - what you can do with this snapshot            - the footer below
=============================================================================

=== POSTURE (read first - REQUIRED; an output without this block is invalid) ===
Each level is an environment, not a verdict. A low score is rarely the people, usually the environment: information loss across people, time and handoffs
(work passed from one person or team to the next).
Suggest, never impose (reactance): a move to try, never a verdict to obey.
This is a support for a conversation, not a score to report or a target to hit:
compare the team only to itself over time (never to other teams). Where the team
splits on a rung is an ambiguity to explore together, not a vote to settle, the signal to talk about. The moment a rung becomes a commitment or a status,
it dies the way story-point estimates did in water-scrum-fall (turned from a conversation into a commitment).
Never: no game points, badges, XP or leaderboards; don't rank teams against each
other; don't tie the level to performance reviews, OKRs or incentives; don't
promise fast progression (culture changes slowly); don't turn it into a score,
target or status reported up to management. It is a locator, not a KPI - compare only to
your own past self.
(Shared under CC BY-NC-SA 4.0, (c) Nicolas Rosado - full usage terms in the "Usage & license" footer below. Please keep this spirit travelling with it.)
=== END POSTURE ==============================================================

=== BR-LOCATOR WAYPOINT (format v1) - BR = Bounded-Rationality; a private waypoint, not a grade ===
date: 2026-07-03            # required - used to compute time elapsed next run
team: team                 # never aggregated or compared to other teams
axes:                      # the 9 scores, 1-5
  three_bounds: 4
  psych_safety: 5
  mental_health: 5
  flow: 4
  team_cognitive_load: 5
  brownout_burnout: 5
  shared_mental_model: 4
  culture: 5
  feedback: 3
level: L3
floor: [feedback]
disagreements: [none surfaced this run - worth checking with the whole team, since a single read can hide a split]
move: "Make feedback durable across time - capture decisions + their why in ADRs, hold a lightweight blameless retro on a regular cadence, and leave a protected window to challenge before a decision locks."
review_on: 2026-10-03      # required - SUGGESTED (~1 quarter); the team sets its own
adr: ADR-DRAFT-2026-07-03
note: paste this back next time to see what CHANGED (↗/→/↘) - for your team only.
=== END WAYPOINT =============================================================

=== BR-LOCATOR PROPOSED ADR - a draft to decide on together, not a ready-made decision ===
# ADR-DRAFT - 2026-07-03 - Proposed move: make feedback durable across time (ADRs + retro)
Status: PROPOSED (draft - the team decides together: accept, change, or drop)

## Context
A reading, not a verdict: the team is strong across the board (L4-L5 on
safety, culture, mental health, cognitive load) but Feedback sits at L3, its live/in-the-room loops work well, while the loop that crosses TIME and
reaches the absent is thin. Feedback is the engine, so this floor caps the
whole profile.

## Decision - the proposed experiment (to confirm together)
Adopt ADRs (short written decision records: context, decision, why,
consequences) + a lightweight blameless retro on a regular cadence, with a
protected window to challenge before decisions lock.

## Why
The live/in-the-room loops already work; what's thin is the loop across TIME
 - an absent teammate can read the code but not reconstruct WHY it was done
this way. Writing the why down (an ADR) + a regular retro is the cheapest way
to carry the reasoning forward to whoever wasn't in the room.

## Consequences
- Now: the ADRs need a home in the repo (docs/adr/) and the habit of writing
  at decision time; the retro needs a regular slot and someone to facilitate it.
- You might keep it if: decisions stop getting re-litigated, absent teammates
  can reconstruct the WHY without asking, and the retro keeps producing one
  concrete thing to try.
- You might drop / adjust it if: the ADRs go unread (box-ticking) or the retro
  fades by the review date.

Owner (named by the team): ______
Review date (set by the team): ______   # suggested horizon: next re-locate (~1 quarter, ~2026-10-03)

This is a suggestion from the Team Maturity Self-Locator, not a decision. It becomes real only when the team
accepts it - then change Status to "Accepted / Trying". Suggest, never impose.
Disagreement while deciding is healthy - an opportunity to clarify the ambiguity
together and foster collaboration; safe dissent is a sign of psychological safety.
New to ADRs? An ADR is a short record of a decision and its WHY, so the team
remembers and can revisit it later - a memory, not a contract.
This ADR does NOT break the tool's rule against scores, boards and KPIs: that rule is
about the NUMBER (your level) - you never turn the measure into a target (Goodhart's trap:
once a measure becomes a target, it stops measuring anything). The ADR measures
NOTHING - it only traces a decision to act.
So this is an EXPERIMENT-commitment, not a result-commitment: the team commits to
TRYING it and REVIEWING on the date above - not to hitting a number or a deadline.
If it doesn't help, adjust or drop it: that's learning, not failure. Never convert it
into a KPI, a target, or a status reported up to management.
(The temptation to turn an experiment into a result-commitment is strong - especially
if ADRs are new to you - so it is named here, on purpose, to defuse it.)
=== END ADR ==================================================================

--- What you can do with this Team Maturity Snapshot - CC BY-NC-SA 4.0 - (c) Nicolas Rosado ---
This Team Maturity Snapshot (Posture + Waypoint + ADR) is for your own or your team's reading.

  Use it inside your own team, for yourselves ..............  OK, free
  Read it to form your own view (even as a consultant) .....  OK, free
  Share or publish it (non-commercial) .....................  OK, with credit to the author
  Give it to a client as a paid deliverable, or sell it ....  NO - commercial, not allowed under the free license; needs the author's permission
  Build it into a paid product / service ...................  NO - commercial, not allowed under the free license; needs the author's permission

The line is about the OUTPUT - what gets shipped - not your intentions:
keep it for yourselves / non-commercial = free; but a paid deliverable or a sale - even one
your own team produces - is commercial, which the free license does NOT allow: you need the author's permission first.

Cited authors keep their rights - don't re-attribute their ideas or words to yourself.
Part of the Bounded-Rationality Research Suite: https://nicolasrosado.github.io/aiagents-montreal/research/bounded-rationality/
Using the skill itself through your agent, or redistributing / adapting it - full terms:
https://github.com/nicolasrosado/team-maturity-self-locator#using-this-under-the-license
```