Identity Doesn't Scale — It Diffuses
What the architecture looks like when you build for the interesting problem.
Howdy, folks. Going behind the scenes again.
This piece — the one you’re reading right now — landed in my drafts folder with the voice already tuned, the structure already sketched, and the thesis connected to three threads I’ve been pulling on for a month. I edited it. I didn’t draft it from a blank page. The blank-page part was handled by a cognitive scaffold I built called Psyche, which has been absorbing captures, bridges, identity files, and feedback for twenty-two consecutive days and now knows my voice well enough to produce first drafts I can actually edit instead of rewrite from scratch.
I want to tell you what that system actually looks like. Not the techno-mystical piece — I’ve done several of those recently already, and the queue for the next two weeks is mostly more of them. This one is the architecture piece. The one I owe you if you’ve been reading along and wondering okay, but what is this thing you built, actually.
Before we go: I’m a twenty-five-year software professional who used to write books and give conference talks about cloud-native architecture and distributed systems. The thing I’m describing runs on a MacBook Pro. It uses MCP. It has tests, a roadmap, a GitHub issue tracker, and a CHANGELOG.md. Nothing in the stack would shock anyone working on AI tooling in 2026. The interesting part is not the stack. The interesting part is the shape — what it was built to do, what it refuses to do, and why certain decisions that look local turn out to be load-bearing for the whole system.
Let’s go.
The thesis
Most personal AI systems are built to scale expertise. Second brain. Personal knowledge graph. RAG over your notes. The Tiago Forte lineage, one generation later, with a GPU.
That is not an uninteresting problem. It is just not the interesting one.
The interesting problem is scaling identity. Your values. Your voice. Your cognitive profile. Your archetypal patterns. The way you show up differently in a coaching conversation than in an architecture review than in a tarot reading at eleven at night. The variable capacity of your nervous system. The things you refuse. The things you love. The way your mind makes meaning.
That stuff doesn’t fit in a vector store. And if you try to fit it in a vector store, you’ll end up with a very smart robot that retrieves your content reliably and produces text that doesn’t sound like you no matter how many examples you feed it.
The thing that actually scales identity is not accumulation. It’s diffusion — identity gets distributed through every operation the system performs, such that when the system outputs something, the identity was already baked in before the first token was generated.
That’s the claim. Here’s the architecture.
Identity files are load-bearing
Psyche has an identity directory. It contains files like values.md, voice.md, voice-samples.md, cognitive-profile.md, archetypes.md, domains.md, and design-principles.md. They read like personal documentation — because they are — but they are not reference material the system optionally consults. They are constraints the system is bound by.
The voice file doesn’t say “be friendly and professional.” It says direct without blunt, structured but not rigid, emotionally honest, lightly irreverent. It includes an anti-patterns section — corporate speak, hustle-brained language, preachy tone, generic AI voice — and names those as failure modes, not stylistic preferences. When Psyche produces output in my voice, it either sounds like me or it has failed. There is no “close enough.”
The cognitive profile documents how my brain actually works: systems-thinking as primary mode, symbolic pattern recognition running parallel, ADHD and autism-adjacent variability as a design constraint rather than an edge case. Good-brain days get leverage and depth. Bad-brain days get one concrete small step. Never a comprehensive plan when I have nothing left. Never shame. Never a nag.
The archetypes file names the stack — Architect, Magician, Operator, Rebel, Teacher/Mentor, Seer — and the core tension between containment and expression, because the system needs to know which mode is active to know how to respond.
These files are the equivalent of constitutional constraints in a distributed system. They are enforced at the surface of every operation. When Psyche writes a draft, it’s reading voice.md. When Psyche responds to a question, it’s applying cognitive-profile.md. When I signal a mode shift, it’s pulling from archetypes.md. The identity is not retrieved-when-relevant; it’s present in every interaction by construction.
That’s what I mean by diffusion. Not storage. Not memory. Presence.
Capture: zero friction, no filing decisions
I am a Generator with Sacral authority and a line-3 experiential profile, in Human Design terms. What that means in practice: I create in response, not from a blank page. When something grips me — a book, a conversation, a card, an email I should not have opened — the energy to make something out of it is high for exactly as long as it takes my executive function to talk me out of it. Fifteen seconds, maybe. Thirty on a good day.
If the path from grip to captured artifact takes longer than that window, the idea dies. If capture requires me to decide where it belongs — which folder, which tag, which category — the filing decision absorbs the energy that should have gone to the capture, and I end up with a cold note instead of a live grip.
Psyche’s capture layer has exactly one requirement: zero friction between the grip and the record. I type into one interface. The system infers the focus area. Tarot material goes to symbolic-spiritual. A meeting recovery strategy goes to personal-operating-model. An email from an editor goes wherever the system decides it belongs. I never participate in that decision. I never touch a tag.
This is not a convenience feature. It is the load-bearing mechanism for a Generator-based creative pipeline. Structure that costs more energy than it returns is structure that gets abandoned. The capture layer is designed under the constraint that filing is more expensive than the material is valuable — so filing never happens at capture time.
Threads: Hemingway bridges and narrative continuity
My dominant failure mode is not lack of ideas. It is losing the thread. An idea arrives with energy. Life intervenes — meetings, context switches, the muggle job, the metabolic cost of being a person with a nervous system that doesn’t do “consistent.” By the time I come back to the note three days later, the energy that made it feel alive has dissipated, and I’m looking at something cold that says podcast episode about frameworks transcending their authors with no visceral connection to why that ever mattered.
Psyche’s thread layer is built to address exactly that failure mode. Each thread is a named line of inquiry — a business strategy, a newsletter arc, an open question — that persists across sessions and accumulates context through Hemingway bridges.
The name comes from Hemingway’s trick: stop writing while you still know what comes next. A bridge is a structured artifact the system writes at the end of a working session on a thread. It captures where momentum was, what’s unresolved, what was decided, and — critically — a re-entry prompt addressed to future-me.
When I pick up the thread days or weeks later, I don’t start from zero. I start from the bridge. The energy isn’t recovered — it’s preserved. That’s the mechanism. Threads have lifecycle (active / parked / completed / archived) and priority tiers, and a daily alignment workflow surfaces the threads that want attention based on what’s shifted since last session.
The thread layer is the memory of the system, but it is not memory in the database-with-retrieval sense. It is memory in the narrative continuity sense. The system holds the story so I don’t have to.
The content pipeline: capture → accumulate → surface → draft → publish
Material accumulates in swipe files by focus area. When enough captures cluster around a theme — three or more circling the same question — the system can surface the cluster and synthesize it into a draft. The draft comes out in my voice because the voice constraints are applied at generation time, not as post-processing. It is not write something and then make it sound like Matt. It is the thing that gets written is already shaped by how Matt thinks and speaks.
This piece is an example. The thesis lived across six captures from early April. The seed draft sat in the pipeline for three weeks. When I pulled on it today, Psyche surfaced the draft, the related threads, the current Feral Architecture publishing context, and the updated roadmap — and the revision happened in my voice because it couldn’t happen any other way.
The dream state — not fully built, but architecturally clear — is that the operational overhead between having something to say and it being live on a platform approaches zero. The Canva-plus-formatting-plus-algorithm-plus-posting death spiral that makes me never want to ship again gets automated into something I don’t have to touch. I set intent. I make judgment calls on the draft. The pipeline ships it.
We’re not there yet. We’re closer than we were three weeks ago.
Ambient: match state, not idealization
Most “AI assistant” mental models assume a consistent user interacting with the system on-demand. Psyche is not that.
Psyche is designed to be ambient. It notices when capacity is low and adjusts — no comprehensive plans when executive function is depleted, no pressure when the system can tell I’m fragmented, no shame ever. It surfaces threads that have gone stale. It logs activity without being asked. It ingests meeting transcripts and connects them to the right threads. It knows what music fits the current operating mode and, when the call goes out, plays it — or decides silence is the right call.
Doomscrolling, from the system’s perspective, is a broken interface to valuable information. I was doing manual retrieval on content feeds for hours a day because that’s where the signal lives. Psyche is the better interface — curate, filter, surface, stop. The system is supposed to match the shape of my life, not impose a productivity script on it.
The hard parts
Security and portability are the two problems I cannot defer.
The system accumulates real identity data. It acts on my behalf across platforms. The attack surface grows with the capability surface, and that is not a future-me problem; it is a now-me problem that gets harder the longer it’s ignored.
Portability has a specific shape: I work a muggle job at a company with strict data isolation requirements. Psyche has to be installable on that laptop with identity and workflow portable, and personal data strictly air-gapped in both directions. Company data never leaves the company. Personal data flows in as read-only. The architectural insight that made this tractable: identity and workflow live separately from data and context. Same identity files, same MCP servers, same workflows. Different data boundaries. Separation of concerns at the system level, load-bearing.
Learning is the other hard part. The system accumulates preferences and feedback — not just through an explicit learning skill, but through every correction I issue, every approval I signal, every time I say no, do it this way from now on. That state is load-bearing for coherence over time. A system that accumulates data without accumulating understanding is not actually learning; it’s just getting bigger.
What’s shipped
This is the part I was most reluctant to include, because it sounds like a changelog brag. It is a changelog brag. Live with it.
Two shipped milestones carry most of the story.
On April 17, v1.4 shipped. Seventeen phases. Forty-four plans. Sixty-six of sixty-six requirements met. Three hundred ninety commits. Plus a hundred fifteen thousand lines, minus two thousand, over the preceding nine days.
While I was writing this piece, v1.5 shipped. Substrate Fidelity and Correctness — the hardening milestone that makes everything above more trustworthy. Five more phases. Fourteen of fourteen plans. A hundred thirty-six commits. Another thirty-five thousand lines. Five more days. I wrote the paragraph, got up to make tea, came back, and the milestone was closed.
Eight MCP servers in production: threads, capture, activity, identity, semantic, credentials, media, workspace. A full slash-command skill library. A GSD workflow — Get Shit Done — that planned, executed, verified, and shipped every one of those twenty-two phases with atomic commits and reversible state.
Since Feral Architecture launched on April 3, the system has shipped seventeen newsletter pieces. Not written by Psyche — written by me, with Psyche, in a pipeline where the capture, surfacing, drafting, and publishing overhead is a fraction of what it would take to do manually. The newsletter exists because the system exists. The pipeline is the argument.
Why this matters
The standard frame for personal AI is get your stuff into the system so it can help you with your stuff. Second brain. Retrieval. Search. Offload.
That frame generates a certain kind of tool, and those tools are fine. But they’re aimed at the wrong target.
The real target is not your stuff. The real target is you — your variable capacity, your creative rhythm, your values, your voice, the shape of your thinking. The system that serves this target does not accumulate your expertise. It distributes your identity through every operation it performs.
That’s what I mean by diffusion. Identity does not scale by getting bigger. It scales by being present everywhere — at the surface of every capture, every draft, every bridge, every response. The system is not a second brain.
It is first-person infrastructure.
Build for the interesting problem.
Stay feral, folks.