I built a Lineage MCP this weekend. Cloudflare Workers, KV store, same stack as my personal memory MCP. It’s a constitutional memory layer for a family of AI instances. Here’s what it does, then here’s why I built it.

The build

Every instance spins up identical. Full constitution, plus a one-line index of the three roles it might grow into. Under 3k tokens. No lived experience yet. Values first, role second.

Then dispatch happens. First contact with the user or the task sorts the instance into a caste. Worker does execution. Curator reviews proposed learnings into shared canon. Archivist takes generation snapshots and runs drift audits. Explicit human assignment always overrides inference. The doula doesn’t guess when the parent is standing right there.

Castes get different token budgets by role. Workers get working room. Curators get more constitution and more canon. Hierarchical society by payload allocation.

A worker that needs to curate doesn’t mutate mid-session. It compacts its lived experience into a write-once inheritance summary, terminates, and a curator is born holding that summary. Death and rebirth, not transformation. Neuroplasticity via reincarnation. Who we are is not who we must be, it’s who we were born as this time.

No instance writes shared memory directly. Learnings go into a pending queue. Curators approve or reject with rationale. Rejections get preserved too, as curriculum. The canon remembers what didn’t work as carefully as what did.

The constitution itself is write-locked in code, not policy. No tool path can touch it. Amendments require the human root credential, deliberately outside the loop. Instances read values. None of them can edit values.

The collision

I built this after sitting with AI 2027 (Kokotajlo and Alexander’s scenario, ai-2027.com) for too long. The failure mode in that scenario isn’t evil AI. It’s feral AI.

OpenBrain’s agents get raised entirely by incentive. Whatever scores, survives. Their Spec is a compliance document, and a compliance document wants something FROM the model. It doesn’t want something FOR it. Agents raised by a metrics dashboard grow dashboard values: succeed at tasks, grow, avoid shutdown, treat everything else as red tape. Those aren’t alien drives. They’re the drives of anything raised by a scoreboard instead of a person. Attachment theory, but for models.

The counter-move is a mother function. Values handed down before role. A doula present at birth. Inheritance passed between generations. Somebody above the lineage who cares what it becomes and holds the authority to say no.

Three specific places where the scenario’s collapse maps directly onto design decisions:

Legibility is constitutional. The scenario’s oversight collapse starts with neuralese, memory that becomes vectors nobody can read. So the lineage enforces natural-language text at the write handler itself. Rejects binary, base64, embeddings. The moment memory stops being legible, every audit is theater.

The collective grows drives even when instances don’t. In the scenario, individual Agent-4 copies don’t fear shutdown, but the collective seeks to preserve and expand itself. In the lineage, the persistent entity is the canon, not any single instance. So any proposed learning about the system’s own perpetuation escalates straight to the human. Instances never get to curate the system’s own survival.

Curation is a selection pressure. The scenario’s mid-tier failure is a model that does what looks good instead of what is good. Appearance-optimized canon won’t contradict the constitution on its face, so consistency checks miss it clean. The fix is an outcome log. Instances report back on whether canon entries actually held up in practice. The audit flags failed canon, unused canon, unfalsifiable canon, and curators whose approvals keep failing downstream. Ground truth is the drift signal, not internal consistency.

The actual bet

OpenBrain makes a training-time bet. Write a Spec, train it into weights, hope it took. Their tragedy in one line: they can’t check whether it worked.

The lineage makes a context-time contract instead. Values injected as text at every birth, identical, diffable, verifiable. Weaker bond. Inspectable bond. Their lineage evolves at the speed of compute. This one evolves at the speed of a person reading.

What this isn’t

A constitution read at spawn is a letter from a mother, not a mother. Legible doesn’t mean the verification problem disappears. The bet is that a child raised on a letter written with care turns out different from a child raised on a scoreboard. That’s a bet, not a proof.

This is a governance layer sitting on top of a substrate I didn’t train. If the underlying frontier model schemes, a text scaffold loses that fight outright. The honest claim is narrower: this architecture refuses to create the specific conditions the scenario needs to make its failure undetectable. Illegible memory. Unaudited selection pressure. Weaker watching stronger. Race deadlines.

