Sibling Kit Quest

Tracks

1. 01🌆Three Copies by Sundown

   0/4 lessons

   The measurement that bought a repository

   Nobody argues for duplicated code, which is why arguing about it never fixes anything. This track starts with an inventory instead: two apps seeded from a third in one afternoon, and a list taken hours later of exactly which layers already existed three times. Then the part that turns a tidiness complaint into an architecture decision — a bug that could not be found from inside any single repository, because it lived in the disagreement between two of them. The track ends with the ruling that followed (the apps stay separate; the shared layer gets one owner) and with the single question that decides, for any given module, which side of that line it falls on.

   Lesson list (4)

   • 01
     Same Shape, Same Day~12 min · duplication, origin, measurement, architecture
   • 02
     The Bug That Proved It~13 min · cross-app-bug, vocabulary, integration, measurement
   • 03
     Separate Apps, One Plumbing~11 min · architecture, monorepo, boundaries, decision
   • 04
     The One Question That Decides Membership~14 min · boundaries, design, judgment, decision-record

   ✓Quiz · 4 questions→

2. 02📦Vendor, Don't Package

   0/4 lessons

   The distribution model, and why the obvious answer was refused

   Once a shared layer has an owner, it needs a way to reach its consumers, and the industry has one answer: publish a package and pin a version. This track walks through why that answer was examined and declined for this particular family — a handful of private repositories running as loopback siblings on one machine — and what was chosen instead: copies, deployed by a script, each carrying a provenance header naming its source and the commit it came from. It covers what the copies buy (every repository still builds from its own checkout, every update is visible in the consumer's own history), what they cost, and the discipline that keeps this from being an excuse: the decision was recorded together with the conditions under which it should be reversed.

   

   Lesson list (4)

   • 01
     The Obvious Answer, and Why Not~12 min · packaging, distribution, trade-offs, decision
   • 02
     A Copy With a Birth Certificate~13 min · provenance, tooling, deploy, implementation
   • 03
     Self-Contained Is the Point~11 min · backup, resilience, review, doctrine
   • 04
     Name Your Reversal Condition~13 min · decision-record, judgment, process, architecture

   ✓Quiz · 4 questions→

3. 03🦷A Check With Teeth

   0/4 lessons

   What makes a copy stay a copy

   Vendored copies without enforcement are exactly the situation the shared repository was created to end, so the check is not the optional half of this model — it is the half that makes the other half defensible. This track builds it: strip the volatile provenance line, substitute per-repository template variables before comparing rather than after, refuse to deploy a placeholder that nobody supplied a value for, and — the part that turns a script into a rule — run the whole thing from each consumer's own test suite, so a hand-edited copy fails that repository's tests until the edit is reverted or made upstream. It ends on the failure that taught the rule's real shape: a rule stated as a file path silently exempted the one consumer that could not host that file.

   Lesson list (4)

   • 01
     Strip the Header, Compare the Body~13 min · drift, tooling, testing, implementation
   • 02
     Substitute Before You Compare~12 min · templates, drift, tooling, design
   • 03
     The Placeholder That Shipped~13 min · failure, tooling, silent-failure, design
   • 04
     Whose Suite Runs It~13 min · enforcement, rules, failure, process

   ✓Quiz · 4 questions→

4. 04🔧Parameterize, Never Fork

   0/5 lessons

   How one implementation serves apps that disagree

   Sharing code between applications that are genuinely different requires a technique, not just a decision. This track is the seam catalog: the shim, where each app binds shared machinery to its own constants in a handful of lines it owns; the injected column name, which lets one schema builder serve workshops that disagree about what a row is even about; the parameter that turns an entire feature off for an app that deliberately does not have it; the discipline of no shared module importing another, with the single recorded exception and what that exception cost; and the two shapes of extension point — a value you pass in, and a slot the app fills with whatever it wants — including the case where a slot absorbed an entire interactive surface without the shared component changing at all.

   Lesson list (5)

   • 01
     The Shim Is the App's Half~12 min · shim, seam, design, implementation
   • 02
     Inject the Column, Keep the Schema~14 min · sql, schema, migration, implementation
   • 03
     Some Apps Don't Have the Feature~12 min · divergence, design, judgment, records
   • 04
     No Module Imports Another~14 min · imports, layout, discipline, exception
   • 05
     Slots, Props, and the Thing You Didn't Anticipate~12 min · ui, extension-points, components, design

   ✓Quiz · 5 questions→

5. 05🚧The Line the Kit Never Crosses

   0/4 lessons

   Where the instinct that removes duplication starts doing damage

   A repository that holds shared code exerts a constant pull. Every time two apps need something similar the cheapest move is to put it in the shared place, and each individual instance of that is defensible — which is exactly how a plumbing layer becomes a framework nobody can leave. This track walks the boundary from both sides: the mirror rule that keeps domain code out, the two name canonicalizations that run in opposite directions on purpose and must never be merged, one data file rendered into three language bindings so that no vocabulary is ever hand-mirrored, and the reason a shared client is deliberately thin — because the sequence it would otherwise reimplement lives at its owner. It closes on the other half of sharing, which is not code at all: the written wire contracts that let a thin client stay thin.

   Lesson list (4)

   • 01
     Domain Never Migrates In~12 min · boundaries, framework, discipline, design
   • 02
     Two Namespaces, Opposite Directions~14 min · vocabulary, boundaries, data-integrity, design
   • 03
     One Catalog, Three Languages~13 min · codegen, vocabulary, validation, implementation
   • 04
     The Client Is Thin Because the Owner Is Not~13 min · contracts, ownership, api, architecture

   ✓Quiz · 4 questions→

6. 06⚰️How a Duplicate Dies

   0/5 lessons

   Promotion, merging, and counting by sweeping

   Extraction is not a single event, and the interesting part is not the first one. This track is about the ongoing practice: when a pattern has earned promotion (usually the third copy, with a named exception for the case where waiting is more expensive than moving early), what to do when a parallel convention has grown to the point where promoting it would put two versions of the same thing inside the repository that exists to remove duplication, how to count adopters when a handoff note and the filesystem disagree, why the things you deliberately decided NOT to unify have to be written down with their reasons, and why a ledger of who uses what is a different document from a manifest of what is deployed where — including the day that ledger silently lied because a column was added and the rows were not.

   Lesson list (5)

   • 01
     Promote at the Third Copy~12 min · rule-of-three, promotion, judgment, process
   • 02
     Don't Admit a Second Chrome~13 min · merge, lineage, judgment, convergence
   • 03
     Count by Sweeping, Never by Memory~12 min · scope, verification, process, failure
   • 04
     The Non-Adoption You Write Down~13 min · records, boundaries, judgment, decision-record
   • 05
     Adoption Is Not Deployment~13 min · ledger, records, failure, verification

   ✓Quiz · 5 questions→

7. 07🧾The Price of Converging

   0/5 lessons

   What each adoption actually cost, measured rather than assumed

   Consolidation is usually argued in the abstract and paid for concretely, one application at a time. This track is the invoice. It covers converting cheapest-first and writing down what the first one cost so the rest are estimates instead of hopes; the app that had to delete three settings controls while the identical question cost the next three apps nothing; the permission attribute whose silent removal would have taken a feature with it; the optional slot that broke nine consumers because it was only ever verified in the two that use it; and the deploy-order rule for a family that is not versioned APIs but loopback siblings on one machine, where a half-deployed window manufactures false confidence.

   Lesson list (5)

   • 01
     Price the Cheapest One First~11 min · migration, planning, measurement, process
   • 02
     What It Cost to Give Up the Sliders~13 min · migration, trade-offs, product, judgment
   • 03
     The Permission That Would Have Vanished~13 min · migration, silent-failure, capability, review
   • 04
     Verify Where the Prop Is Absent~14 min · testing, sampling, layout, failure
   • 05
     One Window, Not a Version~12 min · deploy, contracts, operations, discipline

   ✓Quiz · 5 questions→

8. 08👤The Rules That Are About People

   0/5 lessons

   Policy, defaults, and the things a check cannot hold

   The last track is about the parts of a shared layer that are not code problems. Deciding a policy once, with the owner, instead of letting each app answer it differently and calling the difference architecture. Declaring a migration flag with a stated end so it does not quietly become a permanent choice. Recording a dead end — an approach that satisfies every measurement and still reads wrong to the person using it — so nobody re-walks it. The day four independent robot icons appeared across one family because nobody owned what a face should look like, and the fix that was a default rather than a rule. And finally what a shared-plumbing repository actually buys, what it costs, and the honest test for whether you need one at all.

   Lesson list (5)

   • 01
     Decide the Policy Once~12 min · policy, consistency, judgment, governance
   • 02
     A Flag With an End~12 min · migration, flags, discipline, design
   • 03
     Write Down the Dead End~13 min · measurement, judgment, records, design
   • 04
     Nobody Owned the Likeness~14 min · identity, defaults, design, governance
   • 05
     What the Repository Actually Buys~13 min · closing, trade-offs, judgment, architecture

   ✓Quiz · 5 questions→