Cortex

The first articulation was a file-sync utility: keep CLAUDE.md files consistent across Claude Code, Desktop, and Console. Reasonable. Buildable in a weekend. Wrong product.

The deeper problem wasn't files drifting out of sync — it was that Claude re-learns the same things in every project. Every new session, the same corrections, the same preferences, the same groundwork. The collaboration wasn't compounding. It was restarting.

"Always run xcodegen after a merge" is learned in one project. In a file-based world it stays there forever. The reframe: recognize it as an xcodegen-workflow pattern — project-type-agnostic — and make it available to any project that uses xcodegen, including projects that haven't started yet.

Projects consume skills; they don't own them. That single inversion — intelligence above projects, not inside them — is the kind of decision that defines a product category instead of a feature. It was a design decision before it was an engineering one.

The architecture was right; the harder problem was experiential. A real graph sits underneath — skills connect to projects, projects to corrections, corrections to sessions. But the moment a user feels like they're administering that graph — nodes, edges, relationship counts — the design has failed.

One principle resolved it: expertise, not infrastructure. The user should see "Claude knows how to do X," never "there are three edges connecting these nodes." That cascaded into rules I wrote down before any wireframes: skills named like capabilities, not rules; the graph never exposed directly; promotion never automatic; origin always preserved.

Skill promotion is the highest-stakes moment in the product. Too eager and the global skill set fills with project-specific noise; too timid and the cross-project learning never happens. The whole thing turns on a feeling: does this read as the system noticing something, or the system deciding something? The first earns trust. The second erodes it.

So the copy is load-bearing. The approved framing is observational and tentative — past tense, evidential, non-prescriptive: "You've applied this in Hopscotch and Tokenomics. It looks like a general practice — make it a skill so Claude uses it everywhere it applies."

Promotion asks first because the stakes are high. But most learning isn't — it's a correction you made in passing, the kind you'd never stop to file. Requiring approval for each one would make the system useless at volume. So capture inverts the rule: over-remember, then actively forget. Corrections are caught automatically, go live as probationary rules, and surface in a "Recently Learned" feed where a single thumbs-down pulls one back. The judgment moved out of the save moment and into the pipeline — decay and consolidation became the editor.

That created a subtler trust problem. Cortex reads its own past sessions to judge which rules are working — but those transcripts contain the very rules Cortex injected. A naive system would count "Claude followed this rule" as proof the rule was right. A rule shouldn't get to vote for itself. So injection stopped counting as evidence: a rule needs corroboration from two independent sessions to graduate, and one genuine contradiction can demote a rule that's been applied correctly a hundred times.

As Cortex assembles context from several layers, users need to answer one question without understanding the architecture: does Claude have what it needs for this session? Showing what's loaded isn't enough. What creates trust is showing what was left out — and why.

"signing-debug — not relevant here" is as important as the list of what loaded. Without that reasoning, an absence becomes a worry: did the system forget? With it, the absence is legible — a judgment about relevance. I borrowed the move from iOS Focus mode: surfacing what's off makes what's on feel deliberate.

Cortex serves two modes that one surface can't. Ambient awareness — a glance at status mid-session, then back to work. And deep management — browsing the graph, reviewing skills, reading what a session was built from. A 360-point menu-bar panel for the first; a full window for the second; one shared state behind both.

Designing the second surface is what let the first one be ruthless. With deep access living in the window, the panel didn't have to grow edit affordances and detail rows — it could stay a calm, three-row glance. Surface separation is scope discipline.

Before any view was implemented, I codified the foundations: a five-token spacing scale on a 4-point grid, a six-size type scale that signals hierarchy through weight rather than big size jumps, and a semantic color system — never hardcoded hex — so dark mode and accessibility settings come for free.

Two marks carry the brand into the product. The six-band wave — also the menu-bar icon — and the ✦ skill glyph, chosen over a checkbox precisely because a checkbox implies configuration debt. The ✦ signals presence from the global layer without implying anything needs managing. Used consistently, it means something without a legend.

For two months, Cortex's core promise — save a correction in one session, recall it in the next — was completely broken, in a way that looked completely fine. MCP tools returned success. Tests passed. The CLI printed confirmations. Five independent bugs were each masking the next, which is exactly why all five survived.

I found them by refusing to trust the logs — sitting down to run the actual demo and following what really happened at each step. Each fix exposed the next failure. No amount of unit testing would have caught this: every component worked in isolation. The failure lived in the seams between them.

Most AI memory tools are good filing cabinets — they store and organize, and never change. Cortex is built to behave like memory: it strengthens what you reinforce, lets the unused fade, and gets more useful the longer you use it. The architecture that made that possible also makes the business model honest — local runs free on your Mac at zero marginal cost, and cloud sync (in testing now, coming soon) is the only piece with a real per-user cost, so it's the only part that will be paid.