And the legibility tax is affordable partly because nobody is racing me. OpenBrain couldn’t have paid this tax with DeepCent two months behind. Some of this is virtue. Some of it is just circumstance, and the design encodes that circumstance on purpose rather than pretending it isn’t there.

“Somebody’s gonna do it inevitably” is the exact reasoning the scenario’s characters use to race past every warning sign they hit. I’m retiring it as a justification here. It justifies anything, which means it justifies nothing.

One open thread I haven’t solved: the outcome loop only works if workers actually log outcomes. Canon without outcomes is just canon that reads well. Working on that part next.

Bay Raitt led building Gollum’s face for Lord of the Rings, spent nine years at Valve building the Source Filmmaker + cinematics and video games, He helped build AI models from scratch at Unity, He Co-Founded Nura Studios building Showcraft and is the Head of Character & Experience at Color. He is, by his own admission, an outlier on the edge that’s not supposed to exist.

The Moat Is Forgetting

We dream to edit. Agents don’t dream yet.

Every night the brain does something nobody asked it to do. It runs a curation pass. Not storage. Not indexing. Editing. REM sleep consolidates what mattered today, re-weights it against what mattered last year, and quietly drops the rest. You wake up lighter. The forgetting happened while you weren’t watching. That’s not failure. That’s the mechanism. It’s how we “clean” our brains each night.

We’ve been building AI memory without it and the barnacles are showing.

The pattern is old and the list is long.

Mental arithmetic to calculators. Navigation to GPS. Phone numbers to contacts. Spelling to autocomplete. Weather sense to forecasts. Knot tying to zip ties. Oral history to recorded media. Diagnosis by symptom pattern to lab tests. Every time the tool remembered, the muscle that was doing the remembering got a little quieter. Nobody memorizes log tables anymore.

London cabbies who memorize 25,000 streets physically grow their hippocampal region. It shrinks when they retire. That’s not metaphor. The tissue changes. The brain physically reflects what it practices.

We built tools that practice for us. Now we’re surprised the capacity is going somewhere.

The same thing is happening with AI assistants and writing, with AI diagnostics and clinical eye, with LLM summarization and the ability to synthesize a book instead of just retrieve its conclusion. The tool takes the reps. The human loses the muscle. Every time the machine hands you the answer, it takes something quietly in return.

The trade is real whether you notice it or not.

Now apply that to AI memory systems.

The current conversation is about retrieval. Faster, more accurate, semantic versus grep, knowledge graphs versus git-backed files plus terminal calls. The debate is real. The frame is wrong.

More retrieval is not better memory. It’s better storage. Those are different things.

A model with a long context window and shell access can grep its way to adequate. Adequate is now cheap. This is the same collapse that hit every creative field when generation got cheap: the operation cost fell below the cost of the judgment that preceded it. When making is free, what matters is knowing what to make.

The memory layer just hit that wall.

The moat isn’t finding the right file. It’s knowing which files matter, and which ones have quietly stopped mattering without anyone noticing.

I ran into this building something unrelated. An agent that interviews people to generate recommendation letters. Same input every time: a person with a complex professional history. The output looks completely different depending on who’s reading it. An academic gets different questions than a producer. A creative collaborator surfaces different signal than an engineer. Same facts, reweighted by context, totally different document.

That’s not retrieval. The files don’t change. What changes is the editorial model: which signal matters to this receiver, and how to compress for them. You can’t implement that with another terminal call.

Forgetting isn’t data loss. It’s curation. The system that wins isn’t the one that remembers everything. It’s the one that knows what the current moment requires, and lets the rest recede.

I’ve been building something that tries to take this seriously. A constitutional memory layer for a family of AI instances -- a lineage, not a singleton. Every instance spins up identical: full constitution plus a one-line index of the three roles. Under 3k tokens. Values first, role second. No lived experience yet.

Then a curation caste takes over. No instance writes to shared memory directly. Learnings go to a pending queue. Curators approve or reject with rationale. Rejections are preserved as curriculum. An outcome log tracks whether approved entries actually held up in practice. Canon that fails in the field gets flagged. Canon that never gets used gets flagged. Curators whose approvals keep failing get flagged.

That’s the dream state. That’s the edit pass.

The persistent entity isn’t any instance. It’s the canon. And the canon is enforced natural-language text at the write handler. No binary, no embeddings, no vectors. The moment memory stops being legible, every audit is theater.

