fowler-brain.

Every AI tool drifts independently.

If you use Claude Code in one terminal, Cursor in another, Claude.ai for ideation, an Ollama model for offline work, and a custom agent or two on top — you're maintaining five separate notions of "how Justin works." Each tool gets re-taught the same lessons. Each tool drifts in its own direction. None of them remember what you decided last quarter.

The conventional fix is a prompt library. Save the good prompts somewhere, paste them when needed. This breaks at scale — prompts aren't enough to encode how you actually think, the prompts don't propagate when you switch tools, and the prompts have no lifecycle: nothing graduates, nothing retires, nothing connects an in-the-moment insight to the rule that should prevent the next occurrence.

The deeper problem: the most valuable assets in your work — the lessons you've learned, the way you frame decisions, the vocabulary you've evolved — are the assets least likely to be version-controlled. They live in your head, where they drift. They live in scattered notes, where they rot. They live in chat history, where they're lost when the context window resets.

Two layers. One repo.

A Brain that knows my style but not my goals optimizes the wrong thing. A Strategy file with no operating discipline gets ignored after week 2. Bundling them keeps Tuesday's decisions traceable to Saturday's strategy review traceable to the long-range plan — without any of those layers losing their own granularity.

Capture. Review. Promote. Distribute. Execute.

One source. Eight surfaces.

The compile step is what makes this different from a notes folder. Every adapter is a deterministic function of the Brain — so a change to global/communication.md propagates to every downstream surface on the next rebuild.sh.

One change at the source. Eight surfaces stay coherent. The cost of changing my mind about how to write a PR description goes from "update eight places, miss one, drift starts" to "edit one file, run one script."

Four phases shipped. Two trigger-deferred.

Phases 5 and 6 are deferred by design — they fire when their triggers fire, not on a calendar. Sophistication starts when a month of accumulated lessons gives the promotion algorithm enough signal. Evolution starts at the first quarterly architecture review. Neither is "behind schedule"; both are queued behind the conditions that make them worth doing.

Compounds across tools.

The architectural win: the Brain is a small, stable system that powers a large, evolving set of tools. Adding a new tool means writing one new adapter, not re-deriving how I want it to behave. Changing how I work means editing one file and re-running the compile.

Each rule pays for a past incident.

The Brain isn't theoretical. Most of its rules were paid for in real friction — incidents that cost time, broke a deploy, or generated the wrong output. A few examples (all are real rules, all are documented in lessons/):

• Never-silent-delegation rule. When a delegated subsystem (Atlas, Linear webhook, MCP server) is unhealthy, announce the red channel before falling back to a local path. Came from an incident where a Linear webhook was silently down and the local fallback masked the outage for hours.
• MCP preflight banner. At session start, a banner prints the count of failed MCP dispatches in the last 24 hours. Surfaced after an Atlas-down event went unnoticed across multiple sessions.
• Verification-before-completion rule. No "done" / "fixed" / "deployed" claim without a verification path on a different surface than the one being verified. Came from a series of incidents where a tool's success message was reported as truth — when the actual prod state was broken.
• No-speculative-Supabase-views rule. Verify a view exists before wiring a UI page to it. Caused by wiring three dashboard pages to view names that had never been created.
• Twin-label-field detector. Codified as a rule in the operating context for Salesforce work, and as a detector in the audit primitive (see Six-Layer Integration Audit).

Each rule is small. Each one prevents a specific class of recurrence. The compounding value isn't in any single rule — it's in the population of rules, every one earned, every one indexed by the lesson that justified it.

Personal. Private. Open architecture.

fowler-brain is a private repository — the contents include identity files, strategy decisions, weekly action plans, and lessons from real engagements that wouldn't survive open publication. What's portable, however, is the architecture: the two-layer split, the capture-review-promote-distribute-execute loop, the rebuild-script-as-distribution model, the lesson-bound-rule pattern.

If you're an operator considering building something similar: the architecture works. The discipline is harder than the architecture. The compounding only starts after about three months — by which point the rebuilt adapters are already cheaper to maintain than per-tool settings would be.

Architecture on request.

The fowler-brain source repository is private. The architecture pattern, distribution model, and operating loop are described in this case study and are free for any operator to adapt to their own setup.

If you'd like architectural diagrams or a walkthrough — reach out. I'm happy to share the design rationale and the failure modes I've worked around.