A worked example of [[Build a Shared Brain|building a shared second brain]] at organisational scale, traced through [[Knowledge mapping|the three acts]]: decompose what a question depends on, place each piece in its container and judge its state, then match a method. It lands on a cross-project decision log, kept by a standing review group accountable for it. ![[Shared second brain example - ADR log.canvas]] ## Summary 1. Prompt *"should we use an event bus here - has anyone tried it?"* - the answer is locked inside other projects' repos and tech leads' heads 2. Per-project [[Architecture Decision Record|ADRs]] written but siloed (🟢 behind 🔒, unreachable across projects), the rationale 🟣 tacit, no cross-project index (🔴), no single place to look (🟡) 3. One shared cross-project [[Decision log|decision log]] with a standing review group as steward 4. [implementation] [[Notion]] ^summary ## The acts in one line each Prompt *"should we use an event bus here, and has anyone tried it before?"* decomposes into the prior decisions on that pattern, each project's ADR recording one, and the rationale behind each verdict - a cone that runs straight past the asker's project boundary. ^trail-line Where each piece lives: the ADRs sit in each project's own repo, written but reachable only by that team (🟢 behind a 🔒); the *rationale* for each verdict is 🟣 tacit in the tech lead's head; there is no cross-project index (🔴) and no single place that answers "who decided on this?" (🟡). The brokers - senior engineers spanning projects - are the bus factor. ^profile-line Lift the per-project ADRs into one shared, org-readable [[Decision log|decision log]] (single source), capture the tacit rationale, and stand up a small review group accountable for keeping it true. ^method-line ## Full walkthrough ### Act 1 — dependencies Start from a real question a tech lead on a new project actually asks: *"Should we use an event bus here - and has anyone in the org tried it before?"* Decompose what answering it depends on: - the **prior decisions** on event-driven architecture across the org; - each of which depends on the **project's ADR** that recorded it - the decision and its alternatives; - each of which depends on the **rationale** - *why* it was accepted or rejected, and the constraints that ruled. Traced down, the cone runs straight past the boundary of the asker's own project: the pieces it needs were produced by *other* teams. The leaves are concrete - Project A's event-bus ADR, Project B's, and the reasoning behind each. Where they live and what state they are in is the next act. ### Act 2 — containers Place each leaf in the container that holds it, and colour it: - **Project A's ADR** and **Project B's ADR** - each written, in that project's own git repo: 🟢 defined *within* the project. But the repo is gated (🔒) to its own team, so to the asker on a third project the dependency runs red - written and owned, yet **unreachable**. - **The rationale behind each verdict** - never fully written; it lives in the deciding tech lead's head: 🟣 tacit. Lose that person and the *why* goes too. - **A cross-project index** - the one thing that would let anyone find a relevant prior decision: 🔴 absent. - **"Who decided on this pattern, and where?"** - answerable only by asking around several repos and people: 🟡 no single source. The board shows it plainly: the knowledge is *written* but siloed per project, the reasoning is tacit, and nothing ties it together. The informal brokers - a handful of senior engineers who span projects - are the only path across today, and the bus factor with them. A board for this example: [[Shared second brain example - ADR log.canvas|the cone, coloured]]. ### Act 3 — method Read the move off each colour: - 🟢-but-unreachable ADRs → **publish** them up into one shared, org-readable layer; - 🟡 scattered "who decided?" → **single-source** it: one cross-project log is the place to look; - 🟣 tacit rationale → **capture** the *why* alongside each decision; - 🔴 absent index → **author** the shared log that indexes them all. The moves converge on one method: a shared **[[Decision log|technical decision log]]** common to the whole organisation - every cross-project-relevant decision recorded with its alternatives and the constraints that ruled, tagged with its project of origin. A small **standing review group** (drawn from the spanning senior engineers) confirms each entry so it counts as an organisational decision, and is the container accountable for keeping the log current. ### Tool (illustrative, after the workshop) [[Notion]] - linked databases for cross-project tagging and querying, comfortable for non-engineers to read, in the same workspace where the organisation's process documentation already lived. The tool followed the method (shared, queryable, cross-linkable, org-readable), not the other way around.