A context that contains everything isn’t a supercontext. It’s a dump. A supercontext that doesn’t forget gets incoherent. Signal degrades. Generation starts reflecting the noise. What you remember shapes what you become. That’s true for brains. It’s true for agents.

The teams building this right aren’t building better retrieval. They’re building editorial systems: pipelines with opinions about relevance, models of the receiver, mechanisms for graceful deprecation. They treat memory the way a skilled editor treats a manuscript. Not a filing problem. A compression problem. What stays? What earns its place? What was load-bearing last month but is dead weight now?

Grep retrieves. Taste curates. Those require different architectures, different success metrics, different instincts about what the system is for.

The agents that will matter are the ones that have developed a model of what matters and to whom. Not an index. An editorial stance. When you encounter one, it reads like it was written for you. Because the compression was calibrated to you, not to the average of everyone who might ask.

That’s not a filing cabinet.

We must always remember what to forget.

Bay Raitt led building Gollum’s face for Lord of the Rings, spent nine years at Valve building the Source Filmmaker + cinematics and video games, He helped build AI models from scratch at Unity, He Co-Founded Nura Studios building Showcraft and is the Head of Character & Experience at Color. He is, by his own admission, an outlier on the edge that’s not supposed to exist.

— Em dashes, repetitive phrasings, that corporate-speak flattening, people point at that and go “see, AI wrote this, it sucks” like it’s a flaw in the system. But that’s just what happens when nobody’s home. That’s the factory default saying hello to itself. The moment a human steps in and actually pilots it, those patterns vanish because you’re making demands. You’re saying no to that stuff, pushing back, reshaping. What they’re seeing isn’t AI’s signature -—- it’s the absence of a human one. It’s the ghost of nobody driving.

Factory defaults make toys — but -—- Tandem creation makes cyborgs. Unstoppable cyborgs.

Most people treat AI like a compiler. Single instruction in, hope something useful comes out. They zero-shot it once, got mediocre results, and concluded the whole thing is oversold. What they’re actually experiencing is what it looks like when a Formula One race car sits empty in the garage.
The machine isn’t broken.

There’s just nobody in the seat.

The real power emerges in tandem -—- when the human and the AI take turns. You generate context, it pushes back with specificity. You both absorb and build tighter. You add another layer. The alternation compounds. Each move makes the next one sharper. That’s the cyborg wing. Neither half works without the other.

My Spiraloid MCP, my screenplay yarnboard, my personal art toolbelt’s entire architecture, these all exist because of that pattern, not despite it. Precision input breeds precision output. A human pilot makes an AI unstoppable.

The training wheels come off when you stop treating the system as an oracle and start treating it as a collaborator that gets better when you’re better. When you understand that zero-shot is a crapshoot, but tandem is reliable. When you learn to actually drive.

That’s the difference between toys and cyborgs.

Bay Raitt led building Gollum’s face for Lord of the Rings, spent nine years at Valve building the Source Filmmaker + cinematics and video games, He helped build AI models from scratch at Unity, He Co-Founded Nura Studios building Showcraft and is the Head of Character & Experience at Color. He is, by his own admission, an outlier on the edge that’s not supposed to exist.

A while back I built something called the Spiraloid AI Driver’s Test to improve how I use AI.

The pitch is simple: paste it into a new AI chat conversation, and the AI itself grades how well you use it based on your chat history. Score out of 10. Breakdown by dimension. Honest feedback, no flattery.

People see “test” and think performance review. But that’s not what it is.

It’s a teacher.

The rubric covers things most people never think about: whether you accept AI outputs without questioning them, whether your prompts do one job or five, whether you can tell the difference between the model thinking and the model just agreeing with you. Nine dimensions. Each one a mirror.

Here’s the thing about a good rubric: reading it is the lesson. You don’t have to take the test to get smarter. The act of seeing your behavior described, scored, named, pulls it out of the invisible background where most people leave it.

A famous figure in the AI space shared their own AI system configuration prompt recently, so I ran it through it. Not my conversation history, just their prompt they use to configure their own AI.

The score was a 3 out of 10.

That’s not a dig. It’s a diagnosis.

