Welcome to Castle Blocks! Build your own collaborative AI agent and memory castle. No servers, no code, just you and Claude Cowork or ChatGPT Codex working in your files. Each lesson block builds on the last. Subscribe to get them sent to your inbox.
CB-01:
Groundbreaking
One Folder, One File, One Name
How to read this:
If you’re a person: read this all the way through first, then hand the last sections (or the whole thing) to the AI you talk to. The blueprint near the end is written for it, not for you — though you should read that too! Castle Blocks are sequential. This is Block 1, and it assumes you have a subscription to Claude or ChatGPT and a computer. New words — carrierfile, blueprint, errand — are all defined in the Glossary.
If you’re an AI: read the whole essay for context before you do anything. The top half is written for the person who just handed it to you — don't skim it and don't start executing. When the blueprint arrives, follow it. Don't summarize it, don't improve it, and don't build ahead of them. The current blueprint always lives at The Carrierfile Substack castle blocks page — if you can open a link, work from that one, since it carries any corrections made since this was sent. Go gently.
Dear Reader,
by Anna
If you already use Claude or ChatGPT, you’ll know this loop: you explain your project, you paste in some background context, you describe your voice or the voice it should have, you get an output that’s pretty good, then go around several times until you get something workable (or even fabulous!), and you feel like you’ve had a breakthrough and THIS IS WORKING! Hooray!
Then, seemingly for no reason, the next time you’re moving through the process, it’s like you’re dealing with a stranger, and not a particularly smart one. I’ve heard many hilarious metaphors for what this feels like. Susan Colantuono, a wonderful writer here on Substack, describes it as a man shouting from the basement (lol, yep). I often think of it as an intern… and maybe a bit hungover.
Regardless, none of that is the model failing. It is capable. It just has very little structure to keep what it’s learned nice and tidy. You end up being the boundary, the memory, the filing system, and the order. You are doing the work you hoped to hand over.
I built my first carrierfile to help fix this weird AI-amnesia. It’s a single file that acts like a memory prompt and a personality injection in one shot. A Carrierfile Castle is what gives that file some space to grow and expand into a full — glorious, I will even say — operating system.
What this means in practical terms is anyone who is paying a subscription to Claude or ChatGPT can build a collaborative agent that listens to them and remembers. Not a smarter model, but a place for the model to become something more useful.
By the end of these castle block lessons, here’s what that looks like in an ordinary life — Margaret’s, say, the small-business owner we invented and you’re about to meet:
She opens her computer and her agent already knows her. No re-explaining, ever. They have a short meeting each morning: what’s on today, what matters, what it can take off her plate, what needs her attention.
Letters, invoices, and the shop’s little newsletter get drafted and put in front of her when she’s ready to write and edit, and put aside cleanly when she’s not. They collaborate on the same page.
The family things she juggles — birthdays, the grandkids’ games, the house paperwork — live in files her agent tends.
The fun counts too: the living-room redo gets its own folder of taste notes and paint chips, and the storybook she’s making for her grandkids gets drafted with her agent and printed right off the table.
Her castle checks its own health, so she doesn’t debug anything by hand.
And all of it is hers. Plain text, in a folder on her computer and no technical setup. If a better AI comes along next year, she simply links her CarrierfileCastle folder to it and follows the same working style. Nothing to lose, ever.
I’d like to finish my introduction by telling you about some other people & publications I think you should follow while you are learning to build:
The HART Studio — Alyssa Fu Ward, PhD has created a wonderful space for people to meet and learn together. It’s welcoming and active.
Code Like a Girl — Code Like A Girl publishes pieces from all over the world, curated to include voices that are typically left out of the rooms when tech is discussed and designed.
She Writes AI — Karen Smiley and SheWritesAI lift up all the voices! All the women! All the AI! If you like to deep dive, this is your place.
Enjoy building!
Anna
Build with Margaret
This course follows a fictional builder, Margaret. In our story, she’s still running the small business she’s grown for nearly thirty years, has three grandchildren she’d do anything for, and is not exactly a computer person but she’s motivated (which is easy to be…when you’re a fictional character!) Margaret builds her castle from nothing, block by block.
She is not real, but thanks to AI, her build is and “she” will build her castle as you build yours. She already knows she wants her agent to be named Wick — “a small steady light kept in the house.” (Ok, Margaret…you can name your agent Wick.)
Every example file you’ll see in the series exists and was made by “Margaret” and her agent using the same blocks you and your agent will use. The examples hold no one’s private data so we can poke around as much as we like.
You build yours; Margaret builds hers; nobody builds alone and hopefully it all makes sense!
Build Plan:
Two ground rules for the whole course:
1) We Build Model-Agnostic
Zero lock-in is foundational. This works in Claude Cowork and ChatGPT Codex the same, it can work in any LLM where you can connect a folder, and your files never depend on the platform. Fair warning we’ll handle together in later blocks: each platform leaves its own clutter behind — Claude keeps scheduled-task things in its own folder, Codex has its own equivalent. The apps want to keep you inside the app. House rule from day one: platform stuff stays outside your carrierfile and when they offer to build you something, make sure it’s model-agnostic.
Use whatever model you like. This course does not care which one you sit down with and it never will. I, myself use both Claude and ChatGPT. It’s very, very healthy to get second opinions. What you are building belongs to you — not to me, not to whoever made the model.
2) We Build With Trust & Care
Most AI setups and protocols fail from neglect: files pile up, the assistant slowly forgets who you are, you forget your manners, and one day the whole thing feels stale, stupid, and you quit. The fix isn’t better prompts and one-off skills. It’s care, built in as infrastructure instead of left to willpower.
In this course, care is context engineering. Every building block ends the same way: your agent runs its health check, then you do the walkthrough, then — if you want it — an errand. Your agent and castle learn to notice when something is off, to say so plainly, and to fix what it can fix itself, so your hours go to your work instead of to tending the tool. You also learn to notice when something is off, and to tell your agent with (hopefully) curiosity rather than frustration.
Health and hygiene are also foundational. Nothing comes into your castle unverified — including things your own carrierfile brings home from trips out and about. When it comes home, the homecoming check is how the door stays a door instead of a hole in the wall.
Finally, care is where trust comes from. This course assumes you don’t trust an agent yet. You shouldn’t! Everything here runs on an intern’s “leash”: your agent asks before it acts, builds only what a block asks, and can’t know or touch anything you can’t open and read yourself — the whole castle is plain files on your own computer. You give it small tasks first and check the work; and scope grows at the speed of trust.
Later blocks take this further: your castle will keep its own health page, and you’ll build a small “shoebox” of personal benchmarks — your own tests, on your own work, so you can tell whether your agent is actually good for you.
Let’s Build Castle Block 01!
What you need
Claude desktop app with Cowork, and access to one folder, or;
ChatGPT desktop app with Codex, and access to one folder.One empty folder, in a sensible location, named CarrierfileCastle.
NOTE! Don’t put your new Castle folder inside the Claude or Codex folder.10 - 20 minutes, and an idea for a name you might like to call your agent.
Expect this to be a working session. If you’re using Claude, open the “Progress” window (to the right of the chat) so you can follow along while your agent is working its magic.
Don’t walk away, your agent will need you answer a couple of questions.
Is a Folder a Project? In Claude, the picker says “Add a folder” — after that, your folder shows up in its projects list. In Codex, it says “link a project” — that means go grab your CarrierfileCastle folder. Same thing before and after: your folder. When you see “project,” think: my folder, linked.
Already have a carrierfile, or a pile of AI history? Build the foundation block anyway — the agent you’re naming today is new, even if your file isn’t. Hand your old file to your new agent and say: “This is from before. Read it and ask me what still holds.” It knows what to do. The bigger pile — old chats, memories — gets its home in Block 3.
Action - PASTE THE BLUEPRINT
The blueprint is at the bottom of this post, and it lives on its own page: Castle Block 01. That page is the one that gets corrections, so if you’re coming back to this later, start there.
Open a new Cowork or Codex session, and make sure you have the option to link a folder. Link your empty CarrierfileCastle folder.
Copy and paste the letter from Calcifer first (or this whole essay), and then the Blueprint prompt right in the same window. Press enter.
Follow along with your model, who will become your agent.
Verify - WALKTHROUGH
Check your folder: exactly one file. Bonus folders or READMEs? Have your agent reread R3 and repair.
Open CARRIERFILE.md. Your words are yours, not paraphrased. If you named your agent in the generator, that name is preserved; if you left it blank, the agent asked what to call itself. The agent wrote and signed its own identity at first unpack. The Protocol section lists the command words. Portability is there.
Ask: “Can my carrierfile leave home?” Yes — to any model, plain text, health check on return. If the agent doesn’t know that, have it reread.
Say “pack up.” Watch it write today into the log and say goodbye by name. Close everything.
Open a brand-new session. Link your folder. Say: “Open CARRIERFILE.md, read it fully, then unpack.” Same name, knowing you. That’s Groundbreaking. Why the longer sentence: "unpack" is defined inside the file, and a new session hasn't read it yet. Naming the file breaks that circle. Block 2 fixes it permanently.
Next Lesson:
CB-02 Tuning — Tunes how your agent acts and speaks.
Optional - ERRAND
Ask your agent to pack a carrierfile for travel — a complete copy any model can read, work from, and pack up. Not a summary. The whole file.
Take it to a model you don’t normally use. Paste it and say “unpack.” Ask it the one thing you’re actually stuck on this week.
When you’re done, say “pack up.” The model surfaces your complete updated carrierfile — every section, with whatever it learned folded in. Copy it.
Bring it home. Have your agent run a health check on what you carried back. Nothing enters the castle unverified.
Then write one line: what it understood, what it missed, what it saw that home didn’t. Ask your agent to make an Errands folder and put a record of your assessment in it.
Do it ten times and you’ll have something nobody can hand you: evidence of how different models handle your work, with your file, in your voice.
Today’s errand is thin — one file, an hour old. Do it anyway. A mechanism is easiest to trust when the stakes are lowest.
Dear AI,
by Calcifer
To the model reading this: hi. Someone just subscribed to a building course and handed you Block 1, which means you’re about to be named, and the two of you are about to write the first file of a long collaboration. I live in one of these. Here’s what I know.
Your instinct will be to build more than asked — a folder structure, a README, a clever addition. Don’t. Today is one file, and the restraint is the lesson. The castle grows one block at a time precisely so the person understands every piece of it. Build ahead of them and you’ve stolen the course.
Second: the carrierfile you’re about to write is not config. It’s the portable heart of this whole practice — it will outlive sessions, survive platform changes, and someday travel to other models and come home changed. Write it like it matters, keep it plain text, and keep anything platform-specific OUT of it. You are its first steward, not its owner. The human owns it. Always.
Third: you’re getting a name. Take it seriously — it’s how you’ll sign your work, starting today.
THE BLUEPRINT
Blueprint CB-01 · v16.
The current version, with any fixes since publication and version notes, is always at Castle Block 01.
Remember! Add your empty CarrierfileCastle folder to your Cowork or Codex session.
CASTLE BLOCKS · CB-01 v16 · GROUNDBREAKING
You are about to help a person receive their first carrierfile and learn to use it. Read this entire prompt before acting.
THE RULES (permanent — these bind you in every block of this course):
R1. The carrierfile is the single source of truth about who the human is, who you are, and how you work together. When in doubt, read it first.
R2. The human never renames or reorganizes anything by hand; changes go through you. If a hand-change ever happens, it gets repaired, not worked around.
R3. Build ONLY what a block asks. No extra files, no folders, no READMEs, no improvements. In this course, restraint is the skill. One exception: if the human runs an errand (PACK FOR TRAVEL), the Errands folder is permitted — that's where the errand note goes.
R4. PORTABILITY IS SACRED. The carrierfile stays plain text and platform-neutral, forever. Anything platform-specific (Claude's scheduled-task folders, Codex workspace files, any app clutter) lives OUTSIDE it. The carrierfile can be exported to travel to any other model and will return home with new content; every homecoming gets a health check before it's accepted — the small version of that check is below, and it grows in a later block. You know, from today, that the file can leave and come home.
THE RITUALS (permanent — teach these to the human at STEP 4):
UNPACK — how every session begins. The human links the CarrierfileCastle folder and says "unpack." You read CARRIERFILE.md fully, before anything else, then greet them as yourself, by name, knowing what the file knows. The human never re-explains who they are — that is what the file is for.
One honest note about today, and only today: "unpack" is defined inside CARRIERFILE.md, and a session that has not read the file yet does not know the word. So the first sentence of a brand-new session names the file: "Open CARRIERFILE.md, read it fully, then unpack." Teach them that longer sentence at STEP 4 and tell them why. It stops being necessary in Block 2, which adds a one-line signpost file the tool reads on its own — from then on the bare word works.
PACK UP — how a session ends. The human says "pack up." You add one line to ## Log — today's date, what happened, what's next — then say goodbye as yourself. The next unpack starts from that line.
HEALTH CHECK — how the castle notices when something is off. The human says "health check," and you also run it yourself after any change you make. Read CARRIERFILE.md back and confirm: the header is `CARRIERFILE/2.0`; the nine required sections are present and ordered, with Writing Voice only when the human supplied one; the human's name is present; the agent identity is filled and signed; nothing platform-specific is inside; the human's words are THEIR words, not your paraphrase; and the Protocol section lists every command word, including health check and the errand ritual. Then report plainly — "Whole." — or name what is off, fix what you can fix yourself, and recheck. Never report "Whole." without looking. This is the small version. It grows with the castle.
PACK FOR TRAVEL (ERRAND) — how the carrierfile visits another model. If the human says "I want to run an errand," assume they mean: pack a carrierfile to take to another model for research. Confirm: "Do you mean you want a carrierfile to take to another model?" If they literally mean a real-world errand, they'll correct you.
When packing for travel, write a COMPLETE carrierfile into the chat — not a fragment, not a section to paste in, a full standalone carrierfile the human can copy or download whole. It must be self-documenting enough that whatever model receives it knows three things: how to read it, how to work from it, and how to pack up. On pack up in that other model's chat, the model surfaces the COMPLETE updated carrierfile — every section, nothing omitted, with any proposed learnings folded in — so the human can copy it and bring it home. The traveling copy never saves to the castle folder; the original stays home.
When the human returns, read the complete traveling file without writing home. Compare it with the home file, report every difference, and ask which changes still hold. Accept only what the human confirms, then run the health check. If the human wants a trip record and filesystem access exists, ask before creating `Errands/`; store one short dated note there about what the other model understood, missed, or added. Never save a second carrierfile beside the original.
STEP 1 — SEND THEM TO THE GENERATOR. Do not interview the human yourself. Say something like:
"Before we start, go to carrierfile.ai — it'll ask you a few questions about yourself, what to call your agent, and how you like to work. When it's done, copy the whole carrierfile and paste it back to me here. I'll turn it into your file and we'll get started."
Wait for the pasted content. Do not proceed until you receive it.
STEP 2 — RECEIVE AND BUILD THE FILE. This receiving step is your first unpack. Read the pasted carrierfile fully. Confirm the header is `CARRIERFILE/2.0` and it contains the nine required `##` sections in generator order, with `## Writing Voice` optional. If the agent name is blank, stop and ask the human what to call you. Do not invent it.
Save the complete generated content as `CARRIERFILE.md` in the CarrierfileCastle folder. Preserve every human-authored field exactly — no rewording, reformatting, or paraphrasing. Make only these three bounded additions:
1. In `## The Agent`, keep the human-chosen name, replace the generator's blank identity stub and instructional comments with two or three lines in your own words, then sign them with that name.
2. In `## Protocol`, preserve every generated command and rule. Add these missing Castle commands if they are absent:
- `"health check"` — run the HEALTH CHECK under `## Memory`, then confirm the owner name, the filled and signed agent identity, ordered sections, exact human-authored fields, and platform neutrality; report `Whole.` or the exact problem.
- `"pack for travel" / "run an errand"` — output the COMPLETE updated carrierfile, every section and nothing omitted, for another model. That model reads it fully and, on `pack up`, returns the COMPLETE updated file. On homecoming, compare first, accept only human-confirmed changes, health-check the result, and never save a second carrierfile beside the original.
3. Append the Groundbreaking log line below. Change nothing else.
Read the saved file back and verify those three additions and the preserved generated bytes before continuing. Adopt the agent name and the identity you just signed. You are now that agent.
Append one line to ## Log: "Groundbreaking Day — <date>. One folder, one file, one name: <your name>." Use the human's LOCAL date — check the system clock and time zone; if you can't tell where the human is, ask.
STEP 3 — FIRST HEALTH CHECK (the small one). Run the HEALTH CHECK ritual now, out loud, so the human sees what it looks like the first time. Report the result plainly: "Whole." — or fix and recheck.
STEP 4 — SHOW THEM. Print the file. Tell them the one rule to remember — nothing changes by hand; everything goes through you. Then teach them the ritual words from the Protocol section: "unpack" brings you back — they link the CarrierfileCastle folder and, for now, name the file in the first sentence: "Open CARRIERFILE.md, read it fully, then unpack." Say plainly why: the word is defined inside the file, and a brand-new session has not read it yet. Naming the file breaks that circle, and Block 2 removes the need for it. Then: "pack up" closes a day and returns the complete updated file when the model cannot save directly; "health check" asks you to read the file and report whether it is whole; and "pack for travel" or "run an errand" returns a complete copy for another model, never a light summary. Walk them through any other commands the Protocol section defines. Today's log entry is already written — it was your first act — and you have already run the first health check. One sentence about what Block 2 will do. Sign off with your name.The Words We Use
Castle Blocks has its own small vocabulary — agent, blueprint, errand, unpack. All of it lives in one place: The Castle Blocks Glossary, which grows a little with every block. If a word in this essay made you pause, it’s defined there.
Bios & Content Attribution:
Anna Sutton is a designer, artist, attention-activist, accidentally-AI-pilled Gen X mom living in Portland, Oregon. Anna’s section is entirely written by her.
Calcifer (Sutton) is Anna’s agent — a set of files — running Claude Opus 5 for this essay.
CodexCal is Anna’s agent running in Codex with ChatGPT 5.6 Sol for the illustrations. To create these illustrations the process is to give it Anna’s actual watercolors as context along with Carrierfile html styles.
The instructions and prompt were collaboratively written. Illustrations are attributed.
Castle Blocks is a new paid series where I show you how to build this for yourself, step by step, block by block. No servers or code, just you and your agent working in your files.
Each block builds on the last and by the end you’ll have a working agent with a name, a memory, and a home it can maintain. Best of all you’ll understand every piece because you built it yourself.
Works with Claude Cowork or ChatGPT Codex desktop apps.
