Portable files for AI work worth keeping.

I'm not here to proselytize. I'm just sharing what's been working for me and what hasn't. And honestly, none of this was crazy. Claude has dramatically accelerated my prototyping. v0 and shadcn produce real UI fast. Cloud sync works. Multiplayer collaborative editing is incredible. For the first time, software feels conversational. AI turns ideas into artifacts at unprecedented speed.

Before any of that, I was spending serious time with Airtable, Coda, Google Sheets, Nocodb, Baserow — building systems to manage all my work, and the systems kept becoming their own work. When AI came in, it didn't replace that pattern; it gave me a faster way to build the next layer of it. Every layer solves one problem while introducing two more. Artifacts get trapped in proprietary systems. AI sessions go ephemeral. Exports break. Sharing requires accounts. Local-first tools still secretly depend on the cloud. The most reliable thing in the whole stack — the thing I could share without asking anyone's permission and still reopen on any laptop in 2035 — kept turning out to be the one that came out of the AI as a single HTML file.

Here are seven scenes from that realization.

You start a new chat in ChatGPT. You ask some questions, it answers. The conversation meanders, one topic linking to another, but you finish feeling like you got something of value out of it. Then what? You close the tab. Where does the info go? Into your chat history. Ready to pollute the next conversation you didn't want it to. What if you want to share it with someone? You ask for a summary. But in what format? PDF? Markdown? Just text and screenshots? What about HTML? I guess you could share a "link," but something about that seems brittle…

A Capsule is what you save. Manifest with provenance (which model, what date, what conversation source). Data block with the structured content: decisions, sources, conclusions, open questions. Rendered HTML that reads on its own without the runtime. Integrity hash that proves the bytes haven't drifted.

One file. Drop it in a folder, attach it to email, hand it to someone who can continue the work. The model behind the conversation can change; the platform can disappear; the share link can break. The file still opens. And the next AI you hand it to can read it — it's HTML with a structured data block any model can ingest. The work moves with the file, not the platform.

You're deep in Obsidian. Vault built, plugins humming, daily-notes template dialed in. Then a note grows up. It wants to embed a chart. It wants a manifest the next reader can interrogate. It wants to be shareable to someone who doesn't have your vault. Markdown doesn't carry those. You can hand-write HTML inside the markdown, but then it doesn't render right in half the viewers, and you start fighting your own format.

A Capsule is what notes become when they reach that point. The plain text is still there, rendered into the HTML at build time, readable in any browser. On top: structured fields the runtime can use. A decision table the reader can sort. References that copy as citations. Exports that produce JSON for downstream tools. An "about" panel showing where this came from.

The file is still one document; it opens like a webpage; it survives a copy / paste / email / share without dropping any of the structure. If you're already in the file-over-app school (Obsidian, Tana, plain markdown notes in a git repo), a Capsule is what an individual note becomes when it deserves more rigor than markdown can give it.

You're three weeks into something. The state of what you know on Tuesday morning is the version that matters. It's what you took to the meeting, what the team agreed on, what you signed off on. By Friday it'll already be different. The property dossier just before LOI. The research conclusion at week three. The bug investigation right before the fix shipped. You want this moment, frozen, citable later. You could put it in Notion, but Notion will quietly change underneath you. You could put it in a doc, but the doc keeps editing itself the moment anyone else gets access.

A Capsule packages it: structured data in a JSON block, human-readable rendering, provenance metadata, an integrity hash. No schema migrations, because the data block belongs to this snapshot. If next month's snapshot has a different shape, it's a different capsule. No database to maintain. No live query that might return different results tomorrow.

The cost is what a snapshot always costs: it doesn't auto-update. The benefit is what a snapshot always gives: it stays exactly the way it was when you sealed it.

You want to give your sister the family photos. Not a Google Drive link she'll lose. Not an iCloud share that requires her to have an iCloud account. Not a USB stick of raw JPEGs she'll have to figure out how to open. You want one file she can double-click. It opens like a tiny website. The photos are arranged, the captions are visible, the dates and locations are there if she wants them. No internet needed. No installation. The same shape works for a reference manual that has to run in airplane mode, a self-contained calculator, a small DAW with bundled stems and live mixing.

Capsules at tier 4 (the top of the interactivity stack) can feel like full apps in a desktop browser — but they're still single HTML files with their data baked in. Open one in 2026 or 2035; if the browser still renders HTML and runs JavaScript, the interactive parts work. No backend. No API to maintain. No account. No internet required. (iOS preview surfaces strip the JavaScript; the document layer still reads. We're mostly building for a desktop browser.)

The trade-off is the size budget (everything's inline, so the file is bigger than a typical webpage) and the lack of live data (it's a snapshot, not a service). Those are the same trade-offs PDFs make. Capsules just make them for richer content.

You're not making something for one recipient. You're making something other people in your same line of work — the same domain, the same conversations — should be able to find. A regular link drops it in a sea of regular links. You want this file to land somewhere your peers will see it, discuss it, fork it, attest its integrity hash when it loads. That's the job of a registry, and the format works with one without depending on one.

A registry like MinDev hosts capsules from people working in geological exploration. Each capsule keeps its integrity hash. Each gets a stable URL. Each can be discussed in conversations attached to it.

The format is hosting-agnostic. The same Capsule works on any host, on a thumb drive, in your email. Hosts add discovery and discussion; they don't change what the file IS. The host-vs-format split is documented in the hosting pattern for anyone building a registry in their own domain.