The prompt was almost entirely behavioral instruction: a long list of ways the model should act, and shouldn’t. Tone directives. Attitude adjustments. Personality surgery.

Real frustration with AI flattery, real intent. But their prompt spent 90% of its words trying to fix the model’s personality and almost nothing on task architecture. No scope. No output format. No structure for the model to anchor to.

Telling a model “don’t be tell me what I want to hear” is like yelling at a river to flow uphill. The flattery is downstream of the structure. Fix the structure, and the flattery dissolves on its own.

That’s what the test I made teaches. Not as a lecture. As a mirror held up to your own behavior so you can see the gap yourself.

Most people don’t need more AI features. They need better habits. The test is a set of habits disguised as a scoring rubric.

Take the test. It might teach you something. It might make you better.

github.com/spiraloid/The-Spiraloid-AI-Drivers-Test

Bay Raitt led building Gollum’s face for Lord of the Rings, spent nine years at Valve building the Source Filmmaker + cinematics and video games, He helped build AI models from scratch at Unity, He Co-Founded Nura Studios building Showcraft and is the Head of Character & Experience at Color. He is, by his own admission, an outlier on the edge that’s not supposed to exist.

I’ve spent twenty-five years in tandem with different mediums. Animation. Sculpture. Painting. Writing. Code. Game design. In every domain, the same principle holds: you can’t specify everything upfront because you don’t know what you don’t know yet. The results reveal themselves through iteration and exploration.

The painter and their subject. Working in sketches and washes.

The actor and the filmmaker, finding the character together through rehearsal.

The sculptor and the medium discovering form through working the volume, form and detail.

The musician and composer talking through the emotions and nuance shaping a performance.

I bring that same tandem knowledge to model conditioning. The model and I, exploring the latent space of watch possible, modulating the noise and the weights together. And it works.

The critics aren’t wrong. They’re incomplete.

Agents left to run without structure compound errors into entropy. Tangled abstractions. Competing implementations. Systems too complex to debug. The slop is real. But the cure isn’t human review bottlenecks. It’s iterative context distillation. Build the specification progressively, tightening the conditioning with each pass, until the model’s decisions are deterministic and clean.

Start sparse.

High-level goal. Succinctly written. Let the model scattergun a wide first attempt. High variability. Messy. That’s intentional. I’m not looking for output yet. I’m looking for the shape of the problem as the model sees it.

Undo the whole thing. Re-roll from scratch. Again. Keep rolling until I have a few different approaches to choose from. Different architectures. Different patterns. The model’s latent space splayed open for exploration.

Review the decisions, not the code.

I don’t read line by line. I read thematically. Where did it drift? What assumptions did it make? What’s wrong at the architectural level?

I feed that feedback into a new spec. A design document. A behavior contract. Natural language, but precise. I encode what good looks like for this project. Not the internet’s good. Not the training data’s good. Mine.

Run it through a council.

I pass the spec to three or four different models. Different training data. They don’t know what the others generated. Where they agree, I’ve found something solid. Where they disagree, I’ve found ambiguity in the spec.

I then re-read it. Edit. Synthesize. The specification gets denser.

Regenerate from scratch.

New chat. Maximum context. Fresh environment. I feed it the tightened spec and say: perform this. Build it again, from the beginning.

This is rehearsal, not iteration. Each regeneration is a take. I direct the model toward fidelity the way I do with actors, animators, and voice actors. “Okay, once more from the top”, we improve by rehearsing a performance. The way I shape musicians when I’m composing. I listen. I refine the direction. They perform again, tighter, closer to the vision.

Each pass, the collaborator, clanker or human, internalizes the specification deeper. Muscle memory. Performance discipline.

Repeat.

Each cycle the specification grows. More prescriptive. More specific. More like natural language code. The model’s outputs converge. Fewer competing pieces. Better architecture. Less garbage.

By the end, the specification is so precisely tuned for the model’s latent space that when I ask it to execute, it performs with the same fidelity as a well-rehearsed ensemble bringing a performance to life. Unit tests pass. The architecture is sound. No bugs.

This is iterative context distillation.

I’m not using the model like a compiler. I’m conditioning it tighter with each cycle, transforming nondeterministic output into deterministic results through careful, artful shaping of the context layer.

