Learn
/ Why v1.3 is a minor bump
Insight · v1.3
Why v1.3 is a minor bump.
Five layers of the protocol moved in the same release. None of them was a bug fix. All of them changed where discipline lives. That's a paradigm shift, not a patch. So we called it minor.
Patch vs minor, what we're actually versioning.
The v1.2 line was a philosophy shift. v1.3 is a locus shift. Different shape of change, different version digit.
v1.2 told the harness to coach instead of punish. v1.2.1 patched the bits that didn't work. v1.2.2 hardened what did, with 29 days of clean production data behind it.
v1.3 is not the next step in that line. It changes where discipline lives.
In v1.2.x, discipline lived in rules plus hook-enforcement. You said the thing. The hook nagged when you broke it. The audit caught what slipped through.
In v1.3, discipline lives in structure that makes the failure mode hard to occur. Same discipline. Shapes that don't need ceremony to enforce.
Rules need case studies before they're rules. Schemas migrate when at-scale evidence says they should, not when someone remembers. The harness stops policing every interaction and gets out of the way. Public commitments get watched by a folder, not by a person remembering. That's a paradigm shift. Hence minor, not patch.
Five layers moved at once.
If only one layer had shifted, we'd have called it a patch. v1.3 moves five things in the same release because they're load-bearing on each other.
where discipline moved, layer by layer
incubation/ folder watches each commitment. Re-evaluation triggers fire when the world moves, not when we remember.The case-study gate is the keystone. Without it, the new schema is just a schema; with it, the schema is a rule that passes its own gate, twice over, by independent at-scale evidence. The hookless retirement is just a setting; with it, hookless retires its predecessor under the same gate's logic. Nothing ships without earning its place.
The brewery and the recipe.
One more concept lands in v1.3. It took 90+ days to surface and it changes how Hard Rules sit relative to the protocol family.
The protocol is the brewery. Yeast, water, grain, the brew cycle. These are constants. They make you "a kaygee protocol" at all. Files are memory. Generated beats maintained. Build the fence, not the net. RECORD after every logical unit.
uno, duo, tre. These are flavours. Recipes brewed in the same brewery. Different hops, different fermentation temperatures, different malt roasts. Same fundamentals.
uno · operate
an ale
Top-fermented. Monolithic CLAUDE.md, OS-spec shape, ongoing substrate. Domain-shaped daemons (ea, pa, km) brewed onto the same base.
recipe: OS for managing X
duo · construct
a lager
Bottom-fermented. Split docs (CLAUDE.md plus ROLE_PROTOCOL plus DECISIONS plus CONSTRAINTS). Construction site, blueprints and ADRs at hand.
recipe: building bounded things
The mistake we'd been making: treating the flavours as if they should be symmetric. Asking "why doesn't uno have a DECISIONS.md if duo does?" misses the point. uno is an OS spec, POSIX-shaped, monolithic. duo is a construction site, ADR-shaped, split. They're different beers. The right shape for an ale isn't the right shape for a lager.
What v1.3 codifies: Hard Rules sit at two levels.
→ Protocol-level rules apply to every flavour. You live and breathe them because you ARE a kaygee protocol. Files-are-memory. The case-study gate itself. RECORD after every logical unit.
→ Flavour-level rules apply because you chose this recipe. You live and breathe them because you ARE the uno flavour (or the duo flavour). N1 docs-travel-with-code ships in protocol-duo because the convergent evidence came from two Construct-flavour repos. It stays silent in protocol-uno and the maintainer itself. They're not brewing code.
The flavours can morph into each other. A duo project matures into uno-mode substrate when construction ends and ongoing-operations begin. A uno deployment spins up a duo sub-project for a bounded build. Rigid walls between flavours aren't there. Only the brewery is constant.
And even that's contingent. The definition of "beer" will change as frontier models change, as harnesses change. v1.3 is one snapshot. v1.4 will be another.
Three lessons that made v1.3.
The release wasn't designed in one sitting. It accreted from 90 days of evidence, including evidence we wished we'd had earlier.
Lesson 01 The worked example came before the rule.
In March we deployed v1.2 hooks to all 10 repos at once. Two independent reports came back finding the same failure mode: hooks-as-taskmasters generate resistance, resistance generates collateral damage. v1.2.2 fixed the philosophy. But the process by which we got there became the worked example for graduated rollout. Deploy to one repo, run for 29 days clean, then promote. The rule got named retrospectively. v1.3's case-study gate lets future rules earn their place the same way, prospectively.
Lesson 02 Some celebrations need correcting.
When Claude Code shipped hooks, we celebrated by implementing six of them across the fleet. Half stopped getting used. The other half were policing every interaction. One downstream repo, by accident, ran hookless from week one and didn't lose anything. Quite the opposite. v1.3 retires the celebration. Hookless becomes canonical default. Hooks remain available, opt-in. The rushed implementation was more damaging than helpful; recognising that took longer than it should have.
Anti-pattern
Celebrating a primitive by over-implementing it.
A new harness primitive doesn't mean every lifecycle moment needs one. The protocol's job is to know which ones we already had a hole for, and to leave the rest alone.
Lesson 03 Convergent invention is its own case study.
Two independent code-bearing repos arrived at the same Hard Rule, verbatim wording, neither knowing the other did. "After a code change, commit the matching documentation update in the same push." That's not coincidence. That's a structural truth being independently discovered. v1.3's case-study gate accepts convergent invention as a valid case study type. N1 (docs-travel-with-code) is the first flavour-level rule promoted under this logic. It ships in protocol-duo because both inventing repos brew the duo recipe.
The frontier ships features faster than we can incorporate them. Our job isn't to keep up. It's to know which ones we already had a hole for.
What folks should feel.
- →Fewer judgment calls at audit time. Rules either cite case studies or they're deletion candidates. The trim becomes a lookup, not a debate. The anti-pattern table stops growing without bound.
- →Fewer hook errors. The default doesn't police every interaction. If you want hooks, opt in. If you don't, the protocol still works, possibly better.
- →Clearer rule placement. Protocol-level rules apply because you ARE a kaygee protocol. Flavour-level rules apply because you chose this recipe. Both layers are visible. No more "why doesn't uno have what duo has?" Different beer.
- →A folder watching the falsification. The public claims we make at /learn now have a structural witness. If Cursor ships hooks, if Codex's /goal adopts an external judge, if native memory absorbs project-scoped state, we notice through the folder, not by chance.
- →Migration cost is real but bounded. Front-matter changes shape. Hookless settings get rewritten. Existing rules without case studies get flagged at the next audit. A 60-day compat shim covers the transition. After that, the old shape stops working. That's the point.
The through-line
The protocol's bet has always been that structure beats willpower. v1.3 takes that further: structure doesn't just beat willpower, it replaces ceremony. The harness coaches when it has to. The protocol brews when the moment's right. The human's role shrinks to judgment, the only part nobody else can do.
Where to Go Next
Keep going with the protocol.
Read next
Why we double down on Claude Code →
The convergence map. Five primitives the protocol always argued for. Five primitives Claude Code now ships natively. And what would change our mind.
related essay
How /goal slots into the loop →
The external-judge implementation. Same shape of fix as v1.3's case-study gate, one layer below it.
protocol
uno · operate →
OS for managing X. The ale flavour. Monolithic, ongoing substrate, domain-shaped daemons.
protocol
duo · construct →
Building bounded things. The lager flavour. Where N1 docs-travel-with-code lands first.
read first
AI Basics 101 →
The memory myth, files as ground truth, hallucination prevention.