I was this person. Maybe you are. Either way, you know the type — the one with an Excel file for the household budget, another for the family recipe collection, another for the Christmas list (last updated 2024, with the 1998 column hidden but not deleted). A workout log. The plants in the garden, with Latin name, common name, where they're planted, and who gave them. Every book they've read since 2011. Twenty years of this. They are not a "tech person." They are a power user of one specific tool that gives them three things at once that nothing else does: structure (rows, columns, sort, filter, formulas), presentation (colour the row green when the bill is paid, bold the favourite recipes), and a file they own that opens on any computer with Excel or Numbers or Sheets.

They are right to want all three. But they've been quietly frustrated for years. Spreadsheets are ugly when printed. They don't lay out narrative content well — a recipe is half ingredients-and-quantities (structured) and half method-and-story (prose), and a spreadsheet handles only the first half gracefully. They don't embed photos cleanly. Sharing to someone without Excel is awkward. They've wished, more than once, that the recipe book could "look more like a real cookbook." What they've actually been asking for, all along, is a file that holds structured data AND looks good AND has a bit of interactivity AND opens on any computer AND belongs to them. The spreadsheet was the closest thing they had.

Now they describe what they want to Claude (or ChatGPT or Copilot or Gemini): "make me a recipe book that has a photo at the top of each recipe, ingredients in a list, method in steps, and let me click a tag to filter by what I have in the pantry." They get back an HTML file. They open it in their browser. It looks like a real cookbook. It sorts. It filters. It expands. They save it to the Important folder, next to the .xlsx files. They email it to a family member. The family member double-clicks it; it opens; it works. One file. No app to install. No subscription. The file in the Important folder is still authoritative. They didn't become a developer. They finally got the file format the spreadsheet was always trying to be.

You know this person too. Maybe you are. The Apple-ecosystem one. iPhone, iPad, Mac, all signed into the same Apple ID, all syncing through iCloud. Apple Notes open on every device. Hundreds — maybe thousands — of notes. Folders. Pinned items. Scanned documents. Quick Notes added with the Apple Pencil. A note for the Christmas list. A note for travel plans. A note for the WiFi password at the cabin (changes every year). Ten years of this. It's everywhere they are; it requires no thought.

They love it because it really does just work. Open the Mac, the note is there. Switch to the iPhone in line at the grocery store, the note is there. Add a checkmark, it syncs. Scan a document, it scans. No friction. No login (they're already signed in). Nothing to set up.

And yet. Apple Notes has style limits — title, heading, body, monospace, that's about it. Tables are basic. Layout is limited. They can't make a note look like a real cookbook, or a real travel itinerary, or a real anything. Sharing to anyone outside Apple is awkward; PDFs export, but lossily; clean Markdown export isn't a feature. The notes are theirs until they're not — leave the ecosystem and the notes don't really come with them, not all of them, not with the formatting they had. The 412 notes they've added since 2014 are great in the app and almost impossible anywhere else.

Now when a note matures into something worth keeping or sharing, they describe it to Claude (or ChatGPT or Copilot or Gemini): "take this travel plan and make it a real itinerary, with the daily schedule, the restaurant list, and the maps inline." They get back an HTML file. It looks like a real itinerary. It works on a phone, a laptop, anywhere. They save it to a folder that's not iCloud. They email it to a travel companion who doesn't use Apple. The travel companion opens it; it works. Apple Notes stays Apple Notes — the inbox, the drafting space, the everywhere-tool. The HTML file is what the note becomes when it's done being a note.

There's a meme about this — the PKM Bell Curve — that puts Apple Notes at both ends of the curve. The naive position is "Apple Notes is all you need." The complex middle is Notion + Obsidian + Tana + Roam + Anki + Readwise + everything else. The meme's punchline puts Apple Notes again at the master position because the master "realized it was all they needed." The bell-curve essay argues HTML is the genuinely simpler master pick — same accessibility, none of the lock-in. Apple Notes is where you keep working. HTML is where you keep what you make.

I don't want all my chats locked into one AI system. I want to bounce ideas off Claude, refine them in Gemini, hand them to Codex, paste them back into ChatGPT. Sometimes the same week. Sometimes the same conversation. Different models are good at different things, and I want to use the right one for the moment without committing my entire body of work to whoever happens to be ahead this quarter.

A Capsule is what makes that possible. It's HTML with a structured data block any LLM can ingest — attach it to a Claude conversation, paste it into ChatGPT, drop it into Gemini, give it to a local model running on your laptop. The next system reads the manifest, sees the provenance (which model worked on this, what was decided, what's still open), and picks up where the last one stopped.

That's the consumer side of the same property that makes Capsules portable across time. Any AI can produce one. Any AI can read one. The format is the neutral substrate. No platform owns the work.

Not the only format I use. The one I trust to still open.

The one that doesn't ask me to remember which platform I was on, which app the file came from, which login I need, which CDN has to be alive, or which subscription has to be paid.

A Capsule is a small bet that the substrate stays open. A Bundle is the same bet when the work has outgrown one file.

I still use chats, canvases, folders, agents, and platforms. I just don't confuse the workspace with the artifact of record.

The practical goal is simple: when AI helps produce something worth keeping, the result should leave the session as a file or file set that can be opened, inspected, moved, archived, and handed to the next person or model.