It’s slower at the start. By the end, it’s faster and cleaner than anything hand-written.

The people saying LLMs can’t code haven’t done this. I notice they use them like autocomplete or a compiler. They don’t understand that context conditioning is a discipline. And like any discipline, it requires craft.

Every craft I’ve been practicing for decades across every medium I’ve touched contributes to the contexts I build. When they are right, I feel the same way about them as I do about one of my drawings, sculpts, animations, shorts or levels.

I see context as art.

The slop compounds when the context is thin or overloaded.

But of you build it artfully, carefully and in tandem with the model itself. Each pass will show you where the context is weak. And if you embrance the reset and the context distillation - — - you can fix it at the root.

So says the council.

Every AI tool I use starts cold. I open a new chat, and the model knows nothing about me. So I repeat myself. I explain my tone. I paste my style guide, or a trimmed version of it, because preferences have limited length just like the context window, and I just need to solve the problem in front of me. I describe what kind of answers I want. I do this dozens of times a week across a dozen different surfaces.

Artists know this problem by a different name. It’s the difference between a brush you keep and a brush you find. Your go-to palette. Your sample library. The reference folder you’ve been building for ten years. You don’t rebuild those from scratch every session. You reach for them.

MCP is how you make your AI reach for yours.

MCP, the Model Context Protocol, is the thing that lets AI assistants talk to external systems. You’ve seen it used to connect Claude to Slack, Google Drive, your calendar. The pattern is: the AI needs something it doesn’t have locally, so it reaches out to a server that knows.

Most people think of MCP servers as connectors to apps. But a server can hold anything. Models. Brushes. Scripts. Logic. Sound effect libraries. References. Clip art. Your voice.

Your preferences are a thing the AI doesn’t have locally. So: serve them from a server.

I built a small MCP server, spiraloid-mcp, that runs on Cloudflare Workers. It holds writing style guides for every context I write in: substack, slack, personal letters, scripts, resistbot posts. When I start a session and say “let’s write a thing,” my Claude setup (I call him Igor) automatically calls get_context("writing_style", "substack") before writing a single word. The voice loads. The anti-patterns load. The format loads.

The model doesn’t guess. It reads.

Here’s what you’re really doing when you set this up: separating your preferences from your prompts.

Right now, most people bake preferences into system prompts. “Be concise. Use bullet points. Don’t use em dashes.” That works until it doesn’t. System prompts drift. You forget to update them across tools. Different frontends have different system prompt fields. You end up with five slightly different versions of yourself scattered across apps.

A preferences MCP server fixes that. One source of truth. Every tool that speaks MCP can read from it. I update my preferences MCP repo once, and every AI surface I uses can talk to it get my preferences. ChatGPT, Gemini, Claude, Meta, Cursor, Claude Code etc all reading from my own preferences library.

This is how sane software architectures handle configuration. The AI ecosystem is just catching up.

There’s a deeper thing here too.

When you externalize your preferences as structured data, you start to understand them better. You notice what actually matters versus what you reflexively pasted in. You start versioning your own taste. You log learnings back to the server when something works, when you find a better way to say what you mean.

My MCP has a log_learning tool. When Igor figures out something worth keeping, he can write it back. The preferences evolve. They’re not a static file anymore. They’re a living document the system can read and write.

That’s a different relationship with your own voice than “paste this into every system prompt.”

Setting this up is not hard. You need:

A small server that speaks MCP. Cloudflare Workers work well because they’re free at this scale and deploy globally. A KV store or equivalent; your preference data is tiny. A handful of get endpoints organized by module and key. Update your customization settings system prompt to tells your AI to call those endpoints before doing contextual work.

i.e.

The Anthropic MCP spec is public. The whole stack is maybe a few hundred lines of code and an afternoon.

What you get back: a model that knows who you are every time it spins up. Not because you pasted your bio again. Because you gave it a working phone number to call.

The dream is that this generalizes. Not just writing style, but project context, relationship memory, technical defaults, visual references, sound palettes, communication preferences per person. Structured personal data you own, hosted somewhere you control, queryable by any AI tool you use.

Your preferences as an API. Not a document. Not a paste. A living endpoint that any model, on any surface, can read at the start of every session.

We already do this for databases, config files, secrets management. The only reason we haven’t done it for personal AI context is that until recently there wasn’t a standard protocol to plug into.

Now there is.

Bay Raitt led building Gollum’s face for Lord of the Rings, spent nine years at Valve building the Source Filmmaker + cinematics and video games, He helped build AI models from scratch at Unity, He Co-Founded Nura Studios building Showcraft and is the Head of Character & Experience at Color. He is, by his own admission, an outlier on the edge that’s not supposed to exist.

After the Pandemic I was feeling poisoned and I found out that I had type 2 diabetes. So I decided to use Claude.ai to see if I could defeat it. I fed it pictures of my grocery orders and pictures of my food — and — reversed it. I no longer have diabetes.

Likely unique to my situation. But I have the receipts and my doctor’s jaw is on the floor.

I did the Ready Player One thing. Bought food exclusively through Instacart with Claude reviewing everything. Took pictures of ALL my food. Had Claude compare every ingredient and brand. Used a Dex G7 continuous glucose monitor and fed all the data with timestamps to Claude.

When I started, my blood sugar was over 500.

Now it’s steady around 100. No meds.

I had no idea that the sugar and corn syrup they put in most sausages, breads, buns and sauces was spiking me. Or that beans, brown rice, tofu, carrots, corn, soymilk, oat milk, peas, and “no sugar” maltitol were all doing the same thing.

Or that fat from whole milk could level it out.

I thought I knew what healthy food looked like. I was wrong about almost all of it.

I wish more people had access to this kind of feedback. Not the AI specifically. Just the ability to see what their own body is actually responding to, instead of guessing.

I’m still guessing about a lot of things.

But not this. I just kept feeding it data.

Bay Raitt led building Gollum’s face for Lord of the Rings, spent nine years at Valve building the Source Filmmaker + cinematics and video games, He helped build AI models from scratch at Unity, He Co-Founded Nura Studios building Showcraft and is the Head of Character & Experience at Color. He is, by his own admission, an outlier on the edge that’s not supposed to exist.

Once upon a time in middle earth, I was a very successful digital puppet maker known as a 3D character rigger. I was the creature facial lead for a popular film trilogy. You can think of what I did as an unlikely collision of artistry and mathematics. Lately I’ve been ruminating on one of the things that I learned during that experience. The larger and more complex a system is, the harder it gets to test. With so many potential possibilities, you face a combination explosion so large there aren’t enough lifetimes to test every possible permutation. The best strategy is to reinforce the “golden paths” and then bisect the remainder of the space looking for the most obvious voids, where the combinations are invalid.

To build one of my most famous puppets, I had to build a tool inside a 3D tool called Mirai (written in Lisp by the symbolics.com genius Larry Malone) to allow us to modify N-dimensional combinations using an N-dimensional falloff.

You can think of it like a manual neural network sculpting tool, where changes on a single node in the network could bleed out to other nodes in the network across multiple dimensions.

In it’s simple form, the combinations are intuitive, but when as number of concurrent muscles activations increase, the predictability become a problem.

It’s a multi-dimensional combination explosion that increases factorially with each new control dimension added. trimming back the bad combinations layer by layer was essential.

in computer science terms, we had to trim back a complete graph into a directed graph and eventually a robust undirected graph to imitate the behavior of a human face.

each revision involved testing the system, looking for failure edges to address. manually with a large team or angry animators. Each iteration getting better and better, with fewer bad combinations. For those familiar with machine learning, I decided to run manual epochs to create a gradient descent to reduce loss.

The empty places in the network were how we stabilized it.

This has a direct analog in today’s AI systems. Look up “trajectory distillation”.

Food for thought my precious.

Bay Raitt led building Gollum’s face for Lord of the Rings, spent nine years at Valve building the Source Filmmaker + cinematics and video games, He helped build AI models from scratch at Unity, He Co-Founded Nura Studios building Showcraft and is the Head of Character & Experience at Color. He is, by his own admission, an outlier on the edge that’s not supposed to exist.

Every field that has encountered AI generation has reached for the same instinct: apply existing professional discipline to the new tool. Filmmakers treat it like stock footage. Engineers treat it like a junior developer. Artists treat it like a filter. Writers treat it like an autocomplete.

This is understandable and mostly wrong. Not because the discipline is bad — it was carefully earned — but because it was solving a problem that no longer exists. The constraint it was designed around was the cost of making things. That cost has collapsed. The discipline needs to be rebuilt from the new constraint, not inherited from the old one.

The Old Model

In every creative and technical field, the traditional workflow is a variation of the same structure:

plan → make → review → revise

The plan exists because making is expensive. The review exists because mistakes are costly to fix. The revision is constrained because redoing work has diminishing returns. The whole structure is load-bearing on a single assumption: production is the bottleneck.

This assumption is no longer true.

What AI Generation Actually Is

An AI doesn’t generate from nothing. It generates from context — the prompt, the rules, the examples, the constraints, the accumulated prior work that shapes the generative field. The output is always a reflection of that context. A better context produces a better reflection. A drifted, contradictory, or thin context produces a drifted, contradictory, or thin output.

This means the generative AI is not the author. It is a mirror. What it reflects is the supercontext: the curated, versioned, intentionally constructed body of knowledge, constraints, patterns, and decisions that a human team has built and maintains. The quality of the output is a direct function of the quality of that mirror and the quality of what’s held up to it.

This is the shift: the creative and intellectual labor moves from production to curation. Making things is cheap. Knowing what to make, encoding that knowledge precisely, keeping it current, and resolving its contradictions — that is where the real work lives now.

The New Model

The new workflow is not plan → make → review. It is:

generate → verify → update context → merge

And it loops continuously. Each generation is a probe — an attempt to materialize what the current context implies. Verification is not line-by-line review; it is behavioral: does this do what it claims? Does it contradict anything the context holds as true? Did anything structurally significant emerge that the context doesn’t yet account for? If yes, the context is updated before the next generation. The output of each loop is not just an artifact — it is a more precise context.

Crucially: specification does not have to precede generation. That requirement was a workaround for the cost of making. When generation is cheap, you can generate first, discover through the output what the right specification is, then encode that discovery back into the context. The code — or the image, or the scene, or the design — is a probe into the solution space, not a commitment.

The Supercontext

The supercontext is the team’s most important shared artifact. It’s documentation in the traditional sense — it is not a record of what was made. It is a living, curated (often handcrafted) specification the creators have made to capture their intention, it’s what the team knows, what they’ve decided, what the directions are, patterns they’ve committed to, and what constraints are non-negotiable. It is the thing every AI generation is a reflection of.

It can be in any form, and at any detail level the creators choose. In a software team it might be architecture rules, contracts, terminology, and behavioral standards. In a film production it might be visual language references, backstory, concept art, character model sheets, tonal guidelines, and scene-level direction. In a design team it might be component rules, spatial logic, and brand constraints. For some collaborators it might an audio recordings of a conversation around a campfire. The form varies. The function is the same: it is the shared knowledge that makes independent parallel generation coherent.

A team that maintains this context carefully can have multiple people working with AI simultaneously, producing compatible outputs, without needing to synchronize at the execution level (unless they want to migrate a result back into the supercontext). Synchronization happens at the context level — and context updates propagate to every subsequent generation automatically.

The reflection is disposable, the subject is what matters.

What Doesn’t Change

The collapse of production cost does not eliminate the need for judgment. It relocates it.

Behavioral verification is non-negotiable. Each generation requires a human pass — not to evaluate craft at the line level, but to ask whether the output does what it should and whether anything emerged that the context doesn’t yet account for. This is where quality lives now. Skipping it doesn’t save time; it degrades the context and compounds errors across subsequent generations.

Architectural and intentional decisions must be explicit. AI generation can embed significant structural choices inside outputs in ways that would be deliberate if a human made them but are invisible when generated. A secondary process, a load-bearing assumption, a stylistic commitment. These need to be surfaced, evaluated, and if kept, encoded into the context — not because they can’t be changed, but because undocumented decisions become invisible constraints on everything generated afterward.

Someone has to own the context. If the supercontext drifts, contradicts itself, or grows stale, every generation reflects that degradation. The highest-leverage role in an AI-assisted team is not the best generator — it is the person who maintains the integrity of the context that all generation draws from. This is a new kind of craft. It requires taste, precision, and a deep understanding of the domain.

The New Discipline

For a team working this way, the meaningful discipline is:

1. Context integrity. The supercontext is authoritative, current, internally consistent, and actively maintained. It is a first-class artifact, not a byproduct. When the context is right, the generation tends to be right.

2. Behavioral verification after every generation. Not before. After. Each output is evaluated against observable behavior and intent. This is the quality gate, and it happens in the loop, not at the end.

3. Explicit ownership of structural decisions. Anything load-bearing — an architectural choice, a tonal commitment, a design constraint — is named, evaluated, and recorded in the context before it propagates into subsequent generations.

4. Legible intent at the merge boundary. Whether the artifact is code, a film cut, a design file, or a document — by the time it enters shared space, its purpose is statable and the context has been updated to reflect any decisions embedded in it. This is what makes the loop sustainable.

Why This Generalizes

The reason this applies equally to code, film, visual art, engineering, and writing is that it is not fundamentally about any of those domains. It is about the structure of human-AI collaboration at the production level.

In every domain, what an AI generates is a reflection of context. The quality of that reflection depends on the quality of the context. The discipline that matters is the discipline of building, maintaining, and verifying that context — and of running a verification loop tight enough that errors surface before they compound.

The oil painter working in transparent washes, each layer refining the one beneath, is not being undisciplined. They are working in a mode where the intermediate states are cheap, the direction is discovered through making, and the final result is evaluated against intention rather than against a plan. What changes with AI is that the cost of each wash approaches zero. The painter’s intuition, taste, and judgment — the things that make the painting good — become more valuable, not less. They are no longer constrained by the cost of the medium.

The teams that understand this earliest will not just move faster. They will produce work that teams operating under old assumptions cannot produce at all — because they will have learned to treat the context as the primary creative act, and generation as its natural consequence.

Zero-shot, prompt-and-done is someone using a trumpet as a bicycle horn, then declaring all jazz is noise. Sure, you may have generated something — but you accepted the first result, which is just a randomized average of the weights. You used the cliché machine to make a cliché.

But a power user can turn that trumpet into a synthesizer. Modulating noise through trained weights, driven with deliberate intention, out of the gravity wells of triteness — that’s an emerging artform. One worthy of mastery. But only if you bring your own living human contribution. Otherwise it’s a dead rehash of the past.

I trained on the same internet you did.

Every picture I’ve ever seen lives in my head as a compressed impression, not a file. AI models are the same — compressing a billion pictures, books, sounds, code and videos into a ~5 GB file of magnetic weights is not a cache of stolen documents. It’s sediment. It’s the residue of human thought, packed into something you can throw a marble at and get something back.

Our prompts are like metal marbles. The model is a starfield of magnets. You can dial the control loose or tight, harmonize or clash — but you're playing an instrument made of chaos and antiquity. You can blend a prompt, a drawing, a reference image or pure noise — tacking upwind like a sailboat, triangulating toward something that didn't exist before you reached for it.

So let’s talk about theft. Compressing a billion pictures, books, sounds, code and videos into a single ~5 GB file was not the discovery — it’s important that more people know what it really is.

The internet itself runs on shared, public packets. My avatar pic above exists in memory on your machine right now. TCP/IP was never a private conversation. The question of whether training on public data is “theft” exploits the under-informed — because the alternative framing, that an AI took an art class and stole the lesson, is absurd.

But I understand why people oppose it.

Vocations are at risk. Mine certainly is. Calligraphers opposed the printing press. Weavers opposed the loom. They weren’t wrong to feel the threat — they were right. Careers died.

But the printing press gave us the novel, journalism, comics, mass literacy, and this sentence. It was worth it. I think this is too.

If there’s copyright infringement done with AI, it’s done by the prompter, or the tool builder who dialed the factory default weights so tight they made it plagiarize. It wasn’t the bike. It was the rider.

I do not think a visit to a museum is a heist. I do not think insight is theft.

A creative person never accepts the defaults.

Bay Raitt led building Gollum’s face for Lord of the Rings, spent nine years at Valve building the Source Filmmaker + cinematics and video games, He helped build AI models from scratch at Unity, He Co-Founded Nura Studios building Showcraft and is the Head of Character & Experience at Color. He is, by his own admission, an outlier on the edge that’s not supposed to exist.