Here is a question nobody building an AI second brain asks until it is too late: what happens when the tool you built it inside changes?

Most people pour months into a setup that lives inside one CLI. Every command, every workflow, every habit is wired to Claude Code, or to whatever they started with. It feels great. Until that tool raises its price, changes a policy, ships a breaking update, or you simply want to try another one. Then you find out your second brain was never really yours. It was renting space inside someone else’s product.

I did not want that. So my second brain runs on four CLIs, from one codebase. Here is the idea and the build.

The brain is the files. The CLI is just the hands.

The whole thing rests on one separation most people never make.

Your knowledge is a folder of plain markdown. That is the brain. It does not care what reads it. I made the full case for keeping an AI’s memory in plain folders in its own post. The CLI, Claude Code or anything else, is just the pair of hands that reads, writes, and reasons over those files. Hands are replaceable. The brain should not be.

Once you see it that way, locking your brain to one set of hands looks like a mistake. So I stopped doing it.

One codebase, four builds

The commands are written once. A build step turns that one codebase into a package for each CLI.

I run a build script and it produces a version for Claude Code, Codex, Gemini, and OpenCode. Each build gets its own dispatcher file (the CLIs expect different names) and an auto-generated routing table that maps plain-English triggers to the right command. The vault behaves identically across all four. The only differences are the install path and the wiring underneath.

It is 45 commands in total. Four of them are Claude-Code-only (they touch Google Calendar), so the other three CLIs ship 40. Beyond that, same brain, same behavior, four front doors.

Subscribe now

You are not locked to a model either

This is the part that goes deeper than CLIs.

Because the builds are plain instruction files, not code tied to one provider, they run on whatever model the host CLI points at. The OpenCode build will happily run on an open model like Nous Hermes through OpenRouter. Point it at a small model running locally through Ollama, and nothing leaves your machine. Same commands, same vault, your choice of brain behind the hands.

So the lock-in disappears on both axes. Not chained to one company’s CLI, and not chained to one company’s model.

Why this matters more than the model race

Everyone is arguing about which model is smartest this month. That argument resets every few weeks. The thing that actually protects you is whether your setup survives the churn.

CLIs and models in 2026 change fast. Prices move, terms change, favorites get deprecated, new ones appear. If your knowledge system is welded to one of them, every one of those changes is your problem. If your knowledge system is plain files plus commands that build for anything, the churn is just Tuesday. You switch the hands and keep the brain.

That portability is the real moat. Not the model. The model is rented. The files are yours.

Where it breaks

I am not going to pretend this is free.

Maintaining four builds is real overhead. Every time I add a command I make sure it builds cleanly for all four, and a few features genuinely cannot be portable (the calendar commands lean on Claude Code specifics). If you only ever use one CLI and never plan to switch, you do not need this. Single-CLI is simpler, and simpler is correct until portability actually buys you something.

The honest rule: build for one CLI until the day a price change or a policy or a shiny new tool makes you wish you could move. The people who set it up to be portable before that day are the ones who move in an afternoon instead of a month.

If you want to do this

Start with the separation, even if you never build for four CLIs. Keep your knowledge as plain markdown in git, and keep your commands as plain instruction files, not code bolted to one provider. That alone makes you portable.

The full setup is open source. The obsidian-second-brain skill ships the build script and all four targets: one codebase, four CLIs, 45 commands, MIT licensed. Clone it, run the build for your CLI, or read it to copy the pattern.

I am not theorizing. This is the system I built for myself and then watched 2,700 developers clone. It runs on four CLIs today because I refuse to let one company own my second brain.

Frequently asked questions

Can one AI second brain run on Claude Code, Codex, and Gemini at once?
Yes. You write the commands once and a build step produces a package for each CLI, with its own dispatcher file and a routing table. The vault behaves the same on all of them. Mine runs on Claude Code, Codex CLI, Gemini CLI, and OpenCode.

Why not just pick one CLI and stick with it?
You can, and if you never plan to switch, that is simpler. The reason to go portable is that CLIs and models change fast in 2026. If your setup is welded to one, every price or policy change is your problem. Portable means you switch tools in an afternoon, not a month.

Is it locked to one AI provider’s model?
No. Because the builds are plain instruction files, they run on whatever model the host CLI uses, including open models like Nous Hermes via OpenRouter or a local model through Ollama, so nothing has to leave your machine.

Do all the commands work on every CLI?
Almost. It is 45 commands total; four that touch Google Calendar are Claude-Code-only, so the other CLIs ship 40. Everything else is identical across the four.

What is the actual brain made of?
Plain markdown files in git. No database, no app. That is the whole point: the files are the brain and they do not care which CLI reads them, so they survive any tool change.

Key takeaways

• Your AI knowledge lives in plain files. The CLI is just the hands that read and write them, and hands should be swappable.

• One codebase builds for four CLIs (Claude Code, Codex, Gemini, OpenCode) with the same 45 commands and identical vault behavior.

• Because the builds are plain instruction files, you are not locked to one model either, including open and local models for privacy.

• The real protection in a fast-churning 2026 is portability, not picking the smartest model this month.

• Single-CLI is simpler and correct until a price or policy change makes you wish you could move. Set up portability before that day.

• The files are yours. The model and the CLI are rented.

Further reading

• I built this for myself. Then 1,374 strangers cloned it. (the open-source second brain this builds on).

• How to build a folder-native AI agent. (why the brain is plain folders of markdown).

• Karpathy’s LLM Wiki v2: what to keep, what to skip. (the pattern the vault runs).

• OpenCode and the open-model route (Nous Hermes via OpenRouter, local models via Ollama). Search “OpenCode opencode.ai” and “Ollama”.

• The obsidian-second-brain skill on GitHub: github.com/eugeniughelbur/obsidian-second-brain

About the author

Eugeniu Ghelbur is an AI Automation Engineer at Single Grain, where he builds production AI systems for marketing and sales workflows. He ships open-source Claude Code skills and writes about AI knowledge management at theaioperator.io. The obsidian-second-brain skill described here is live on GitHub at github.com/eugeniughelbur/obsidian-second-brain, where it has been starred by over 2,700 developers.

Last week a thread tore through builder Twitter. One screenshot: a free, open model running 300 agents in parallel across 4,000 steps from a single prompt, scoring higher on real research than models you pay five times more for. The replies were a mix of “this changes everything” and “this is nonsense.”

I wanted to know which.

So I did the obvious thing. I pointed an agent swarm at the claim about agent swarms. A 112-agent research run, fanning out across primary sources, then a second pass where independent agents tried to refute every claim before it survived. 24 of 25 claims passed. One got killed.

Here is what came back. The pattern is real and it is worth your time. Most of the specific numbers people are quoting are not. And the gap between those two things is where most builders are about to waste a month.

What a loop actually is

For three years the question was which model is smartest. You picked one, typed into a box, got an answer, closed the tab.

A loop kills that question. The unit stopped being the model. It became the system around it.

A prompt is a wish. You re-type it every time, and it forgets everything the moment the tab closes. Run number fifty is identical to run number one.

A loop is different. A goal goes in, work comes out, and the system keeps what it learned. The next run starts ahead of the last one, because the run before it left something behind. A reusable skill. A tighter spec. A rule that stops a past mistake from coming back. The single best line from that viral thread holds the whole idea: the system that ran your task yesterday should be smarter than the one running it today.

The model stays frozen. The system compounds. That is the whole game.

The pattern is older than the hype

None of this is new, which is exactly why it works.

The base loop was published in 2022 in a paper called ReAct: reason, act on a tool, observe the result, repeat. It cut hallucination from 56 percent to near zero on a standard benchmark, simply by grounding each step in a real lookup instead of the model’s guess. Every agent today is its descendant.

A 2023 project called Voyager added the part everyone is now selling. An agent that wrote its skills as reusable code, stored them in a library, and composed them into harder skills over time. Lifelong learning without retraining the model. Sound familiar? “Save the workflow as a skill” is Voyager in a suit.

Then in 2025 a team at Every gave it a name: compound engineering. Building systems where each run makes the next one faster, safer, and better. This is the same insight I built my own setup on, and the same one behind rebuilding Karpathy’s LLM Wiki: a model does not get bored maintaining its own knowledge, so the knowledge compounds instead of rotting.

If a term in here is new to you, I wrote a plain-language guide to the core AI concepts that pairs well with this post.

Why split it into a swarm

Why fan a task out to many agents instead of asking one model to do it all? Because one agent on a long task fills its context window until it starts to drift. Researchers call it context rot. Past a point, every step gets a little worse, because the model is reasoning over a window stuffed with its own earlier output.

A swarm fixes this. A coordinator splits the job, each agent works on one piece in its own clean context, and only a short summary flows back to be assembled. Nobody drowns in a giant context, so the system holds up on work that would break a single agent. That is the real reason the parallel setup wins, and it has nothing to do with the agent count on the marketing page.

Subscribe now

The one move that separates a loop from a toy

Here is the part most threads skip, and it is the most important one.

A swarm of cheap agents will produce confident, under-cited work. Run enough of them and some will quietly contradict each other. “Looks done” and “is correct” are different planets. The first wave of autonomous agents in 2023, the AutoGPT era, failed for exactly this reason: nothing was checking the work.

The fix is a verify gate. You point a second, trusted model at the output and tell it one thing: refute, do not praise. List what is wrong.

Why this works comes down to a single asymmetry. Checking an answer is easier than producing it. So you generate cheap at high volume, and you spend your expensive, careful tokens only on the gate that catches the silent flaw. A loop without that gate is just AutoGPT again, now at scale and on your invoice.

This is the real shape of the hybrid stack everyone is excited about. A cheap open model does the work. A premium model sits at one gate and keeps it honest.

What’s real, and what’s vendor marketing

This is where the swarm I ran earned its keep. Three findings matter.

The viral “300 agents, 4,000 steps” is a capability ceiling, not a benchmark. It is a line in the open model’s own product page. The vendor’s actual public demos topped out around 100 agents on one task and about 30 on another. The “4,000” came from a separate, unrelated run. It describes what the system can be told to attempt, not the quality of what comes out at that size.

The famous “this model is four times less likely to pass its own code flaws” line is real, but softer than it sounds. It does not appear in the technical safety report at all. I checked the full document. It lives in a launch announcement, it is self-reported with no published method, and it measures honesty, that the model flags its own uncertainty, not that the code it writes is four times better.

The head-to-head benchmark numbers people are reposting, where the open model beats the big paid ones on specific tests, did not hold up. That is the one claim my refute pass killed. They could not be substantiated across sources. The open-versus-closed gap is genuinely unsettled, not won.

None of this means the tools are bad. The open model is genuinely open-weight and genuinely cheap, which is the part that actually matters. Cheap tokens are what make “run it twice and throw the first attempt away” a sane thing to do. That is the same shift that hit the field when DeepSeek landed. The economics are the story, not the leaderboard screenshots.

Why it compounds, and why that is the real moat

The reason to build a loop instead of a better prompt is defensibility.

Anyone can rent the same model you use. Nobody can copy three things: your skill library, the documents you fed in to make the output sound like you, and your constraints file, the running list of every mistake the verify gate caught and turned into a permanent rule. Those were built from months of your real runs.

That is why the first run takes twenty minutes and the fiftieth takes thirty seconds, sharper each time. The model did not get smarter. Your system did. I have watched three model generations come and go while the same files kept running, and each one got better at the job, not because of the model, but because the scaffolding around it kept absorbing what I learned.

“Self-improving” does not mean the weights retrain on your runs. They do not. The system around the model improves. Anyone telling you otherwise is selling something.

When not to build one

I am not going to pretend swarms are for everything, because they are not, and the honest version of this is what separates builders from resharers.

The strongest counter-argument is simple: the same loop that compounds wins also compounds errors. With no human-anchored ground truth, a flawed spec drifts and the system gets confidently wrong faster. The mitigations are the verify gate, the constraints file as a ratchet, and a human who stays on the question and the final decision.

Cost is the other catch. The lab that builds these said it plainly: running parallel agents this way burns roughly fifteen times the tokens of a normal chat, so it only pays off on high-value work. And it is a poor fit for tasks that need one coherent thread of reasoning, like writing a single long argument, or anything where the parts depend tightly on each other. Swarms shine on work you can split, run in parallel, and check: research, monitoring, broad data gathering. Not everything.

Build one this week

You do not need the 300-agent setup to get the benefit. Here is the smallest version that is a real loop and not a toy.

Start with a spec, not a prompt. Pick one task you actually repeat, like a weekly competitive brief. Write down what to collect, which sources count, the exact output format, and what to do when sources conflict. Treat the system like a contractor, not a genie.

Fan the independent parts out to separate agents, each working in its own clean context and handing back a short summary. Then add the gate: a second pass that tries to tear the output apart before you trust it. Capture the whole thing as a reusable skill so next week starts from it. Every flaw the gate catches becomes one line in a constraints file the system reads first, every time. Once it is stable, put it on a schedule and let it surface only the result and anything that looks off.

That is the loop. The only human left in it is the question you set and the decision you make on the answer.

I am not theorizing here. I maintain an open-source second brain that has been cloned and starred by over 2,500 developers. It is a loop: it reads its own notes, does the work in steps I can check, and writes back what it learned so the next run starts smarter. Plain files, in git, no framework. The model underneath has changed three times. The loop kept running.

Build it once. Verify it. Distill it. Then watch it get cheaper and sharper every single time you run it.

Subscribe now

Frequently asked questions

What is an AI agent loop?
It is a system where a model does a task, checks the result, and saves what it learned so the next run starts from a better place. Unlike a one-off prompt, a loop accumulates skills and rules over time, so it improves with use even though the model itself never changes.

What is an AI agent swarm?
It is many agents running in parallel on pieces of one task. A coordinator splits the job, each agent works in its own context and returns a short summary, and the coordinator assembles the result. It beats a single agent on tasks you can break apart, because each piece gets a clean, focused context.

Can an open model really run 300 agents at once?
That number is the vendor’s stated maximum, not a measured benchmark. Real public demos ran closer to 30 to 100 agents. The capability to orchestrate many agents is real. The “300 and 4,000 steps” figure is a marketing ceiling, so treat it as such.

Is “self-improving AI” actually the model learning?
No. The model’s weights stay frozen. What improves is the system around it: a growing library of saved skills, fed documents, and a constraints file of past mistakes. The loop gets smarter. The model does not. Anyone implying live retraining from your runs is overselling.

Why do I need a verify gate?
Because a swarm produces confident, under-checked output, and some of it is quietly wrong. A second model told to refute the work catches flaws before they get saved as a permanent skill. Checking is cheaper than generating, which is why this step pays for itself.

When should I not use an agent swarm?
Skip it for tasks that need one coherent line of reasoning, for tightly interdependent work, and for low-value jobs where the extra cost is not worth it. Parallel swarms can use around fifteen times the tokens of a normal chat, so they fit high-value, splittable, checkable work.

Key takeaways

• An AI loop beats a prompt because it compounds: every run leaves behind a skill, a document, or a rule that makes the next run faster and sharper, while the model stays frozen.

• The pattern is not new. ReAct (2022) gave us the base loop, Voyager (2023) gave us reusable skills, and “compound engineering” (2025) gave it a name.

• A swarm beats one long agent because each piece runs in its own clean context, avoiding the context rot that degrades a single agent on a long task.

• The verify gate is the one non-optional move. A cheap model generates at volume, a trusted model refutes the output, because checking is easier than generating.

• The viral numbers are vendor marketing. “300 agents, 4,000 steps” is a capability ceiling, not a benchmark, and the head-to-head leaderboard claims did not survive fact-checking.

• The real advantage of open models is cost, not benchmarks. Cheap tokens make “run it twice, throw the first away” rational, the same shift DeepSeek triggered.

• Swarms are for splittable, checkable, high-value work. They burn roughly fifteen times the tokens of a chat and are a poor fit for single coherent arguments or tightly coupled tasks.

Further reading

• Anthropic, Building Effective Agents (the canonical taxonomy of workflows versus agents, and the orchestrator-worker and evaluator-optimizer patterns). Search “Anthropic Building Effective Agents”.

• Yao et al., ReAct: Synergizing Reasoning and Acting in Language Models (ICLR 2023, the origin of the agent loop). On arXiv.

• Every, the compound engineering essays by Kieran Klaassen (where the self-improving-system thesis got its name).

• Cognition AI, Don’t Build Multi-Agents (the strongest skeptic case, on when parallel agents hurt you).

• I built this for myself. Then 1,374 strangers cloned it.

• The obsidian-second-brain skill on GitHub: github.com/eugeniughelbur/obsidian-second-brain

About the author

Eugeniu Ghelbur is an AI Automation Engineer at Single Grain, where he builds production AI systems for marketing and sales workflows. He ships open-source Claude Code skills and writes about AI knowledge management at theaioperator.io. The obsidian-second-brain skill described here is live on GitHub at github.com/eugeniughelbur/obsidian-second-brain, where it has been starred by over 3,000 developers.

TL;DR
A folder-native AI agent keeps its memory and its work in the same place: folders of plain markdown, in git, with no database and no framework. Google’s Open Knowledge Format (OKF) standardizes the memory half. The University of Edinburgh’s Interpretable Context Methodology (ICM) standardizes the workflow half. Wire them together and you get one agent that reads its own memory, does the work in steps you can check, and writes what it learned back, so it starts smarter every run. This post gives you the exact folder layout, what goes in each file, the loop that makes it compound, and where it breaks.

Two research groups shipped the same idea three months apart, and nobody put the two halves together.

In March 2026, two researchers at the University of Edinburgh published a paper arguing you do not need a multi-agent framework to run an AI workflow. You need numbered folders, each holding a markdown file that tells the agent what to do at that step. The folder structure is the program. Jake Van Clief, who co-authored the ICM paper, has been one of the most consistent public voices explaining how it works.

In June 2026, Google shipped the Open Knowledge Format. Its claim: you do not need a vector database to give an agent its knowledge. You need a folder of markdown files with a little metadata on top, readable by any agent or any human.

One group described how an agent does work. The other described how an agent remembers. Both landed on the same answer: plain markdown, in folders, in git. I wired the two halves into one agent. Here is exactly how it works, and how to build your own.

Subscribe now

What “folder-native” actually means

A folder-native AI agent is an agent whose memory and workflow are both ordinary files on disk, not records in a database or steps inside a framework.

That is the whole definition. No special runtime. If you can open a file, you can read its memory. If you can clone a repo, you can ship the whole agent. Three pieces make it work, and you already understand all three:

• Markdown is the format. Human-readable text with light structure.

• Folders are the organization. Nesting and naming carry meaning the agent can follow.

• Git is the spine. Version history, diffs, and rollback come for free.

Everything below is built from those three pieces and nothing else.

The filesystem keeps winning

This is not new, which is exactly why I trust it.

In 1978, Doug McIlroy wrote the rule that made Unix powerful: make each program do one thing well, and let plain text pass between them as the universal interface. Fifty years later, every clever layer we bolted on top has aged worse than the plain-text idea underneath. (the Unix philosophy, McIlroy, Bell Labs)

AI is repeating the pattern. We spent two years building scaffolding around language models: vector stores, orchestration frameworks, memory layers with their own SDKs. The quiet result of the last few months is that a folder of markdown beats most of it for the work people actually do.

I wrote about Karpathy’s LLM Wiki when it first went around. The insight: humans abandon wikis because keeping them current is tedious, but a model does not get bored. It will update a cross-reference for the thousandth time without complaint. OKF and ICM are what that insight looks like once it grows into a standard.

Two halves nobody put together

Here is the part worth your attention.

OKF is memory. It is where knowledge lives: facts, context, decisions, people, written as markdown and updated over time. The brain the agent reads from.

ICM is work. It is how a job gets done in stages: research, then draft, then produce, with a human checking the output between steps. The hands.

Every write-up I have seen treats these as separate. They are not. They share the same material, folders of markdown, which means the workflow can read straight from memory and write straight back into it. No glue code. No translation layer. The brain and the hands speak the same language because they are made of the same thing.

What the agent actually looks like

Here is the literal anatomy. One repo, two top-level folders, all markdown.

my-agent/
  memory/                  <- OKF: what the agent knows
    people/
      john-smith.md
    projects/
      weekly-report.md
    decisions/
      pricing-2026.md
    MEMORY.md              <- index: one line per note
  workflow/                <- ICM: how the agent does a job
    01-research/
      CONTEXT.md           <- instructions for this step
      output.md            <- what the step produced
    02-draft/
      CONTEXT.md
      output.md
    03-produce/
      CONTEXT.md
      output.md
  README.md                <- how to run it

Read that tree once, and you understand the entire system. memory/ is the brain. workflow/ is the job, broken into numbered steps a human can read in order. There is no hidden state anywhere. The folder structure is the program.

Inside a single stage

Each numbered folder holds two files. A CONTEXT.md that tells the agent what to do (this is the contract file the ICM paper is built around), and an output.md where it writes the result. Here is what a CONTEXT.md looks like:

# Stage 02 - Draft

## Read first
- memory/projects/weekly-report.md
- ../01-research/output.md

## Do
Write a 1-page client report. Use last week's numbersfrom the research step. 
Match the client's tone from their note in memory.

## Write to
output.md

## Stop
Wait for the human to approve before stage 03 runs.

That is the entire instruction set for one step. Plain English, two file paths to read, one file to write, and an explicit stop. The agent opens CONTEXT.md, pulls exactly the memory it names, does the work, and writes output.md. Then it stops and waits for you.

This is the part frameworks make hard and folders make trivial: every step is a file you can open, read, and correct before the next one runs.

The loop that makes it compound

A pipeline of stages is useful. The loop is what makes it an agent that gets better.

After the work ships, the agent does one more thing: it takes the new facts it learned this run and writes them back into memory/. Next run, it starts from a smarter place, because the work it did became part of what it knows.

The full cycle, all in files:

1. Read the relevant notes from memory/.

2. Do the stage, writing output.md.

3. You check the output and fix it in the file if the angle is off.

4. Write back the new facts into memory/.

5. Next run starts from the updated memory.

That is a complete agent. Memory it reads, work it runs, and a loop where the work makes the memory better. All of it plain files you can read on a Tuesday afternoon with nothing open but a text editor.

Subscribe now

A worked example: the weekly client report

Concrete beats abstract. Say you want an agent to write your weekly client report.

Stage 01 reads the client’s note from memory/people/, pulls this week’s numbers, and writes a research summary to output.md. You glance at it. If a number is wrong, you fix it in the file.

Stage 02 reads the client’s project note and the research output, then drafts the report into its own output.md. You read the draft. If the angle is off, you correct it right there before anything else runs.

Stage 03 polishes the draft into the final report.

Then the loop closes: the agent writes the new facts it learned this week (a changed priority, a new contact, a decision the client made) back into memory/people/ and memory/decisions/. Next Monday, the agent starts from a smarter place. You did not retrain anything. You did not migrate a database. You edited text files.

Why this beats the stack you were about to build

Three reasons, and none are about benchmarks.

You can see everything. No hidden state, no opaque vector index, no “trust me” black box. Every intermediate step is a file. When the output is wrong, you open the folder and find where it went wrong. The system is inspectable by default, not because someone bolted on a logging dashboard.

You can change anything. A non-technical person can edit a markdown file. The person who owns the work can correct the agent without calling a developer. The control surface is a text editor.

It outlives the model. Your knowledge and workflows are not trapped inside a product. They are files in a folder in git. When the next model drops, you point it at the same folder. Nothing to migrate, nothing to rebuild. I have watched three model generations come and go while my own setup kept running on the same files.

How to build your own this week

You do not need either standard to start. You need a folder. Here is the smallest version that works:

1. Make two folders: memory/ and workflow/. Put them in a git repo.

2. Seed memory. Drop in a handful of markdown notes about the things your agent needs to know. One fact per file. Add a MEMORY.md Index with one line per note.

3. Write one stage. Create workflow/01-do-the-thing/CONTEXT.md with three sections: what to read, what to do, what to write. Point an agent (Claude Code, or any tool that can read and write files) at it.

4. Run it and read the output. Fix the output file by hand if it is off. This is the human-in-the-loop, and it is the point, not a workaround.

5. Close the loop. Add a final instruction: write any new facts back into memory/. Run it again next week and watch it start smarter.

6. Add stages only when a single one gets crowded. Split 01 into 01-research and 02-draft When the instructions stop fitting on one screen.

Add the heavy machinery (a database, a framework) only when a folder genuinely cannot do the job. That moment is later and rarer than you think.

Where this breaks

I am not going to tell you that folders solve everything, because they do not.

The Edinburgh paper is honest about this, and so am I. This pattern fits sequential work that a human reviews. It is not built for real-time, many-agents-talking-at-once systems, or high-concurrency services where you need queues and proper infrastructure. For that, the frameworks earn their complexity.

Both standards are also early. OKF is a version 0.1 from a single company. ICM is a young methodology with a small community. This is the start of something, not a settled stack. I am betting on the direction, not claiming the destination.

But for the large, boring middle, the reports and the research and the content and the knowledge work most of us spend our days on, the folder wins. It is simpler than the problem we built frameworks to solve.

I am not theorizing

I maintain an open-source second brain that has been cloned and starred by over 3,000 developers. It is folders of markdown, maintained by AI, on the exact pattern OKF describes. The code is public: github.com/eugeniughelbur/obsidian-second-brain.

This week I made it speak the standard directly. It now exports a valid OKF bundle, so the vault any of those developers run is portable to anything that reads the format. I also run a capture pipeline that takes a voice note or a photo from my phone and files it into the right note, plus a step that means the agent never leaves a dead link: when it references a person or project that has no note yet, it creates that note and fills it.

None of that is a demo. It is what I use every day. The point is not the specific tool. The point is that the architecture works, you can see it working, and you can build it yourself, because it is just files.

Start with a folder

If you take one thing from this: stop reaching for a database or a framework as the first move. Start with a folder of markdown. Let the agent read it, work in it, and keep it current.

The filesystem won the first time, in 1978. It is winning again, for the same reason: plain text outlasts the scaffolding built on top of it. The only question is whether you start now or after everyone else has.

Subscribe now

Frequently asked questions

What is a folder-native AI agent?
A folder-native AI agent is an AI agent whose memory and workflow are both stored as plain markdown files in folders, versioned in git, with no database and no orchestration framework. The agent reads its memory from files, does work in numbered stage folders, and writes new facts back to memory.

What is the Open Knowledge Format (OKF)?
OKF is a standard from Google Cloud, released in June 2026, for packaging knowledge as a folder of markdown files with simple metadata, so AI agents can read and maintain it without a database or scraping. It defines the memory layer of a folder-native agent.

What is Interpretable Context Methodology (ICM)?
ICM is a method from a 2026 University of Edinburgh paper for running multi-step AI workflows using numbered folders and markdown instead of a coding framework. One agent reads the right file at each stage, and a human reviews the output between stages. It defines the workflow layer.

How are OKF and ICM related?
They are the same idea applied to two halves of one agent. OKF is the memory (what the agent knows). ICM is the workflow (how the agent does work). Because both are folders of markdown, you can wire them together so a workflow reads from memory and writes back to it.

Do I need a vector database for AI memory?
For a lot of everyday knowledge work, no. A folder of markdown the model reads directly avoids the “lost in the middle” problem of stuffing everything into one prompt (Liu et al., 2023), and it is far simpler to inspect and edit. Databases earn their place at scale, not by default.

Is folder-native AI ready for production?
For sequential, human-reviewed workflows, yes, people run it today. For real-time, high-concurrency, or many-agent systems, no, you still want proper infrastructure. Both OKF and ICM are early, so treat this as a direction to build toward, not a finished standard.

Can I use this with my existing Obsidian vault?
Yes. An Obsidian vault is already folders of markdown, which is most of the way to OKF. That is why the pattern is spreading fast among people who already keep notes this way.

Key takeaways

• A folder-native AI agent keeps memory and work as plain markdown in folders, in git, with no database and no framework.

• Two 2026 standards landed on the same answer independently: Google’s OKF for the memory layer, the Edinburgh ICM paper for the workflow layer.

• Wire them together and a workflow reads from memory and writes back to it, so each run makes the agent’s memory smarter.

• The build is simple: two folders (memory/ and workflow/), one markdown note per fact, one CONTEXT.md per step, a human check between steps, and a loop that writes new facts back.

• The real advantages are inspectability, editability by non-developers, and surviving the next model with zero migration. Not speed.

• Folders are not for everything. Real-time and high-concurrency systems still need real infrastructure. This fits the large, sequential, human-reviewed middle.

Further reading

• Google Cloud, How the Open Knowledge Format can improve data sharing (the OKF v0.1 announcement, June 2026).

• Van Clief & McDermott, Interpretable Context Methodology: Folder Structure as Agentic Architecture (University of Edinburgh, arXiv:2603.16021, March 2026).

• The ICM reference implementation on GitHub: github.com/RinDig/Interpreted-Context-Methdology.

• Jake Van Clief on ICM (co-authored the paper and posts regularly about the methodology publicly).

• Andrej Karpathy’s LLM Wiki gist (the origin of the “agents do not get bored maintaining a wiki” insight).

• Liu et al., Lost in the Middle: How Language Models Use Long Contexts (why folders the model reads directly beat one giant prompt).

• I rebuilt Karpathy’s LLM Wiki. Here’s what’s missing from the original.

• I built this for myself. Then 1,374 strangers cloned it.

• The obsidian-second-brain skill on GitHub: github.com/eugeniughelbur/obsidian-second-brain

About the author

Eugeniu Ghelbur is an AI Automation Engineer at Single Grain, where he builds production AI systems for marketing and sales workflows. He ships open-source Claude Code skills and writes about AI knowledge management at theaioperator.io. The obsidian-second-brain skill described here is live on GitHub at github.com/eugeniughelbur/obsidian-second-brain, where over 3,000 developers have starred it.

The internet has spent two months designing a “v2” of Andrej Karpathy’s LLM Wiki: confidence scores, supersession chains, forgetting curves, vector search, lifecycle hooks.
I rebuilt the original and have run it every day for months across a repo that 2,317 people have now starred.
Here is the honest report on which v2 ideas earn their place, and which are overkill you will rip out in a week.

Andrej Karpathy posted a gist last year describing how he keeps an LLM-maintained wiki: raw sources go in untouched, the AI owns a folder of markdown notes, and a rules file tells it how to ingest, update, and query. I rebuilt that pattern as a working system and wrote about what the original left out.

Since then a small genre has appeared. People are publishing “LLM Wiki v2” gists. The most-shared one (by a developer who goes by rohitg00) adds confidence scoring, supersession chains, forgetting curves, hybrid vector search, and event hooks. Other versions pile on audit trails, tiered memory, and quality scores.

It reads like a real upgrade. Most of it is not.

I am not theorizing. I have run my rebuilt wiki every day for months, and I open-sourced the whole thing as obsidian-second-brain. So here is the difference between the v2 ideas that survive contact with daily use and the ones that look smart in a gist and die in practice.

First, the part everyone gets right

If you landed here cold, the pattern is three layers, and it genuinely works.

One: raw sources, immutable. Whatever you feed it (an article, a transcript, a meeting) lands in a folder and never gets edited. That is your ground truth.

Two: the wiki. A folder of markdown notes the AI owns and rewrites. New information does not get appended to the bottom. It gets folded into the existing note, and contradictions get reconciled.

Three: the rules file. One markdown file that tells the AI how to ingest a source, how to update a page, how to record what it did. An index.md for navigation and an append-only log.md for history.

The reason it beats dumping everything into a giant context window: a curated wiki of 50,000 to 100,000 tokens answers most questions without loading your entire corpus. You spend tokens on the answer, not on the haystack. That part is real and v2 does not change it.

What “v2” actually means right now

There is no official v2. Karpathy’s gist is still the only canonical spec. “v2” is a community label for a pile of proposed additions, and they cluster into two buckets.

Governance features: confidence scores on claims, supersession chains so an old fact points to the new one that replaced it, and “forgetting curves” so stale notes decay instead of rotting in place.

Retrieval and infrastructure: hybrid search (keyword plus vector embeddings), lifecycle and event hooks, quality scoring, tiered memory.

The first bucket is about whether the wiki tells you the truth. The second is about machinery. After months of running this, the split between them is exactly the split between what works and what is overkill.

Subscribe now

The v2 ideas I shipped and kept

The governance bucket earns its place. Every one of these is in the system I run.

Confidence markers. Every claim my wiki writes carries a tag: stated, high, or low. It costs almost nothing (one word per fact) and it changes how you read. When the AI synthesizes across notes, a stated claim gets treated as a quote, not a truth. This is the single highest-value v2 idea and it requires zero infrastructure.

Supersession, done as reconciliation. When a new source contradicts an existing note, the wiki does not keep both and shrug. A command reconciles them: the note gets rewritten to the current truth, and the change is logged. You do not need a formal “supersession chain” data structure. You need the AI to actually resolve the conflict instead of hoarding it.

A forgetting curve, but boring. The fancy version tracks decay scores and timestamps. Mine is simpler: lessons get reviewed, and the ones that stopped being true get pruned. Notes that just accumulate become a graveyard. The point of a forgetting curve is not the math. It is that something deletes.

Lifecycle hooks, as scheduled agents. This one is real and I run it. Background agents wake up on a schedule and maintain the wiki while I am not looking: reconcile contradictions, synthesize patterns, flag stale claims. You do not need an event-bus abstraction. You need cron and a rules file.

The v2 idea I skipped, and why

Hybrid vector search is the headline feature of almost every v2 gist. I tried it. I took it out.

Here is the thing nobody writing these gists seems to have measured: at wiki scale, you do not have a retrieval problem. A curated wiki is 50,000 to 100,000 tokens. That is small. Grep plus read finds the right note faster and more predictably than an embedding lookup, with no vector database to host, no index to keep fresh, and no “why did it return that chunk” debugging.

Vector search earns its keep at hundreds of thousands of documents. A personal or team wiki is not that. Bolting embeddings onto a 200-note vault is solving a problem you do not have, and paying for a database to do it.

The same goes for tiered memory and elaborate quality-scoring engines. They are answers to scale problems. At the scale where an LLM wiki is actually useful, they are weight.

What is genuinely still missing

Honesty cuts both ways, so here is the gap the v2 gists also miss.

None of them have a real guard against the AI lying about what is in the wiki. I learned this the hard way: when I read through the forks of my repo, a stranger had added the exact thing I lacked. The most common failure is not the AI making up a fact. It is the AI saying “there is no note about that” when there is, because it answered from memory instead of actually searching.

That is the real frontier of v2. Not fancier retrieval. A rule that forces the model to verify presence and absence by listing and grepping, never from memory, before it tells you something does not exist. I am merging that guard in now. No v2 gist I have seen includes it.

The actual lesson

The v2 discourse has the direction backwards. It treats the upgrade as machinery you add: a vector store, a scoring engine, a memory hierarchy.

The version that works is the opposite. It is the smallest set of rules that makes the AI maintain its own truth. Confidence on every claim. Contradictions resolved, not hoarded. Stale notes deleted. An agent that does the maintenance on a schedule. All of that lives in the rules file, and none of it needs a database.

Karpathy’s original insight was that the wiki should be plain markdown the AI owns. The real v2 honors that. It does not drown it in infrastructure.

The full system is open source at obsidian-second-brain. I built it for myself first, and the rules file is the part worth reading. That is where the v2 actually lives.

Frequently asked questions

What is Karpathy’s LLM Wiki?
A pattern Andrej Karpathy shared for letting an AI maintain a small markdown knowledge base. Three layers: raw sources kept immutable, a wiki of notes the AI owns and rewrites, and a rules file that tells it how to ingest, update, and query.

What is “LLM Wiki v2”?
A community label, not an official release. Karpathy’s gist is still the only canonical spec. “v2” refers to additions people propose in their own gists: confidence scores, supersession chains, forgetting curves, hybrid vector search, and lifecycle hooks.

Do you need vector search for an LLM wiki?
No, not at wiki scale. A curated wiki is 50,000 to 100,000 tokens, and grep plus read finds the right note faster and more predictably than embeddings, with no database to host. Vector search earns its place at hundreds of thousands of documents.

Which v2 ideas are actually worth adding?
The governance ones: confidence tags on claims, reconciling contradictions instead of hoarding them, pruning stale notes, and a scheduled agent that maintains the wiki. Each is a few lines in the rules file, not new infrastructure.

How large can an LLM wiki get before it breaks?
It is built for small, curated corpora, roughly 50,000 to 100,000 tokens. Past that, the scale features the v2 gists propose start to matter. At the size where an LLM wiki is most useful, they are weight.

Where can I get a working implementation?
The full system is open source as obsidian-second-brain, a Claude Code skill on GitHub.

Key takeaways

• Karpathy’s three-layer pattern (immutable sources, an AI-owned wiki, a rules file) is solid, and v2 does not change it.

• “LLM Wiki v2” is a community label, not an official release. Karpathy’s gist is still the only canonical spec.

• The v2 ideas worth keeping are all governance: confidence tags, reconciliation, pruning, and scheduled agents. Each costs a few lines in the rules file.

• Hybrid vector search is overkill at wiki scale. Grep plus read wins below hundreds of thousands of documents.

• The real gap no v2 gist covers is an anti-hallucination guard against false absence: the AI claiming a note does not exist when it does.

• The upgrade is rules the AI enforces on itself, not bolted-on machinery.

Further reading

• Andrej Karpathy’s original LLM Wiki gist (2026-02)

• rohitg00’s LLM Wiki v2 gist (2026-03)

• I rebuilt Karpathy’s LLM Wiki. Here’s what’s missing from the original.

• Your notes are a graveyard. Here’s how to bring them back to life.

• obsidian-second-brain on GitHub

About the author

Eugeniu Ghelbur is an AI Automation Engineer at Single Grain, where he builds production AI systems for marketing and sales workflows. He ships open-source Claude Code skills and writes about AI knowledge management at theaioperator.io. The obsidian-second-brain skill described here is live on GitHub at github.com/eugeniughelbur/obsidian-second-brain, where it has been starred by over 2,300 developers.

Most note apps are where ideas go to die. You write something sharp, tag it, feel organized for an afternoon. Six months later you can’t find it, can’t remember the decision behind it, and you repeat a mistake you already made once and wrote down. (I wrote a whole piece on why your notes are a graveyard if you want the long version.)

I built obsidian-second-brain to end that. It’s an open-source system that turns a plain Obsidian vault into something that reads, writes, researches, and argues back, all driven by talking to an AI agent instead of clicking around. This week it got its biggest update yet. I call it The Architect, and it closes the one gap that bothered me most: the thing you spend most of your day inside, your codebase, never lived in your second brain. Now it does.

Let me show you what it could already do, then walk you through what just changed and how.

Subscribe now

What this thing actually is

If you’re new here: this started as my own attempt to rebuild Andrej Karpathy’s old “LLM Wiki” idea, a vault that rewrites itself as you feed it. I wrote up what I rebuilt and what was missing from the original. I built it for myself. Then 1,374 strangers cloned it, and it turned into a real project: 1,500+ stars, MIT licensed, and it runs on four different AI coding tools (Claude Code, Codex, Gemini, OpenCode) from one codebase.

It is not a notes app with AI bolted on the side. There’s no chat box in a corner. You operate the whole vault through commands you run by talking to the agent, and the agent does the filing, linking, and rewriting that you’d normally do by hand and never actually do.

Before: a second brain that already thinks

Here are a few of the commands that were already in place, and what they actually do day to day:

• /obsidian-save is the one that hooks people. You finish a long conversation with the AI and just say “save this.” It spins up parallel agents that pull out every person, project, decision, task, and idea from the chat, writes each one as a properly linked note, and updates your daily log. One command. You stop being a librarian for your own life.

• /obsidian-ingest takes a URL, a PDF, or a YouTube link. The vault doesn’t just file it in a folder. It rewrites itself around it: one source can touch 5 to 15 existing notes, updating what changed and linking what’s related.

• /obsidian-challenge is the one nobody expects. You pitch an idea and your own vault argues back, using your past notes and decisions as ammunition. It’s caught me about to repeat a mistake I’d already made and documented. I wrote about building a tool that lets my vault argue with me when I first shipped it.

• /research-deep reads what your vault already knows on a topic, finds the gaps, researches only those, and hands you the delta. No re-reading what you’ve already got.

• /obsidian-daily, /obsidian-visualize, /obsidian-reconcile give you your whole day pulled together each morning, a visual map of your entire knowledge graph, and a pass that hunts down contradictions across your notes and resolves them.

That was already 30-some commands of “your notes, alive.” Useful. But there was a hole in it, and once I saw it I couldn’t unsee it.

The gap: your code lived outside your brain

The vault captured my ideas, my people, my decisions, my research. But the thing I spend the most hours inside, the actual codebase, lived nowhere near it. It lived in a stale README that was wrong the week after I wrote it, and in my own head, which is worse, because heads leak.

So I’d save a sharp architectural decision into the vault (”we’re queueing webhooks instead of processing them inline, because X”), and three months later the decision note and the code that the decision shaped had no idea the other one existed. The knowledge was split in two and both halves rotted at their own speed.

That’s the gap The Architect closes.

After: The Architect

/obsidian-architect points the system at a software project and turns it into part of your second brain.

/obsidian-architect ~/Projects/my-app

Here’s what it does, in three parts, because the third part is the one that matters most.

What it does. It scans the whole project: languages, modules, dependencies, entry points. Then it writes a set of notes straight into your vault. An overview note with a diagram of how the pieces fit. One note per module, describing what that module does and what it depends on. And a “key decisions” note pulled from your own commit history, so the why behind the code gets captured, not just the what.

Why it’s powerful. Those notes aren’t dead documentation sitting in a docs/ folder nobody opens. They’re linked into everything else in your vault. A decision you saved months ago can now point straight at the module it shaped. “How does billing work again?” stops being a 40-minute code-reading session and becomes a question your vault answers in one note, with links out to the exact modules and the decisions behind them.

The part that makes it stick. Documentation always rots because writing it is a one-time act and the code keeps moving. So I built the refresh to be safe to re-run. Run /obsidian-architect again any time and it refreshes only the parts it generated. Anything you wrote by hand inside those notes is fenced off and never touched.

That fencing is the whole trick. Under the hood, the generated sections live between markers, and your hand-written notes live outside them. On a re-run, the agent regenerates what’s inside the fence and leaves everything outside it exactly as you left it. So the docs stay true as the code moves, instead of being accurate for exactly one day.

Before: my code knowledge lived in my head and decayed. After: it’s documented, linked, and self-updating, in the same brain as everything else I think about.

Everything else that got more powerful

The headline is The Architect, but this was a big release and the whole tool levelled up. The short version of what else landed:

• Research went free. Before this, /research needed a paid Perplexity key or it just errored out, which was the single biggest reason people bounced on first install. Now, with no key at all, it pulls from free public sources (Wikipedia, Hacker News, arXiv, Reddit, and more) and the AI writes the dossier from those. It works, for free, the second you install it. If you do have a key, it still uses it for deeper pulls.

• It learned your calendar. New commands pull your week into a note, book an event straight from a task, and turn a meeting into a note. There’s also a reconcile pass that checks your vault against your calendar and flags commitments you wrote down but never actually scheduled.

• It stopped lying by omission. The sneakiest AI failure mode isn’t making things up. It’s confidently telling you “you have no note on that” when you do, because it didn’t look hard enough. There’s now a hard rule baked in: search the whole vault before ever claiming something is missing.

• New thinking tools. You can convene a panel of different perspectives on a decision (/obsidian-panel), cross-reference everything your vault knows on one topic (/vault-deep-synthesis), or surface what’s actually worth working on next (/idea-discovery).

• It got trustworthy. This release added the first automated tests and CI. That’s the line between a weekend hack and something you’d hand years of your own notes to. And as of this update it runs on Codex CLI too, not just Claude Code.

Put it together and the count is now 43 commands across four AI tools. One vault that reads, writes, argues, researches, and now maps your code.

If you want the wider tour of the commands I actually use in a normal week, I broke those down in 30+ AI shortcuts I built for my own work.

Subscribe now

Already using it?

Pull the latest and that’s the whole upgrade. Everything is additive. Nothing breaks. One change worth knowing about: the optional background helper that quietly writes to your vault now ships off until you switch it on. Safer default, not a lost feature. If you relied on it, flip it back on and you’re exactly where you were.

New here?

It’s one line to install (the command is in the repo). Then run /obsidian-init to set up your vault structure, and /obsidian-daily to create your first note. After that, you mostly just talk to it.

Repo: github.com/eugeniughelbur/obsidian-second-brain

A second brain shouldn’t stop at your ideas. The code you write is knowledge too, and the decisions behind it are the part you forget fastest. Now they live in the same place as everything else you think about, and they stay true on their own.

If you build with this, I want to hear what you point The Architect at first. Reply and tell me.

I built 30+ AI shortcuts for my own work over six months.

Three of them quietly took three hours off every workday.

This post is about those three, and what makes them load-bearing.

I have a folder of small text files. Each file teaches my AI assistant to do one specific thing for me. I type a short name, hit enter, and Claude runs the recipe in that file. Some of these recipes take ten seconds to run. Some take six minutes. All of them replace work I used to do by hand.

There are thirty-something of these recipes now. Some are tiny. Some are mega-commands that pull data from five places, talk to three APIs, generate an image, and write five drafts in a row.

I do not use all of them every day. Most of them I built for one specific moment and then they sit there until that moment comes back. The interesting set is the small group I run every day, sometimes three or four times a day. Those three are the ones I want to write about. The other twenty-seven are good. These three are why my Tuesdays used to take a full day and now take a couple of hours.

What I mean by “shortcut”

If you have used ChatGPT, you have typed a prompt. A shortcut is a prompt I already wrote down for myself. Instead of typing the whole prompt every time, I type a short name and the AI loads the prompt and runs it on whatever context the conversation already has.

I work in a tool called Claude Code. It is the place I write code and the place I write everything else, including this post. Inside that tool, my shortcuts are stored as small Markdown files. There is no app to install, no SaaS to pay for, no UI. The shortcut is the prompt, and the prompt is the file. (The same setup is what I described when I rebuilt Karpathy’s LLM Wiki, if you have not read that one yet.)

This matters because the shortcuts compound. Each one I build can call any of the others. A morning routine shortcut runs a research shortcut, which calls a vault-search shortcut, which calls a write-to-disk shortcut. The composition is the whole point.

1. The one that writes my newsletter

The newsletter you are reading right now was drafted by a shortcut I built last week.

When I type the name of it, the shortcut does this: it scans the last seven days of my private notes, the last seven days of Google search data on my website, the last seven days of analytics on which posts people read, the last fourteen days of any deep-research I ran in another tool, recent issues and merges on my public GitHub repository, and a few other places. It scores every possible topic against five rubrics, then surfaces the top five candidates to me. I pick one. It then runs a research pass on that topic, drafts the newsletter, drafts the X version, drafts the LinkedIn version, drafts the Medium version, generates a hero image, runs a voice check, and saves everything.

The first time I ran it, the full pipeline took six minutes and produced a draft I could ship after fifteen minutes of editing.

Before this shortcut existed, the same workflow took me four hours on a good day. On a bad day, it took two days, because deciding what to write about was its own meeting with myself. I would scroll, second-guess, draft three openings I deleted, lose the thread, and end up posting nothing.

The shortcut does not write better than I do. What it does is remove the part where I have to start, which is the only part of writing I actually struggle with.

Saved per use: about four hours. I run it once or twice a week. That alone is about an hour back per day if I average it out.

Subscribe now

2. The one that turns my Claude chats into actual notes

I have a lot of conversations with Claude that produce real information. A decision, a project update, a meeting summary, a person I should remember, a debugging session that ended in a fix. Before I built this shortcut, all of that knowledge stayed inside the chat window. I would lose it the moment I closed the tab.

The shortcut reads the current conversation, figures out what is worth keeping, and writes the right kind of note to the right place in my second brain. A decision becomes a decision record with a date and a wikilink to the people involved. A project update becomes an append to the project’s note. A person I just talked to becomes a contact card, or updates the existing one. The whole thing takes about ten seconds and writes between one and six files.

I run this one between three and ten times a day. Every Claude session that produces something real ends with this shortcut.

The hidden value is not the ten seconds I save versus typing the notes by hand. It is that the notes actually get written. Before this existed, the answer to “did I write that down?” was almost always no. Now the answer is yes, and the writing is structured the same way every time, so future-me can find it.

Saved per day: about an hour, if you count the value of notes that would otherwise not exist at all. Hard to put a number on knowledge you would have lost, but a useful one to try.

Here I talk about the skill I built; Obsidian Second Brain (Starred by 1400 stars and used by more than 10k starngers now)

Subscribe now

3. The one that does my research

Whenever I need to understand something I do not already understand, I run a shortcut that does deep research for me. It uses Perplexity in the background, runs multiple passes, gathers citations, and writes a structured report to disk. Topics range from “is this stack the right choice for my new SaaS” to “what is the current state of this regulatory thing in Spain” to “what did this person just say on a podcast and is it on-topic for what I am building.”

A real research task that used to take me two to three hours of tabs, scrolling, and forgetting to bookmark now takes the shortcut about three minutes and produces a citation-grounded document I can either trust or push back on.

I do not use this every day. I use it three to five times a week. But each use saves enough time that on a research-heavy day, the shortcut is the difference between shipping something and not.

Saved per use: ninety minutes to two hours. Distributed across the week, this is conservatively an hour a day.

The pattern under the three

These three look unrelated. One writes a newsletter. One files notes. One does research.

They share one shape. Each one takes a thing that used to live inside my head and gives it to the machine, in a form the machine can repeat. The hard part was not the prompt. The hard part was deciding what to extract, which fields to require, which file format to write to, and what to do when the input is messy.

The actual lesson is not “build more shortcuts.” The lesson is that the bottleneck of working with AI is not the AI. The bottleneck is the lack of a clear, repeatable way to ask the AI for the thing you want, every single time, without thinking about it. Once you have that, the AI is fast, and you become fast.

Three hours a day, on a knowledge worker’s calendar, is the difference between treading water and shipping a side project.

What I am not saying

I am not saying everybody should learn to write these. Most people will not, and most people do not need to. What I am saying is that the shape of the win is reproducible. The same logic works in any tool that has prompts, including the AI tools your company is probably paying for and not using well.

If you want to see the actual shortcuts, they are at github.com/eugeniughelbur/obsidian-second-brain, MIT licensed, currently at 1,358 stars. (Earlier this month I wrote about what surprised me when 1,374 strangers cloned the repo. That post is the back-story to this one.) The shortcuts I described above are in that repo, or in a sibling project I am still building in the open.

The full set is thirty-something. Three save me three hours a day. The other twenty-seven save me thirty-second moments. The thirty-second moments add up too.

TL;DR

• Glean is a $7.2B bet that you can search your way out of a messy corpus.

• I think the wedge is the opposite: refuse bad notes at write-time.

• I have shipped the primitive at one-person scale in OSB v0.7. The company version is still a thesis.

New here? I write one post per Tuesday on AI workflows, agent patterns, and what actually works in production. Subscribe to The AI Operator →

Subscribe now

The wedge is write-time, not read-time

The way to beat Glean is to clean before you save, not search after. Glean is a $7.2B work-AI platform (Series F, June 2025, $200M ARR per Futurum 2025-09). It crawls Slack, Notion, Google Drive, Jira, builds a permissions-aware knowledge graph, and runs read-time search plus agentic actions across the pile. The pile stays a pile.

I think the better wedge is intercepting content at write-time. Before a note saves, an agent checks whether it has the metadata, the preamble, and the structure that make it findable later. If it does not, the note gets flagged at the door.

The logic is simple. If you clean on write, you do not need a seven-figure search layer to find things on read.

I want to be honest about scope up front. The validator hook runs against my personal vault, not a company corpus. But this is not pure theory either. Since shipping the primitive, a venture-backed founder who found me through the open-source repo became a paying consulting client, and over a recent in-person session signaled willingness to back the team version if I build it. The rest of this post is what that team version would look like. Public version of the pitch.

What “second brain for companies” would actually mean

A company second brain is a single graph where every document has one canonical home, typed links, and machine-readable metadata. Three properties define it:

• One canonical doc per concept. Duplicates get merged or redirected.

• Typed backlinks. Not just “this links to that,” but “this DECIDES that” or “this BLOCKS that.”

• Write-time validation. An agent reviews the note before it persists.

Glean does none of this. Glean is a flashlight in a warehouse. The thesis is to build the warehouse.

The primitive I have actually shipped

The primitive exists today as a Claude Code PostToolUse hook that enforces a write-time schema on every save. In OSB v0.7, I shipped it at hooks/validate-ai-first.sh. It runs every time Claude Code writes a file inside my vault path. The hook warns when a note violates the AI-first rule: missing frontmatter, missing preamble, missing ai-first: true, or otherwise failing the schema I have set for my own corpus.

This is a one-person primitive. It runs against my vault. It is not multiplayer, it has no duplicate detection across a team, and it has no notion of canonical ownership across humans. What it does prove is that the agent surface (Claude Code) plus the substrate (Obsidian, plain markdown, local files) can enforce a write-time schema without a separate server, a separate UI, or a separate buyer.

The repo is public at github.com/eugeniughelbur/obsidian-second-brain, MIT licensed, around 1.3K stars, 33 commands as of v0.8.0. (on May 19th, 2026).

What the company version would need

The personal hook is the architecture in miniature. To make it work for a team, four things have to be added:

1. Duplicate detection across a shared vault, not just schema checks on a single file.

2. Canonical-location suggestion when two docs claim the same concept.

3. Typed links (decides, blocks, supersedes, references) instead of bare wikilinks.

4. A multiplayer lock model so two people are not silently editing the same canonical doc.

The schema I would push for, carried in every doc’s frontmatter:

• type: decision, spec, retro, meeting, reference, draft

• owner: single human, not a team

• status: draft, active, archived, superseded-by

• links_in / links_out: typed (decides, blocks, supersedes, references)

• canonical_for: the concept this doc owns

• last_validated: ISO date

The agent rejects anything missing these. That sounds harsh. In practice the agent can fill most fields itself and ask one question. The cost of being strict at write-time is a short prompt. The cost of being loose is a six-month archaeological dig later.

Why Glean cannot pivot here

Glean cannot pivot here because write-time validation is a developer-tools sale, not an IT sale. Glean’s distribution is enterprise IT. Their buyer wants a layer over the existing mess because changing the mess is a political fight. Write-time validation requires changing how people write, which means changing the tool they write in.

That is a developer-tools sale, not an IT sale. Different buyer, different motion, different product surface. Glean does ship agentic write actions (Agentic Engine 2, Canvas co-authoring, Glean Protect Plus governance), but those are AI-agents-execute-tasks-in-source-systems, not validate-the-document-against-a-schema-before-it-saves. The wedge I want is at the editor, in the human’s write path, before the doc exists. The wedge has to start bottom-up, inside the writing tool, not top-down from a CIO budget line. That is why I built the open-source repo at github.com/eugeniughelbur/obsidian-second-brain instead of pitching a platform.

Subscribe now

How does this connect to the personal second brain

I have written about the personal version of this pattern in three places worth reading:

• I rebuilt Karpathy’s LLM wiki in Obsidian. The same canonical-doc-per-concept rule, scaled down to one person.

• I built a tool that lets my Obsidian vault talk back. The agent loop that the validator hook grew out of.

• I built this for myself, then 1,374 people cloned it. The signal that solo patterns find an audience.

The company version is not a new architecture. It is the personal vault pattern with multiplayer locks and a stricter schema.

Why this is the right wedge in 2026

Write-time cleanup became the right wedge in 2026 because three forces converged, and one third-party analyst already raised doubts about whether Glean’s knowledge-graph moat survives. Futurum Group wrote in September 2025 that Glean’s “future success depends on whether its knowledge graph depth can hold off an improving and natively integrated Microsoft 365 Copilot.” That is the moat question every founder should be asking about every search-layer business: what happens when the suite vendors index the same corpus natively. Three forces converged this year:

• Long context windows at production cost. Write-time validation against a meaningful slice of the corpus is finally cheap enough to run on every save.

• Glean’s $7.2B valuation made every PM realize search is the consolation prize for a clean corpus. The category is funded, which means the category is also legible to founders looking for the inverse bet.

• Agent surfaces inside editors are now real. Claude Code, Cursor, and the Obsidian plugin ecosystem mean an agent can sit in the write path without a custom client.

The opening is write-time cleanup as a layer that lives inside the editor, not a search box bolted on top.

Frequently asked questions

Is this a Glean competitor today?
No. Glean is a shipped product, $200M ARR by mid-2025, customers in 27 countries, $1M+ contracts growing 3x year over year (Futurum, 2025-09). I have a personal primitive and a thesis. The argument is about where the category is going, not where it is.

Does write-time AI cleanup slow people down?
It adds friction at save. The bet is that the friction is small relative to the time later spent hunting for the right version of a doc that should not have existed in the first place. I have not measured this at team scale.

Why Obsidian as the substrate?
Plain markdown, local files, plugin API, git-native. No other tool I have tried gives me a writable graph with a real agent surface I can hook into. The repo is at github.com/eugeniughelbur/obsidian-second-brain.

What is the proof you have right now?
A working PostToolUse hook in OSB v0.7 that enforces the AI-first schema against my personal vault. It runs on every Claude Code write inside the vault path. That is one-person proof of architecture. The business proof so far is one inbound founder, paid consulting client, in-person investor signal. Early. Not a term sheet. Enough to know the wedge is real to someone who runs a real company.

What would change your mind about the wedge?
If a team adopted write-time validation and the corpus did not get measurably cleaner, the thesis is wrong. The honest next step is to run that test, not to claim I already have.

So what

If you are choosing a knowledge tool in 2026, the question is not “which search is best.” The question is “what stops bad docs from being written in the first place.” Search is the tax you pay for skipping that question. The second brain for companies is the answer that skips the tax. I have the personal primitive. The company version is still a thesis, and I would rather say so than fake the receipts.

If you got value from this post:

• Free: I publish one of these every Tuesday on AI workflows, agent patterns, and what actually ships. Subscribe to The AI Operator →

• Paid ($8/mo or $80/yr): Monthly deep-dives with the actual code, configs, and setup walkthroughs behind the thesis posts. Coming up in a few weeks: the hooks/validate-ai-first.sh walkthrough, exact frontmatter schema, Claude Code PostToolUse config, and the prompt templates that catch what a regex cannot. Upgrade to paid →

• Repo: github.com/eugeniughelbur/obsidian-second-brain. The open-source primitive this post is built on. MIT licensed, 33 commands as of v0.8.0.

Find me on X: @eugeniu_ghelbur. Replies open.

Update, 2026: The AI Operator has narrowed its focus to AI and building with AI in production. This post is from before that shift. If that’s what you’re here for, start with I rebuilt Karpathy’s LLM Wiki, I built this for myself. Then 1,374 strangers cloned it., or what The AI Operator is now.

Every November, The Economist publishes a cover so dense with symbolism it launches a thousand conspiracy theories. The 2026 edition (40 years into their predictions practice) is the most analyzed magazine cover of the decade.

The question splitting readers: is it forecast, signal, or something more deliberate?

I’m an AI automation engineer. I read this cover the way I read product diagrams. Every element is there for a reason, and the reasons usually live in the second pass.

After two weeks decoding it, here’s what I found. 2026 isn’t the year the world breaks. It’s the year we discover how it already broke, and the role AI plays in keeping it that way.

Subscribe now

The Cover That Broke the Internet

Released November 10, 2025. The Economist’s “World Ahead 2026” cover renders a chaotic planet as a soccer ball, orbiting weapons, pills, surveillance drones, and a birthday cake marked “250.”

Within 48 hours it went viral. Not just in policy circles. Across TikTok, X, and conspiracy forums.

Why the obsession? The Economist isn’t just any magazine. 21% owned by the Rothschild family. Read by every G7 finance minister. When they publish predictions, markets move.

Their Editor-in-Chief attended the 2025 Bilderberg meeting in Stockholm. Their track record is “weirdly accurate.” They correctly predicted 6 of 9 major 2025 events, though they badly underestimated Trump’s 2024 victory (giving him only 33% odds).

But 2026 is different. Editor Tom Standage calls it “a year of uncertainty” where “the old world order is finished.” Not incremental change. Systemic recombination.

And almost every signal on the cover points at one accelerant: AI.

The Visual Grammar: Red vs. Blue, Chaos vs. Control

Start with the color. The cover splits the world into red and blue. That one choice is the geopolitical map.

Blue is the Western order. NATO, tech dominance, the dollar system, democratic institutions. Defensive posture, trying to hold the global chokepoints: SWIFT payments, semiconductor supply chains, shipping insurance.

Red is alarm. Disruption. Conflict. The revisionist powers (China, Russia), inflation zones, hot conflicts.

The interplay isn’t Cold War binary. It’s messier. A nervous system where a shock in one domain transmits instantly across the whole structure.

This isn’t East vs. West. It’s a Standards War. Two competing systems for AI regulation, trade rules, digital currencies, tech ecosystems.

Countries aren’t choosing sides. They’re navigating between two incompatible operating systems.

The 250 Birthday Cake: America’s Divided Jubilee

At the center sits a massive cake marked “250.” America’s 250th anniversary on July 4, 2026. Look closer.

Rising from the cake: a blue fist locked in handcuffs. Popular uprising met with authoritarian response. Below it, a cracked judicial gavel signals a fractured justice system. The balloons are red, echoing the 1983 Cold War track “99 Red Balloons” about innocent objects triggering military panic.

The Economist predicts Americans will hear “wildly diverging accounts” of their country. Two competing narratives:

• The 1776 narrative (Republican / Trump): founding ideals, nationalism, rejection of “woke” revisionism.

• The 1619 narrative (Democrat / progressive): unfinished work of democracy, reckoning with slavery and inequality.

This isn’t just a culture war. It’s a narrative civil war, and AI is the megaphone. Russia and China will amplify the divisions through AI-generated disinformation, deepfake politicians, synthetic protest footage. The 250th anniversary won’t unite America. It will reveal how fractured it already is.

Same week, Philadelphia hosts a FIFA World Cup Round of 16 match. Patriotic spectacle colliding with global sport, with strained relations between the US and co-hosts Mexico and Canada.

Subscribe now

The Soccer Ball Earth: When Sport Becomes Warfare

The planet is rendered as a black-and-white soccer ball. Direct reference to the 2026 FIFA World Cup (June 11 to July 19). First 48-team tournament. First three-nation hosting.

The symbolism runs deeper. The world as a ball being kicked around by powerful actors. Geopolitics as competitive spectacle where the referee (international law) has limited authority.

Tourism Economics projects 1.24 million international visitors, 6.5 million total attendees. The Economist warns “fans may stay away” because of political tensions. Trump threatened to remove matches from Democrat-led cities. Even the world’s most unifying event cannot escape geopolitics.

A 48-team tournament at this scale runs on AI infrastructure. Facial recognition, threat detection, drone surveillance, crowd-flow models. The stadium is the surveillance state’s product demo.

This connects to The Economist’s “Sporting Values” theme. Sport no longer offers respite from politics. It IS politics. The shift is from “sportswashing” to sports-warfare, where hosting rights and fan treatment become diplomatic weapons.

Meanwhile, the Enhanced Games debut in Las Vegas (May 2026). Performance-enhancing drugs explicitly permitted. $500,000 purses per event. $1 million for world records. WADA calls it “ridiculous and dangerous.” But it is happening.

Most of those drugs were AI-designed. Modern drug discovery is AI-first. The Enhanced Games is what happens when you stop pretending the AI-pharma pipeline exists.

The question: is enhancement cheating, or just a different game?

This extends beyond athletics. Millions take next-gen GLP-1 weight-loss pills (also AI-discovered). As The Economist notes: “Few people compete in the Olympics, but anyone can take part in the Ozempic games.”

Grey Zone Warfare: The New Normal

The cover bristles with military hardware. White missiles with red tips. Tanks scattered globally. An armed robot dog (direct reference to China’s weaponized dog-like robots deployed in 2023 military drills).

But notice. These aren’t arranged for total war. They’re positioned for perpetual tension.

The Economist predicts 2026 will see “grey zone” provocations. Hostile actions below the threshold of declared war. And the grey zone is where AI changes everything: cheaper, deniable, scalable.

Northern European front

Russia will test NATO commitment through:

• GPS jamming affecting civil aviation

• “Accidental” severing of undersea fiber-optic cables (seabed warfare)

• AI-driven cyberattacks on infrastructure (banks, power grids)

Strategic goal: fracture NATO unity. If a cable is cut and Russia denies it, does NATO invoke Article 5? The ambiguity is the weapon. AI makes the ambiguity cheaper to produce.

South China Sea front

China will test US resolve through:

• Maritime militia vessels (fishing boats acting as naval auxiliaries)

• Water-cannoning Philippine resupply ships

• “Quarantine” blockades of Taiwan

Japan’s Type-12 surface-to-ship missiles extend to 1,000km range by 2026, creating a new deterrent landscape China may test before it is fully operational.

After Gaza, The Iran War, and What The Economist Missed

The cover labeled Middle East “After Gaza.” The thesis: transition from kinetic intensity to fragile diplomacy.

They underestimated how fast the transition would invert.

On February 28, 2026, US and Israeli forces launched Operation Epic Fury. The strike assassinated Iran’s Supreme Leader Ali Khamenei and hit nuclear sites. Iran retaliated with missile and drone strikes on Israel, US bases, and Gulf states. Iran closed the Strait of Hormuz. Global trade choked.

Operation Epic Fury formally ended May 5, 2026. Thousands dead. Millions displaced across Iran, Lebanon, Israel, and the Gulf.

The ceasefire is “indefinite” but fragile. On May 10, Trump rejected Iran’s nuclear proposal. Iran’s military warned of “new arenas of war.” Drones tested the ceasefire the same day off Qatar, with airspace incursions into UAE and Kuwait.

The new power center inside Iran is IRGC Commander Maj. Gen. Ahmad Vahidi, the de facto successor to Khamenei. He is the hardliner blocking concessions on the Strait of Hormuz and Iran’s HEU stockpile. The US is pushing a one-page MoU. Iran is stalling.

Russia is rebuilding Iran’s capacity during the ceasefire. Drone components arrive via the Caspian Sea. During the war, Russia and China shared satellite imagery of US bases with Iran. The “Standards War” of the cover is now a kinetic alliance.

Iranian-backed Iraqi militias (Kataib Hezbollah, Hezbollah al Nujaba, Kataib Sayyid al Shuhada) refuse to disarm. The 2026 Iran war ended on the calendar, not on the ground.

What the cover got right: the militarization. The robot dog. The missiles with red tips. The Standards War. The Russia-China alignment.

What it missed: the speed. The assassination of a head of state. The Strait closure. The scale of displacement. The Economist projected a “Trumpian deal” for Saudi-Israel normalization. There has been no deal. There has been a war.

The accelerant the cover did not name: AI-targeted drones, AI-analyzed satellite intel from Beijing, AI-enhanced naval logistics in the US blockade. The cover showed surveillance. It did not show that the surveillance had already gone autonomous.

Subscribe now

The Brain and the Controller: Cognitive Warfare

The cover’s most dystopian image is the simplest. A human brain wired to a video game controller.

It reads two ways at once.

Technological. Neuralink brain-computer interfaces enter clinical trials. 2026 is the year biology and silicon start sharing wire.

Sociological. This is cognitive warfare. The US 250th anniversary and November midterms make 2026 a year when the “public mind” becomes the contested terrain. Political narratives play out like video games. Recommendation algorithms are the controllers. Human sentiment is the score.

The battlefield of 2026 isn’t just land or sea. It’s the neuro-circuitry of populations.

Gartner predicts 40% of enterprise applications will run task-specific AI agents by 2026, up from under 5% in 2025. But Nobel laureate Daron Acemoglu warns: “These models are being hyped up, and we’re investing more than we should.”

The Economist asks bluntly: “Will the AI bubble burst?”

By 2026, trillions will have been spent on AI infrastructure: chips, data centers, energy. Investors will demand tangible ROI. If AI hasn’t delivered productivity gains, funding could evaporate, triggering a tech crash on the scale of the 2000 dot-com burst.

The energy constraint is real. Data centers consume more electricity each quarter, forcing a pivot back to nuclear or fossil fuels, colliding directly with climate goals.

Economic Gravity Returns: The Bond Market Reckoning

A plunging red line graph with scattered US pennies appears prominently. The Economist’s warning: “rich countries are living beyond their means.”

The bond vigilante scenario

G7 governments ran massive deficits for pandemic relief, wars, and industrial policy. AI capex added trillions on top. In 2026, the bill comes due.

“Bond vigilantes” (investors who sell government debt to protest fiscal irresponsibility) may return, driving up yields. This crushes government budgets as debt service costs soar. It also crushes mortgage holders.

The choice becomes brutal:

• Austerity: cut spending (risks recession and unrest)

• Financial repression: let inflation run hot to erode debt

J.P. Morgan assigns 40% probability to a US or global recession. Fed Chair Jerome Powell’s term ends May 2026. Politicizing the Fed seat could trigger a market showdown.

Trump’s tariffs will “dampen global growth,” eventually biting consumers with stagflationary pressure.

China’s deflationary trap

China faces its own crisis: deflation, industrial glut, demographic decline. Goldman Sachs projects 4.3 to 5.0% GDP growth. But the strategy of “exporting its way out” by flooding the world with cheap goods will trigger retaliatory tariffs from the US and Europe.

The crisis creates opportunity. As the US turns inward (”America First”), China consolidates the Global South. Latin America, Africa, Southeast Asia. China presents itself as the “adult in the room,” offering trade agreements and green tech dominance: EVs, solar, batteries. All AI-optimized supply chains. Bangladesh is explicitly targeted for engagement with lower-interest loans.

The Pharmaceutical Revolution: Syringes, Pills, and the Supply Chain of Thinness

Giant hypodermic needles and scattered pills dominate the cover. The Economist’s tenth theme: “Ozempic, but better.”

Next-gen GLP-1 weight-loss drugs arrive in pill form in 2026. Eli Lilly’s orforglipron targets spring FDA approval at $149-150 per month (vs $1,000+ for current injectables). Novo Nordisk slashed prices 70%. Generic versions launch in Brazil, China, India. The global market surpassed $26 billion in 2025 and explodes from there.

The economic earthquake

This isn’t just healthcare. It’s macro-economic disruption.

• “Big Junk” food industry faces existential threat. As caloric intake drops globally, Nestlé, PepsiCo, McDonald’s see shrinking markets. Investors may short these stocks while going long on pharma giants.

• Healthcare systems face upfront cost explosions despite long-term savings from reduced diabetes and heart disease.

• The ethics debate: “Is taking them cheating?” The question extends from athletes to everyday people. Are we hacking our metabolism or addressing a health crisis?

The other syringe: pandemic stockpile

The syringes next to missiles aren’t coincidence. Pharmaceutical supply chains are now national security, and 2026 is testing them on two fronts at once.

H5N1 avian flu has 71 US cases since 2024, 43 mammal species infected, one US death in Louisiana, one child fatality in Bangladesh (January 2026), and one British Columbia case with no identified exposure source (March 2026). WHO tracked 13 zoonotic flu variant cases in Q1 2026. No sustained human-to-human transmission yet. The “yet” is doing a lot of work.

AI-discovered antivirals, AI-screened pathogens, and AI-monitored wildlife genomic surveillance are now the default pipeline for pandemic preparedness. The same AI-pharma stack that produced cheap GLP-1 pills is the stack racing the next outbreak.

The cover shows the syringe as a symbol of societal transformation and geopolitical positioning. The same syringe is the front line of biosecurity.

Subscribe now

Surveillance Omnipresence: The Transparent Battlefield

The cover swarms with drones and satellites. They visualize the “panopticon” state where privacy is extinct.

The end of privacy. Surveillance spans urban centers to the remote Arctic. Every cable, every ship, every movement is monitored. The panopticon only works at this scale because AI does the watching now. Humans do not review feeds. Models do.

Orbital warfare. These symbols warn of grey-zone provocations in space. Expect satellite dazzling, cyber-hijacking of constellations, militarization of commercial assets like Starlink. The eyes are watching. They are also targets.

The broader theme: 2026 is the year of the “Transparent Battlefield.” Advantage goes to those who see first, decide fastest, and act before the other side has processed the same data. That is an AI workload, not a human one.

The European Trilemma: An Impossible Balancing Act

The Economist identifies “Problems for Europe” as a top theme. The continent faces a mathematical impossibility:

• Increase defense spending (to deter Russia)

• Maintain social welfare (to appease voters)

• Reduce deficits (to please bond markets)

It cannot do all three.

Austerity drives voters toward anti-establishment parties threatening Euro / NATO exit. That creates an existential crisis for the EU project. The hard-right populism surge becomes the engine of political instability.

Yet opportunity exists. Defense industry renaissance. Leadership in AI regulation through the AI Act, which has become the global benchmark for governance frameworks while Washington stalls and Beijing builds its own.

Regional Outlook: The Strategic Map of 2026

Climate’s Mixed Picture: Green Hushing

The cover shows melting ice cubes. A nod to climate crisis. The Economist’s verdict: 1.5°C warming target is “off the table.”

But here’s the twist: “Green Hushing” emerges as corporate strategy. Companies keep decarbonizing, not for ideology but because solar and wind are now cheaper. They stop talking about it to avoid anti-ESG backlash in Trump’s America.

Meanwhile the Global South accelerates adoption, aided by Chinese tech. The “Green” mantle passes from West to developing world. The moral center of gravity in geopolitics shifts with it.

Geothermal energy emerges as the sector to watch. AI data centers need 24/7 baseload power that solar and wind cannot match. Geothermal can. The energy transition is now downstream of the AI capex cycle.

The Conspiracy Layer: Predictive Programming or Pattern Recognition?

No analysis is complete without addressing the elephant in the room: conspiracy theories.

Within days of release, alternative media exploded with “decoding” content. Key narratives:

The Rothschild-Bilderberg theory. With 21% Rothschild ownership and the Editor-in-Chief attending Bilderberg, conspiracists frame the predictions as elite communication, not analysis.

The Illuminati / 1776 connection. 1776 marked both US independence and the Bavarian Illuminati founding. The cake is read as “alluding to elite secret agendas.”

The “Plandemic” interpretation. Prominent syringes signal another health crisis. Marburg virus fears dominate this thread.

The mind-control theory. The brain-controller represents mass psychological manipulation via AI. This one is less conspiracy and more current operating reality of every social platform you use.

The Economist has leaned into the speculation, admitting they include “mysterious symbols or red herrings to keep conspiracists guessing.”

But here is the reality. Elite forecasters report 53% confidence but achieve only 23% accuracy (Berkeley Haas study). Fed research shows professional forecasts perform no better than benchmarks at one-year horizons.

The pattern. The Economist excels at identifying which issues will dominate discourse. Call it a trend compass. They struggle with specific outcomes, timing, and black swans.

Use these predictions as a framework for understanding what sophisticated analysts consider important, not as prophecy.

Subscribe now

What Actually Happens in 2026: The Scheduled Events

Beyond predictions, here is what is confirmed:

• February 6-22: Milano Cortina Winter Olympics (debuts ski mountaineering)

• February 8: Super Bowl LX at Levi’s Stadium

• February 2026: Artemis II, first crewed lunar mission since 1972 (NASA budget concerns may delay)

• June 11 - July 19: FIFA World Cup (48 teams, 16 US cities)

• July 4: US 250th anniversary. Time capsule burial in Philadelphia. 7th International Fleet Review (60 ships, 30 countries). MLB All-Star Game

• November 3: US Midterm Elections (Democrats need net +3 for House majority; historical trends favor opposition. AI-generated deepfake interference is the wildcard)

The Meta-Narrative: From Globalization to Game Theory

The synthesis of all this research reveals a profound shift.

We are moving from the era of “Globalization” to the era of “Game Theory.”

Relationships are transactional, strategic, zero-sum. The distinction between a trade deal and a peace treaty has vanished. Sport, health, technology, finance: all are now weapons in a single arena of competition.

The “nervous system” metaphor is perfect. A shock anywhere transmits everywhere. A tariff tweet in Washington affects chip supply in Taiwan, energy prices in Europe, bond yields in Japan.

The old world order is not dying. It is already dead. 2026 reveals what replaces it: fluid “coalitions of the willing,” competing tech standards, weaponized commerce, grey-zone conflicts where ambiguity is the strategy.

And one operating system running underneath all of it: AI.

Conclusion: Watch the Grey Zones

The Economist’s 2026 cover functions as visual information density. Too many crises to isolate, too interconnected to separate. Earth as a soccer ball orbited by weapons, pills, and surveillance while a divided America celebrates: festivity amid fragility.

The lasting value is not predictive accuracy (which will be mixed). The value is the identification of forces competing for attention. A birthday party held on a soccer ball surrounded by missiles and pills, with a handcuffed fist emerging from the cake. That is the visual thesis.

Same exercise I ran last year on the 2025 cover. The framework holds. The threat surface widened.

Here is your action framework for 2026:

1. Watch the grey zones

The next crisis will not start with a declaration of war. It will start with a severed cable in the North Sea, a “quarantine” of Taiwan, or a quiet bond market default.

2. Follow the money and the medications

The GLP-1 revolution will reshape economies faster than AI. Short junk food, long pharma, and watch for healthcare cost explosions.

3. Understand cognitive warfare

Elections, narratives, and public opinion are the battlefield. Algorithms are the weapons. Your attention is the territory.

4. Embrace transactionalism

Permanent alliances are over. Success goes to those who can play multiple sides without commitment.

5. Prepare for volatility

2026 is not the year the world breaks. It is the year we discover how it already broke and learn to navigate the fragments.

Navigating fragments is now a tooling problem. You need a personal system that captures, connects, and surfaces what matters before the next signal arrives. That is exactly what obsidian-second-brain was built for, and why I built it for myself.

In 2026 the future arrives. Not as shiny utopia. As gritty reality of AI surveillance, bio-hacked bodies, and drone warfare. Everything is connected. Everything is at risk.

The question is not whether The Economist’s predictions come true. The question is whether you are ready for a world where they are even plausible.

Your Turn: What Do You See?

I’ve decoded what five AI systems and dozens of analysts found in this cover. But symbols are Rorschach tests. They reveal as much about the observer as the observed.

What patterns do you see emerging? What am I missing?

Drop your analysis in the comments. Let’s build a collective intelligence network that rivals any think tank.

If you found this useful, subscribe to The AI Operator. One post per week. AI agent patterns, Obsidian + AI workflows, and the geopolitical context of the technology shaping 2026.

Clarity is the only competitive advantage left.

Subscribe now

Sources

• The Economist, “The World Ahead 2026” (November 2025)

• Berkeley Haas Business School, “Elite Forecaster Accuracy Study”

• J.P. Morgan Global Economic Research

• Goldman Sachs China Economic Outlook

• Gartner AI Adoption Forecasts

• Tourism Economics FIFA World Cup Impact Analysis

• Institute for the Study of War, Iran Update Special Reports (May 2026)

• CDC A(H5) Bird Flu Situation Summary

• WHO Q1 2026 Zoonotic Influenza Report via CIDRAP

What is obsidian-second-brain? A free, open-source Claude Code skill that gives Claude persistent memory through your Obsidian vault. 1,024 stars in seven weeks. MIT licensed. Built by Eugeniu Ghelbur. Repo: github.com/eugeniughelbur/obsidian-second-brain.

You use Claude every day. Every session starts from scratch. You re-explain everything. The conversation ends. Everything disappears.

You take notes in Obsidian. Hundreds of files. They just sit there. You make the same decision twice because you forgot you made it six months ago.

Two powerful tools. Completely disconnected.

That was my problem. I was tired of it. So I built the bridge.

Then I open-sourced it on GitHub. Seven weeks later, 1,374 strangers had cloned it.

This post is what I built, why people are using it, and what it might mean for you if you bring AI into your work.

What obsidian-second-brain does

obsidian-second-brain is a free Claude Code skill. Open source. MIT license. The repo is called obsidian-second-brain.

Under the hood it’s 31 commands across four layers. But you don’t need to know all 31. You only need to know what each layer DOES:

1. Claude remembers. Every meeting, every decision, every voice memo, every screenshot. It gets saved to the right place in your vault automatically. You stop losing things.

2. Claude thinks with you. Your vault argues back. Before you decide something, you can ask “have I been here before?” and it shows you your past failures and reversed decisions on the same topic.

3. Claude knows you. Your identity, your projects, your current state. Loaded in ten seconds. Every session picks up where the last one ended.

4. Claude pulls knowledge in. X posts, web research, YouTube transcripts. They go into your vault, not just into a temporary chat that disappears.

Plus four scheduled agents that run while you sleep. The vault gets smarter without you.

You don’t even have to open Obsidian to use it. Everything happens through Claude.

What it actually does

Some real moments where it changes how you work:

• After a meeting, one command saves every decision, person, task, and idea to the right note. You do nothing.

• You record a voice memo on your phone. Drop it in. It gets transcribed, the action items get extracted, the right people and projects get linked.

• You take a photo of a whiteboard. Same thing. The image becomes searchable knowledge.

• You find a great YouTube video. It doesn’t get summarized into one new note. It REWRITES your existing pages. People get updated. Contradictions get resolved. Patterns trigger new synthesis pages.

• Before a big decision, the vault searches your past notes for the same topic and pushes back with your own words. Your vault holds you accountable.

• You go to sleep, and a nightly agent runs five phases: closes the day, reconciles contradictions, finds patterns across sources, heals orphan notes, rebuilds the index. You wake up to a smarter vault.

That’s the difference between a notes app and a second brain. The notes app waits for you. The second brain works for you.

The proof

Here are the numbers, fresh from the GitHub Insights page today:

• Created seven weeks ago. 2026-03-24.

• 1,024 stars.

• 99 forks.

• 1,374 unique people cloned the repo in the last two weeks alone. That’s not vanity. Cloning means they actually pulled the code down to try it.

• 5,910 unique visitors to the repo in 14 days.

• The top referrer is Twitter, by a wide margin. The second is Google. People are searching for this and finding it.

The first public user feedback came in a LinkedIn DM from a Cybersecurity Leader. He said he was “personally impressed by the correlation engine within one hour” of migrating his own data into the vault.

The first external code contribution came from someone I had never met. He shipped 695 lines of code to add a new /podcast command. He found a real bug in my code while doing it. The project isn’t just mine anymore.

The Substack readers who actually click through to the repo convert at 24 percent. Meaning the people who read about it stay.

Subscribe now

Why this matters if you’re a founder

Your team uses AI. Your team takes notes. The two don’t talk.

You hire someone in March. They have great calls with three customers in their first week. The notes go into a tool. The Claude conversations go nowhere. By June, that person has switched roles or left. The customer insight is gone.

Multiply that by fifty people on your team and you have institutional amnesia at scale. Your company knows things, but your company can’t remember them.

This open-source skill is how I solved that problem for one person. Me. The principles are the same at any size. The code is free to fork.

If you bring AI into your team in the next six months, your team is going to hit this exact wall. The fix isn’t a new SaaS subscription. It’s a pattern. The pattern is in the repo.

Try it

GitHub repo: github.com/eugeniughelbur/obsidian-second-brain

It’s free. MIT license. One command to install.

If you don’t use Obsidian or Claude Code yet, the README explains both. If you do, you can be running it in five minutes.

Frequently asked questions

What is obsidian-second-brain?
A free, open-source Claude Code skill that connects Claude to an Obsidian vault. Every conversation, decision, meeting note, voice memo, and research finding gets saved to the right place automatically. The vault then feeds context back into every future Claude session.

Is it free?
Yes. MIT license. Free to use, fork, or extend. There is no paid tier.

Who built it?
Eugeniu Ghelbur, AI Automation Engineer at Single Grain. The repo went public on 2026-03-24. As of 2026-05-10 it has 1,024 stars, 99 forks, and 1,374 clones in the prior 14 days.

Do I need to know how to code?
No. One command installs it. The README walks you through Claude Code and Obsidian setup from scratch.

Does it require Claude Code?
Yes. It is a Claude Code skill, not a standalone app. Claude Code is free at claude.com/claude-code.

Does it require Obsidian?
Yes. Obsidian is free for personal use. The skill assumes a markdown vault on local disk.

How is this different from Obsidian AI plugins like Smart Connections?
Most plugins call an AI API from inside Obsidian. obsidian-second-brain inverts that. Claude is the operator. The vault is its memory. You can go weeks without opening Obsidian. The vault gets smarter while you work somewhere else.

Where is the repo?
github.com/eugeniughelbur/obsidian-second-brain

Subscribe now

What’s next

This is week one of The AI Operator, my publication for people building with AI in production.

One post per Tuesday. Three things I write about:

• Obsidian + AI workflows (how to make your second brain actually intelligent, like this post)

• AI agent patterns (what works, what breaks, what I’m shipping)

• AI for humans (how to bring AI into your team or your life without scaring people)

If you’re bringing AI into your work and you want to see what’s actually working in production from someone who ships it, subscribe. There’s a button somewhere obvious on this page.

Thanks for being here. I write for the people who build.

Eugeniu

Quick orientation. If you came here searching for Karpathy's original LLM Wiki gist, here it is: Karpathy’s original LLM Wiki gist. Bookmark it, it's still the cleanest starting point. What follows is the version I built on top of it, a second brain that rewrites itself, open-sourced so you can clone it: https://github.com/eugeniughelbur/obsidian-second-brain

TL;DR

• Karpathy’s LLM Wiki gist describes the right pattern but at the intent level: integrate new sources, lint periodically, treat the wiki as primary. It is a conceptual blueprint, not a runnable spec.

• The gap between the gist and a working system is in the mechanics: how integration handles contradictions, how lint runs without you asking, and who the wiki is actually written for.

• This rebuild fills in the spec on five axes: specified integration mechanics, automatic contradiction reconciliation, unsolicited synthesis, scheduled maintenance agents, and notes written for AI retrieval rather than human reading.

• The most contrarian of the five is the AI-First Vault Principle: notes designed so future-Claude can read them in 10 seconds, not so future-you can re-read them in 30 minutes. Karpathy’s gist treats the wiki as serving both humans and LLMs; this rebuild inverts that.

• The open-source implementation ships as a Claude Code skill with 31 slash commands and 4 scheduled agents.

What is Karpathy’s LLM Wiki pattern?

Karpathy’s LLM Wiki is a knowledge-base pattern published as a public gist in early 2026. You drop sources into a folder. An LLM reads them, extracts entities and concepts into wiki pages, and cross-references everything. Future questions are answered from the wiki, not from a fresh web search.

The full pattern lives in Karpathy’s gist. The core insight is correct and important: the wiki is the product, the chat is just the interface. Cross-references already exist. Synthesis already reflects everything that has been read. Knowledge compounds like interest, instead of being regenerated from scratch every time you open a chat.

This was the right starting point. It is also where most implementations stop. As of 2026-04, every public Karpathy-Wiki implementation I have reviewed (six on GitHub, two on Substack, one on dev.to) treats the original gist as a complete spec. None of them solve the problems that show up the moment your wiki crosses a few hundred sources.

Why a conceptual blueprint is not a working second brain

Karpathy's pattern is append-only by design. Every ingest creates new pages and adds cross-references; existing pages stay frozen. This works for the first 50 to 100 sources. Past that, three failure modes compound: claims go stale, contradictions accumulate faster than you resolve them, and the cross-reference graph becomes too dense to navigate manually.

A wiki built this way is essentially a logbook with internal links. It captures what you read, but it does not update what you previously believed. If you ingest a YouTube video about a person who has changed jobs, you get a new source page with the new fact, plus a backlink on the person's existing page. The person's page itself still describes them at their old job. Future-Claude reading the page sees both, has no way to know which is current, and gives you a hedged answer.

The fix is structural. A real second brain has to rewrite, reconcile, synthesize, schedule, and rewrite-for-AI. Five extensions. Below.

Five things a working second brain has to do that the original doesn't

1. Ingest has to rewrite, not just append

Real intelligence rewrites. When I ingest a YouTube video about someone already in my vault, the person’s page itself gets updated. Their startup status changes from “considering joining” to “joined in March 2026.” A thesis that was “speculation” becomes “confirmed.” The old version is preserved as a dated entry below, not deleted, but the live state of the page reflects the latest evidence.

This is the difference between a wiki that grows and a wiki that learns. Append-only knowledge bases get stale invisibly because nothing about reading them tells you that a fact is from 2024. Rewriting forces every page to carry the current best answer at the top.

2. Contradictions have to be resolved, not just flagged

Karpathy’s pattern flags contradictions during ingest. You resolve them manually. In a small wiki, that works. In a vault past a few hundred pages, contradictions accumulate faster than you have time to resolve. The wiki becomes internally inconsistent, and future-Claude pulling from it gets contradictory inputs and produces hedged outputs.

The fix is automatic reconciliation. A dedicated process scans the vault, finds claims that contradict each other across pages, and resolves them by source recency, source authority, and explicit confidence levels. The most recent, best-sourced, highest-confidence claim wins. The losing claim gets archived with an explanation of why it was superseded. The vault stays internally consistent without you babysitting it.

3. Patterns have to be surfaced without being asked

Karpathy’s wiki answers the questions you ask it. It cannot tell you about the patterns it has noticed and you have not. This is a massive missed opportunity. Half the value of a knowledge base is the LLM telling you “you have mentioned this idea seven times across five different notes and never named it. Here is what it is.”

A working second brain runs synthesis on its own. It scans the vault for unnamed recurring themes, hidden contradictions between people’s stated values and their actual decisions, and connections between projects that look unrelated. It writes synthesis pages without being prompted. The vault tells you what it has noticed about you.

4. Maintenance has to be scheduled, not on-demand

Karpathy’s pattern runs only when you prompt it. Every operation is on-demand. This means maintenance only happens when you remember it, which means it never happens. Vaults rot in silence.

The fix is scheduled agents. A nightly process closes out the day, files loose ideas, updates the daily note. A weekly process runs the full reconciliation pass and the synthesis pass. A health check finds orphaned notes, dead links, and pages that have gone stale. You wake up to a vault that has already done its homework, and you never run a maintenance command yourself.

5. Notes have to be written for AI, not for humans

This is the most contrarian point and the centerpiece of this article. Every personal-knowledge-management tradition (Zettelkasten, Building a Second Brain, evergreen notes) optimizes notes for human reading. Karpathy’s pattern follows this convention. Wiki pages look like Wikipedia articles, written in flowing prose, designed for a human to skim.

The premise is wrong. You do not read your own notes. The LLM does. So they should be optimized for LLM retrieval, not for human reading. This is the AI-First Vault Principle, and it is the single biggest unlock in this rebuild.

The AI-First Vault Principle

Notes designed for AI retrieval beat notes designed for human reading, in any vault where the LLM does most of the reading. Every note follows seven rules: a ## For future Claude preamble, machine-readable frontmatter, mandatory wikilinks, recency markers per external claim, source URLs preserved verbatim, confidence levels where applicable, and self-contained context so the note can be retrieved standalone.

---
type: person
name: "Andrej Karpathy"
date: 2026-04-29
tags: [ai-researcher, llm-wiki-pattern]
ai-first: true
confidence: high
---

## For future Claude
Andrej Karpathy is the originator of the LLM Wiki pattern, published as a public
gist in early 2026. He proposes that LLMs should maintain a living markdown wiki
as the primary knowledge artifact, not a vector store. Use this page as the
canonical reference when reasoning about the LLM Wiki pattern.

## Key claims
- The wiki is the product. Chat is the interface (as of 2026-02, karpathy gist).
- Knowledge should compound across sessions. Source: same.
- Cross-references should already exist when a question is asked. Source: same.

## Related
[[LLM Wiki Pattern]] · [[Obsidian Second Brain]] · [[Append vs Rewrite]]

This page is harder for a human to scan than a regular Wikipedia-style note. It is dramatically faster for an LLM to retrieve, parse, and reason over. The frontmatter tells the LLM what kind of note it is in three lines. The “For future Claude” preamble tells it whether to bother reading the rest in another three sentences. The recency markers tell it what to verify. The wikilinks tell it where to go next.

The inversion is uncomfortable for anyone who has invested in a beautiful Obsidian vault. It is also the only thing that makes a vault past a few hundred notes actually compound for an LLM-driven workflow. Once you stop pretending you will re-read your notes, you can write them in a way that compounds for the system that will.

Subscribe now

How this compares to Karpathy’s original and rohitg00’s v2

This rebuild is the third iteration of the public LLM Wiki pattern. Karpathy’s gist (2026-02) is v1: append-only ingest, manual lint, human-readable notes. rohitg00’s LLM Wiki v2 (2026-03) added confidence scoring, supersession of stale claims, and contradiction detection. This rebuild adds three things v2 still does not have: scheduled agents, automatic synthesis, and AI-first note structure.

None of the existing public implementations ship a working integration with Claude Code as a slash-command skill. None ship a real specification for AI-first notes. None ship scheduled agents. The repo behind this article does. It is open-source, MIT-licensed, and live on GitHub: eugeniughelbur/obsidian-second-brain.

## What I got wrong

When I first shipped `/research-deep` and ran it against my own vault, the command wrote 
three different kinds of garbage into the synthesis note. I had assigned the wrong 
Perplexity model to the synthesis call, so the API returned a hardcoded 10,000-word 
academic report instead of following the markdown structure I asked for. 
The reasoning model I switched to wrapped its internal deliberation 
in `<think>...</think>` blocks, and those tags ended up saved to the vault verbatim. 
And the frontmatter meant to log which queries had run was instead saving stringified 
Python dictionaries.

Three small bugs, but together they meant the command designed to make my vault smarter 
was making it dumber on its first run. I only caught it because I happened to test on a 
real topic in my own vault and actually read the output. If I had trusted the test less 
and the implementation more, the broken version would have shipped, and every other vault 
running the skill would have inherited the same junk.

The fix took an afternoon. The lesson took longer. **The right level of automation 
is not "everything always," it is "everything reversibly."** A second brain that 
rewrites itself is only valuable if you can see exactly what it changed and roll 
back when it gets it wrong. Every scheduled agent in this rebuild now logs its changes 
to a daily diff note and waits 24 hours before any change becomes permanent. 
The first version did not. That is the difference between a tool I trust on my own vault
and one I would never let near it.

The general lesson is that the right level of automation is not “everything always,” it is “everything reversibly.” A second brain that rewrites itself is only valuable if you can see what it changed and roll back when it gets it wrong. Every scheduled agent in this rebuild logs its changes to a daily diff note and waits 24 hours before any change becomes permanent.

Subscribe now

Frequently asked questions

What is the LLM Wiki pattern?

The LLM Wiki pattern is a knowledge-base architecture proposed by Andrej Karpathy in early 2026. You drop sources into a folder, an LLM reads them and writes wiki pages, cross-references entities, and answers future questions from the wiki rather than from fresh web searches. The wiki is a persistent artifact that compounds across sessions, instead of being regenerated each chat.

How is this different from RAG?

RAG retrieves chunks of source documents at query time and feeds them to an LLM as context. The LLM Wiki pattern flips this: an LLM reads sources once, distills them into structured wiki pages, and the wiki itself becomes the retrieval target. The result is faster, cheaper queries, plus cross-references that already exist instead of being inferred at query time. This rebuild adds write-back so the wiki stays current with new sources.

Do I need to know how to code to use this?

No. The implementation is a Claude Code skill that ships as 31 slash commands. You install it once with a shell script, then operate it with commands like /obsidian-save and /obsidian-ingest from any Claude Code session. The vault is plain markdown, so Obsidian works on top of it natively.

Will this break my existing Obsidian vault?

No. The skill never deletes or modifies notes destructively without explicit confirmation. Existing notes are left untouched. New notes follow the AI-First Vault Principle. A health-check command flags pre-AI-first notes so you can update them on your own schedule. Every scheduled agent writes to a daily diff log so you can see what changed overnight and revert if needed.

Does it work without Claude?

The current implementation is built for Claude Code, but the AI-First Vault Principle and the slash-command interface are portable. The vault format is plain markdown with YAML frontmatter, so the underlying knowledge base is model-agnostic. As of 2026-04 the production-tested integration is Claude Code only.

What does it cost to run?

The 26 vault commands work without any API keys: only your Claude Code subscription is required. The 5 research commands require API keys for xAI Grok and Perplexity. Approximate per-call costs as of 2026-04: /x-read around $0.05, /x-pulse around $0.13, /research around $0.04, /research-deep around $0.40 to $0.80, /youtube around $0.04.

Key takeaways

• Karpathy’s LLM Wiki pattern is a brilliant foundation. The wiki is the product, chat is the interface, knowledge compounds across sessions.

• Append-only ingest fails past a few hundred sources. Stale claims, unresolved contradictions, and missed patterns accumulate invisibly.

• The five extensions that turn a Karpathy-style wiki into a working second brain are write-back, reconciliation, unsolicited synthesis, scheduled agents, and AI-first notes.

• The AI-First Vault Principle is the most important of the five. Notes designed for AI retrieval beat notes designed for human reading in any vault where the LLM does most of the reading.

• Automation has to be reversible. Every scheduled agent in this rebuild writes a diff log and waits 24 hours before any change becomes permanent.

• The open-source implementation is live on GitHub and runs as a Claude Code skill with 31 slash commands. Install in two minutes.

If Karpathy’s LLM Wiki is a knowledge base you maintain with an LLM, this rebuild is a knowledge base that maintains itself.

Further reading

• Karpathy’s original LLM Wiki gist (2026-02): the canonical pattern.

• rohitg00’s LLM Wiki v2 gist (2026-03): adds confidence and supersession.

• Penfield Labs on what’s missing from Karpathy’s wiki: typed-link extension.

• Andy Matuschak on evergreen notes: the human-first PKM tradition this rebuild departs from.

• obsidian-second-brain on GitHub: the open-source implementation.

About the author

Eugeniu Ghelbur is an AI Automation Engineer at Single Grain, where he builds production AI systems for marketing and sales workflows. He ships open-source Claude Code skills and writes about AI knowledge management at ghelburlabs.substack.com. The obsidian-second-brain skill described in this article is live on GitHub at github.com/eugeniughelbur/obsidian-second-brain and has been used in production since 2026-03.

Every productive person I know writes lessons down. “Don’t sign one-year contracts without exit clauses.” “Always run migrations on a staging copy first.” “When a client goes silent for two weeks, escalate to email.”

Then they make the same mistake six months later.

The lessons aren’t lost. They’re just buried in daily notes, dev logs, and meeting recaps that nobody opens again. The wisdom rots in place.

The problem with second brains

Most note-taking advice ends at “write it down.” But writing is the easy part. The hard part is keeping the lessons alive — surfaced, reviewed, applied.

Without that step, your second brain becomes a graveyard. The more you write, the worse it gets. Important rules get drowned by daily noise. The lesson you needed yesterday was logged eight months ago, three folders deep, with no link pulling it forward.

The fix: a command that reviews your wisdom

I just shipped /obsidian-learn in my open-source Claude Code skill. It does one thing: scans your entire vault for lessons and decides which ones still matter.

Five places it looks:

• “Lesson learned” sections in daily notes

• Architectural Decision Records (ADRs)

• Pattern reports from previous reviews

• Failure-learning phrases — “next time”, “don’t do this”, “wasted time on”

• Recurring success patterns — things that worked twice or more

Then it classifies each lesson:

Active — still applies, reinforced by something recent. Keep it.

Stale — six months old, no recent reinforcement. Archive or convert to history.

Superseded — explicitly replaced by a newer decision. Acknowledge the evolution.

Promotable — appeared three or more times across your vault. This is now a permanent rule. The command suggests exact wording to add to your operating manual.

What this does in practice

Run /obsidian-learn weekly. Get a report:

Top 5 Lessons of the Period

1. “Always verify live state before patching from memory” — 4 reinforcements. Promote to permanent rule.

2. “Never re-run destructive wizards” — reinforced after a recent incident.

3. “Talk to one named user before designing the system” — corrected twice.

4. “Pre-written decline scripts beat willpower” — recurring pattern across multiple weeks.

5. “If the side project competes with the day job for content, the side project dies” — emerged from cross-domain synthesis.

Promote the top ones into your operating manual. Now every AI session you start, on any device, opens with these rules already loaded. The wisdom you earned compounds.

Why this matters

The next decade’s competitive edge isn’t access to AI models. Everyone will have that. The edge is the corpus the model works from — your years of decisions, lessons, and patterns, organized so they actually surface when relevant.

A vault that doesn’t review itself is just a filing cabinet with extra steps. A vault that promotes its own lessons into rules becomes a personal operating system that gets sharper every quarter.

This is the latest release of obsidian-second-brain — a Claude Code skill that turns your Obsidian vault into a living knowledge base. 26 commands now. Self-rewriting ingest, thinking tools that argue with you using your own history, scheduled agents that maintain the vault while you sleep, and now a command that compounds your wisdom instead of letting it rot.

Inspired by Garry Tan’s gstack /learn pattern. Open source. MIT licensed.

github.com/eugeniughelbur/obsidian-second-brain

Not metaphorically. I told Claude I wanted to move our database from Railway to Supabase. It searched my vault, found my own notes from six months ago where I evaluated Supabase and decided against it because of cold start latency on serverless functions killing our API response times, found my decision log where I wrote “keep everything on Railway: one platform, one bill, no vendor juggling,” and pushed back with my own words.

That moment changed how I think about AI.

Here’s the backstory.

I use Obsidian for everything. Daily notes, project tracking, people notes, decisions, ideas. Hundreds of markdown files going back years. But they were dead files. I’d write something, forget it existed, and make the same mistake six months later.

Meanwhile, every Claude session started from zero. “Hi, I’m working on X, the context is Y, the goal is Z.” Every. Single. Time.

So I built a Claude Code skill that connects the two. Claude reads my vault, writes to it, and thinks with it.

The architecture is simple:

┌──────────────┐
│  You talk    │
│  Claude saves│ ── Layer 1: Vault Ops
│  to the vault│    14 commands
└──────┬───────┘
       │
┌──────▼───────┐
│  Your vault  │
│  argues back │ ── Layer 2: Thinking
│  challenges  │    4 commands
│  finds       │
│  patterns    │
└──────┬───────┘
       │
┌──────▼───────┐
│  Claude knows│
│  who you are │ ── Layer 3: Context
│  every time  │    1 command
└──────────────┘

Layer 1 is the boring part that saves you hours.

You finish a conversation and type /obsidian-save. Claude scans the entire chat, pulls out decisions, tasks, people mentioned, and ideas discussed, and saves each one to the right place in your vault. Project notes get updated. Kanban boards get new cards. Today’s daily note gets links to everything. You do nothing.

14 commands handle every vault operation. Daily notes, dev logs, people notes, project tracking, idea capture, weekly reviews, vault health checks. All of them search before creating. No duplicates. Every write propagates everywhere it belongs.

Layer 2 is what makes it different.

/obsidian-challenge red-teams your current idea against your own history. It spawns three parallel agents that search your vault for past failures, contradictions, and reversed decisions. Then it presents the evidence and asks if you still want to proceed.

/obsidian-emerge scans your last 30 days of daily notes and surfaces patterns you haven’t named. I ran it last week. It found I’d mentioned “onboarding friction” in four separate client projects without ever calling it a systemic problem. It was. I just couldn’t see it from inside.

/obsidian-connect takes two unrelated domains from your vault and finds the bridge between them. Shared concepts, structural analogies, collision ideas. The output is grounded in your own notes, not generic brainstorming.

/obsidian-graduate takes an idea fragment tagged #idea and turns it into a full project. Spec, goals, tasks, board entries. The idea note gets marked as graduated and linked to the new project. Nothing dies in your inbox.

Layer 3 solves context loss.

One command: /obsidian-world. Run it at the start of any session. Claude reads your identity file, checks your last three daily notes, scans your boards, and tells you where you left off. No re-explaining. No memory issues. Full context in ten seconds.

Then there’s the stuff that runs without you.

A background agent fires after every context compaction. It reads the session summary and silently updates your vault while you keep working.

Four scheduled agents run on cron:

8 AM  ── Morning agent
         Creates daily note
         Surfaces overdue tasks

10 PM ── Nightly agent
         Closes out the day
         Moves tasks to Done

Fri   ── Weekly agent
         Generates review note

Sun   ── Health check agent
         Audits for rot

You wake up to a daily note that already knows what’s overdue. You go to bed and your vault closes itself out.

The whole thing runs on one file: _CLAUDE.md. It sits at your vault root and tells every Claude surface how your vault works. Folder structure, naming rules, frontmatter schemas, and propagation rules. Claude Desktop, Claude Code, VS Code, terminal. They all read the same file. No memory needed between sessions.

git clone https://github.com/eugeniughelbur/obsidian-second-brain ~/.claude/skills/obsidian-second-brain
bash scripts/setup.sh "/path/to/vault"

Run /obsidian-init and Claude generates your _CLAUDE.md from your existing vault structure.

The uncomfortable truth: the AI is not the moat. Your notes are.

Everyone will have access to the same models. The differentiator is having years of interlinked personal writing for the model to work with. Daily reflection, decisions logged, lessons captured. That compounds. Generic prompts don’t.

99% of people will read this and think “cool” and keep using Claude as a search engine. That’s fine.

The 1% who actually build a vault, write daily, and let the system compound will have something no one can copy. A thinking partner trained on their own history.

The repo: https://github.com/eugeniughelbur/obsidian-second-brain

No company became 10x more valuable as a result.

So where did the productivity go?

I’ve been sitting with this question for weeks, building AI systems at a digital marketing agency - and I think I finally understand why most of what we call “AI adoption” is theater.

The electricity mistake, repeated

In the 1890s, New England textile mills replaced their steam engines with electric motors. Faster, cleaner, more powerful. The technology was unambiguously better.

For thirty years, productivity barely moved.

It wasn’t until the 1920s — when factories threw out the old layout entirely and rebuilt around electricity from the ground up, with assembly lines, individual motors inside every machine, and workers doing completely different jobs — that the gains arrived.

The technology was never the bottleneck. The organization was.

George Sivulka, CEO of Hebbia and a16z partner, wrote a piece this week arguing we’re making the same mistake with AI right now. We’ve swapped the motor. We have not redesigned the factory.

I think he’s right. And I think most of us can feel it, even if we haven’t named it yet.

The difference no one talks about

There are two kinds of AI being built right now.

Individual AI makes you faster. It’s the ChatGPT tab, the AI writing assistant, the personal productivity setup someone posts about on Slack to show they’re keeping up. It benefits one person. It stops when that person stops prompting.

Institutional AI makes the organization different. It runs whether anyone opens a laptop or not. It routes information to the right people. It surfaces the one real signal in a mountain of noise. It asks a human to approve something, then acts. It’s load-bearing — turning it off would actually hurt the business.

The gap between these two is enormous. And almost everything marketed as “AI transformation” is actually just Individual AI with a better pitch deck.

What this looks like in practice

Here’s the test I use:

Does it run without anyone asking it to?

If someone has to open it, prompt it, or click generate — it’s Individual AI. Feels productive. Moves nothing.

If it wakes up at 7am, scans your pipeline, surfaces the three deals most likely to close this week, and posts them to Slack before your team’s first coffee — that’s Institutional AI. It’s a thing your organization depends on, not a tool someone chose to use today.

Does the output land where the team already is?

A dashboard requires people to remember to check it. Slack is where they already are. The difference between a dashboard and a Slack message isn’t just UX — it’s whether the insight actually reaches the person who needs to act on it.

Does it produce a number?

Not “it saves time.” Not “it’s more efficient.” A number. Pipeline recovered. Meetings booked. Churn risks flagged before they became churned clients. If you can’t say the number, the system isn’t institutional yet.

The coordination problem nobody’s solving

Sivulka’s most striking point is about coordination.

Imagine doubling your team’s headcount tomorrow with clones of your best people. Each one is individually excellent. None of them have shared context, defined responsibilities, or outputs that connect to each other.

You haven’t made your organization better. You’ve created chaos with better-dressed chaos.

This is exactly what’s happening in every company that gave everyone a ChatGPT subscription and called it an AI strategy. Everyone has their own prompts. Their own outputs. Their own version of what the AI should be doing. Nothing connects to anything else.

Institutional AI requires a coordination layer. Defined roles for each agent. Outputs that feed into other agents or into human decision-making. A shared infrastructure everyone builds on, not a hundred individual setups that happen to be in the same building.

Why this matters now

The companies building Institutional AI aren’t just more productive — they’re building something that compounds.

Every process encoded in an agent is institutional memory that survives turnover. Every workflow that runs without being triggered is leverage that doesn’t require more headcount. Every approval loop that keeps a human in the decision without slowing down the work is a way to move faster without moving recklessly.

The companies still in the Individual AI phase are getting the feeling of progress without the substance of it. Their people are faster. Their organization is the same.

We’re in the 1900s equivalent right now — we’ve plugged in the electric motors. The factories that win the next decade will be the ones that tear out the old layout and rebuild around what the technology actually enables.

The question isn’t whether your people are using AI.

It’s whether your organization is.

Update, 2026: The AI Operator has narrowed its focus to AI and building with AI in production. This post is from before that shift. If that’s what you’re here for, start with I rebuilt Karpathy’s LLM Wiki, I built this for myself. Then 1,374 strangers cloned it., or what The AI Operator is now.

The News (January 28, 2026)

Apple has given Patreon an ultimatum: **by November 1, 2026**, all creators must switch to Apple’s in-app purchase system — or Patreon gets kicked from the App Store.

What does this mean in practice?

- **Apple takes 30%** of every subscription (15% after year one)

- Creators must either **raise prices** for iOS users, or **eat the fee** themselves

- 96% of Patreon creators have already switched; the remaining 4% have 9 months

This isn’t new — Apple announced this in 2024. But the deadline just got real.

Why This Matters for the Creator Economy

Last year, I wrote about where creator economy money actually moves. The takeaway? Platforms extract, creators create.

This Apple-Patreon situation is a perfect case study:

The Math of the “Apple Tax”

Let’s say you’re a Patreon creator earning $10,000/month from 500 supporters at $20 each.

Before (Patreon’s cut: ~8-12%):

- You keep: ~$8,800/month

After (Apple’s cut: 30% year 1, 15% after):

- Year 1: You keep ~$6,200/month (or raise prices and lose subscribers)

- Year 2+: You keep ~$7,500/month

That’s $2,600/month gone in Year 1 — straight to Apple, for processing a transaction.

The Three Options Creators Now Have

1. Raise iOS prices by 30% — Risk: Subscribers churn

2. Absorb the fee yourself — Risk: Income drops significantly

3. Push users to subscribe via web — Risk: Friction = fewer conversions

None of these is good. All of them shift the burden to creators or fans.

Subscribe now

The Bigger Picture: Platform Dependency is the Real Problem

This isn’t about Apple being evil. Apple built iOS. Apple owns the App Store. Apple makes the rules.

The real lesson? **If you build on rented land, you play by the landlord’s rules.**

Patreon creators didn’t choose to be in this position. But they’re now learning what every creator eventually learns:

> Every platform is a partner until it’s a parasite.

YouTube’s algorithm changes. Instagram’s reach collapses. TikTok’s potential ban. And now, Apple’s 30% toll booth.

Subscribe now

What Smart Creators Should Do Now

If you’re building a creator business in 2026, here’s the playbook:

1. Own Your Audience

- Build an email list (Substack, Beehiiv, ConvertKit)

- Your email list is the only audience you truly own

2. Diversify Revenue Streams

- Don’t rely on one platform for >50% of income

- Mix: Subscriptions + courses + consulting + sponsorships

3. Push Direct Relationships

- Sell on your own website (Gumroad, Stripe, etc.)

- Apple can’t tax what doesn’t go through the App Store

4. Stay Mobile

- If Patreon becomes untenable, have a migration plan

- Your content + your audience should be portable

The Bottom Line

Apple’s Patreon move isn’t surprising — it’s inevitable when one company controls the rails.

The question isn’t “Is this fair?” The question is: **How do you build a creator business that doesn’t depend on anyone’s permission?**

The answer: Own your distribution. Own your audience. Own your revenue.

The 30% tax isn’t a bug. It’s a feature of a system designed to extract value from the people who create it.

What do you think? Are you a Patreon creator affected by this? How are you adapting? Reply and let me know.

If you found this valuable, share it with a creator friend who needs to hear it.

Ever feel like AI is evolving so quickly that traditional coding is giving way to something more intuitive? I’m right there with you—constantly experimenting with new ways to build without getting bogged down in syntax. As we head into 2026, discussions on Reddit are buzzing about the shift from rigid programming to vibe coding and Claude code: describing intents naturally to automate workflows and ship results. From high-upvote threads in r/vibecoding emphasizing capability overhang in AI tools to r/ChatGPTCoding ranting on vibe coding’s pitfalls, the consensus is clear: the real edge comes from skills that let you vibe code with Claude for practical wins.

Drawing from fresh insights across platforms, I’ve pulled together 10 key AI automation trends that stand out. These aren’t just buzzwords—they’re actionable areas where I’m pushing myself to experiment, like using Claude to vibe code agent chains by describing “build a system where one researches trends, another summarizes.” Whether you’re automating marketing tasks or building custom tools, mastering these can help you go from curious learner to efficient shipper. Let’s dive in and explore how to apply them, with tips from real conversations to get you started.

The Rise of Vibe Coding in AI Automation

Vibe coding is exploding as a trend, allowing natural descriptions to generate code without syntax mastery. Reddit experts call it “hot garbage” for killing assisted coding but acknowledge its productivity link. Others debate its future, noting AI’s jankiness but potential in 6-12 months. I’m experimenting with vibe coding daily—describing “optimize this workflow for speed” to Claude, and it’s slashed my build time. The key? It’s shifting from memorization to intent-driven development.

• Start with basics: Describe simple tasks to Claude, then refine with “add step-by-step reasoning.”

• Experiment iteratively: Test variations by describing changes and track results.

• Bias to action: Build a vibe library—I’ve got one for automation hooks that saves hours.

• Integrate with flows: Combine with Claude-described agents for end-to-end processes.

• Measure impact: Focus on outputs that solve problems, not just clever descriptions.

Subscribe now

Claude Code’s Role in Streamlining Automation

Claude code is trending for its ability to turn vibes into functional builds. Experts share stories of using Claude for apps generating revenue link. Discussions touch on its impact on tech jobs, with users vibe coding full products. I’m leveling up by describing “connect APIs for social pipelines” to Claude—turning ideas into magic without drudgery. It’s about leveraging Claude to handle repetitive tasks, freeing you for creativity.

• Choose your approach: Start with Claude-vibed basics, describe custom logic.

• Map processes: Identify bottlenecks like email sorting, and vibe code solutions step-by-step with Claude.

• Test scalability: Describe pilots to Claude for overnight trust.

• Add triggers: Vibe events like new data to kick off flows.

• Optimize loops: Describe feedback for refinements.

Agentic Evolution in Vibe Coding

Agentic AI is a game-changer, evolving tools to autonomous teammates. Experts debate AI’s code limits but note vibe coding’s potential link. Predictions highlight overhang in capabilities. I’m pushing boundaries by vibe coding multi-agents with Claude: “One researches, another summarizes”—like a mini team. The buzz is on goal-driven systems that self-correct.

• Frameworks first: Describe agent interactions to Claude.

• Define goals: Set clear objectives like research automation.

• Tool integration: Vibe API connections.

• Handle errors: Describe self-correction loops.

• Scale small: Start single, describe multi-systems.

Subscribe now

Capability Overhang in Coding AI

Capability overhang is hot, with AI tools underutilized due to interfaces. Experts explore this in coding AI link. I’m integrating by vibe coding with Claude: “Pull from notes for summaries”—unlocking hidden potential. It’s transforming models into powerhouses.

• Set up: Vibe databases for retrieval.

• Query: Describe combinations for pulls.

• Hygiene: Vibe maintenance for accuracy.

• Test: Describe edge cases.

• Action: Use for report generation.

Fine-Tuning for Tailored Vibe Builds

Fine-tuning customizes for niche needs. Experts discuss vibe coding’s traps but praise Claude for tweaks link. I’m experimenting by vibe coding: “Setup for fine-tuning”—training assistants. Trend toward bespoke over generic.

• Platforms: Vibe on APIs with Claude.

• Prep: Describe datasets.

• Metrics: Vibe evals for specificity.

• Iterate: Retrain via descriptions.

• Deploy: Vibe integrations.

Multimodal Vibe for Versatile Automation

Multimodal handles text/images seamlessly. Experts critique Google ‘vibe coding’ but note limitations link. I’m diving by vibe coding: “Analyze visuals”—actionable insights. Expanding reach beyond words.

• Models: Vibe for mixed APIs.

• Cases: Describe video summaries.

• Combine: Vibe richer outputs.

• Safe: Test biases via descriptions.

• Projects: Vibe image searches.

Scaling Visuals with Claude Code

Video gen scales content. Experts share revenue from Claude-coded apps link. I’m testing by vibe coding: “Repurpose to clips”—boosting engagement.

• Tools: Vibe scripts.

• Script: Describe narratives.

• Edit: Vibe pacing.

• Automate: Vibe integrations.

• Measure: Track to refine.

  ---

Stacking for Leverage in Vibe Coding

Stacking creates ecosystems. Experts debate vibecoders vs developers link. I’m stacking by vibe coding: “Data flow integrations”—multiplied productivity.

• Synergies: Describe pairings.

• Custom: Vibe setups.

• Avoid: Choose interoperable.

• Test: Vibe handoffs.

• Scale: Describe growth.

Evaluating for Reliability

Evaluating ensures quality. Experts warn vibe coding traps link. I’m using Claude to vibe evaluations—catching issues.

• Tools: Describe tracking.

• Metrics: Vibe assessments.

• Versions: Iterate descriptions.

• Costs: Vibe optimizations.

• Loop: Describe improvements.

Intent-Driven Vibe Development

Vibe coding describes intents. Experts question AI code but see potential link. I’m trying Claude for quick builds—focusing on what.

• Platforms: Claude for vibe.

• Problems: Let AI syntax.

• Review: Describe checks.

• Faster: Vibe prototypes.

• Learn: Vibe for building.

Wrapping this up, these 10 trends—from vibe coding to intent-driven builds—are the ones sparking real buzz on Reddit for 2026. Experimenting has pushed my automations forward, turning ideas into systems. Key takeaway? Relentless action: pick one, vibe something small, iterate. As these become bottlenecks, shippers lead.

Ready to level up?

Subscribe now

Subscribe for more deep dives on AI experiments, comment on the trend you’re tackling first, or vibe code one task with Claude today! Check out my latest build on X for inspiration: Eugeniu Ghelbur on X

Eugeniu Ghelbur – Relentless learner automating my way through AI. Follow on X @eugeniu_ghelbur and on LinkedIn

That seamless tap-to-pay on your phone, the silent acceleration of an electric car, the very screen you’re reading this on—they all share a hidden, powerful secret. The magic of modern technology isn’t just in the code or the cloud; it’s forged from materials pulled from the Earth. With global electric car sales surpassing 17 million in 2024, the demand for these ingredients is exploding.

These are critical minerals: the essential, often unseen, building blocks driving our digital lives and the global transition to green energy. And right now, a high-stakes global race is underway to control them.

What Are Critical Minerals and Why Do They Matter?

In simple terms, critical minerals are raw materials essential for clean energy technologies and the modern economy, but whose supply chains are vulnerable to disruption. Their importance is skyrocketing for a few key reasons:

• The Clean Energy Boom: The single largest driver of demand growth is the clean energy sector. The rapid deployment of batteries for EVs and energy storage is fueling an unprecedented need for lithium, graphite, nickel, and cobalt.

• Powering Electrification: The expansion of electricity grids and the widespread electrification of equipment are creating massive demand for copper, the workhorse of electrical wiring.

• Advanced Magnets: The powerful, high-performance permanent magnets required for EV motors and wind turbines are boosting demand for a special class of materials known as rare earth elements.

As the world shifts toward a “more electrified, renewables-rich energy system,” these minerals have become a frontline issue for global energy and economic security. Let’s meet the key players in this new global competition.

Subscribe now

Meet the Stars: Key Minerals Powering Our World

While dozens of minerals are considered critical, a handful stand out for their central role in shaping our technological future.

Copper: The Circulatory System of Electrification

Often called “Dr. Copper” for its ability to gauge economic health, this metal is a critical component for electricity due to its high conductivity, durability, and affordability.

• Power Grids & Wiring: It is the fundamental material used in the vast infrastructure that delivers electricity to homes, businesses, and charging stations.

• Electric Vehicles (EVs) & Wind Power: Copper is used extensively in the wiring, motors, and components of these cornerstone green technologies.

• AI and Data Centers: Its importance is growing rapidly in the infrastructure for Artificial Intelligence, which has significantly higher power and cooling requirements. Copper use in data centers alone could account for 1-2% of global demand by 2030.

Lithium: The Heart of the Battery Revolution

Lithium is the lightweight, energy-dense metal at the center of the battery revolution. Demand is projected to grow fivefold between today and 2040.

The vast majority of this growth is driven by the EV sector and grid-scale energy storage. Due to its immense battery manufacturing capacity, China currently represents over three-quarters of global lithium demand.

Rare Earth Elements (REEs): The Super-Magnets That Spin the Green Revolution

Despite their name, Rare Earth Elements aren’t all that rare. They are a group of 17 metals crucial for producing the world’s strongest high-performance permanent magnets.

These magnets are essential components in the motors of most EVs and the generators of modern wind turbines. China is the dominant player in this space, accounting for around 57% of global demand for magnet REEs in 2024 and producing 94% of the world’s most common high-performance magnets (sintered NdFeB magnets).

Nickel & Cobalt: The Energy-Density Duo: Powering Longer Ranges

Nickel and cobalt are key ingredients in the high-performance, nickel-rich batteries—like Nickel-Manganese-Cobalt (NMC) cathodes—used in many long-range EVs.

In 2024, energy technologies made up almost 20% of total nickel demand. That share is projected to more than double, rising to over 40% by 2040.

Graphite: The Stable Foundation of Every Battery

Graphite is the essential, workhorse material for the negative end (the anode) of nearly all lithium-ion batteries. If lithium ions are the workers carrying energy, the graphite anode is the factory floor where they safely clock in and out during charging and discharging.

Demand for graphite is projected to double by 2040. It comes in two forms: natural (mined) and synthetic. China currently controls nearly all global production of synthetic graphite.

These minerals are the foundation of our future, but the journey of these materials from deep in the earth to the palm of your hand is fraught with geopolitical risk.

Subscribe now

The Global Challenge: Where Do These Minerals Come From?

While the demand for critical minerals is global, their supply chains are the central conflict in this race. The primary challenge is extreme geographic concentration. This level of concentration is like the entire world’s food supply depending on just one or two countries for all its wheat and corn—a disruption in one place creates a crisis everywhere.

• 1. Highly Concentrated Mining: A few countries dominate the world’s mining output. Between 2020 and 2024, the market share of the top three mining countries rose from 73% to 77%.

Mineral: Cobalt
Democratic Republic of the Congo (DRC)

Mineral: Nickel
Dominant Mining Country/Countries: Indonesia

Mineral: Graphite & Rare Earths
Dominant Mining Country/Countries: China

• 2. Even More Concentrated Refining: The processing of raw ores into high-purity materials is even more concentrated than mining. This dominance in refining isn’t accidental; it’s the result of decades of focused industrial strategy, creating a critical chokepoint in the global supply chain. Between 2020 and 2024, the average market share of the top three refining nations climbed from 82% to 86%.

◦ China is the undisputed global leader. It produces:

▪ Over 95% of the world’s battery-grade graphite and rare earths.

▪ 70% of the world’s lithium chemicals.

This concentration creates significant risk. China has implemented export controls on materials like graphite and REEs, and the DRC suspended cobalt exports in early 2025, highlighting how quickly access can be disrupted. In response, a global race to the finish line is underway.

Subscribe now

The Race for a Secure Future: Innovation and Diversification

Recognizing these vulnerabilities, governments and companies worldwide are racing to build more resilient and diverse supply chains. The key strategies fall into three main categories:

1. Diversifying the Supply Chain: Governments in the United States, European Union, Canada, and Australia have launched major funding programs and policies, like the EU’s Critical Raw Materials Act, to support new mining and refining projects and secure reliable supplies from allied nations.

2. Unlocking New Technologies: Innovation is a powerful tool for unlocking new, more sustainable sources of critical minerals.

◦ Direct Lithium Extraction (DLE): This technology can extract lithium more efficiently from new sources like geothermal brines, potentially boosting production in North America and Europe.

◦ AI-Based Exploration: Using artificial intelligence to analyze geological data can dramatically improve the success rate of finding new mineral deposits while reducing exploration costs.

◦ Advanced Recycling: New “short-loop” processes are being developed to recover valuable materials, like REEs from permanent magnets in scrapped EV motors and wind turbines, with a significantly lower environmental footprint than primary mining.

3. Innovating in Battery Chemistry: The market is adapting by developing new technologies that rely on more abundant materials. The explosive growth of Lithium Iron Phosphate (LFP) batteries is a powerful example of the market’s response to geopolitical risk—by innovating away from the most concentrated and volatile supply chains for nickel and cobalt, automakers are effectively voting for supply security with their battery chemistry. By 2024, LFP batteries already supplied almost half the global EV battery market.

Subscribe now

Conclusion: The Materials That Will Shape Tomorrow

The clean energy transition and the future of technology are not just ideas; they are being built, ounce by ounce, from these critical minerals. As demand skyrockets, the tension between this urgent need and the fragile, geopolitically charged reality of their supply chains has ignited one of the most defining challenges of the 21st century.

This is more than a contest for resources—it is a high-stakes race that will reshape global alliances, drive a wave of technological innovation, and define the economic and political landscape for decades to come. The next time you pick up your device, remember the immense global competition humming just beneath its surface, powering the world in your hands.

The engine of artificial intelligence is threatening to overheat our planet. The massive data centers that power the AI boom are consuming electricity at a staggering rate, with projections suggesting they could account for up to 9% of total U.S. electricity consumption by 2030. This relentless demand is creating an urgent infrastructure crisis, straining our power grids, land, and water resources.

In response, technology giants are pursuing a solution that sounds like science fiction but is now a strategic imperative: moving data centers into orbit. This is not a unified effort, but a competitive race with distinct strategies. SpaceX is focused on volume and velocity, aiming to launch vast low-Earth orbit (LEO) networks. Google is targeting specialized, high-performance AI training with its custom hardware. And Blue Origin is positioning itself as a foundational orbital utility provider, building the infrastructure to host this new ecosystem in geostationary orbit (GEO). This article reveals five of the most surprising realities behind this monumental undertaking to build AI’s mandatory next-generation infrastructure in space.

AI’s Thirst for Power Is Forcing an Off-World Migration

It’s Not Science Fiction, It’s an Energy Crisis

The primary motivation for building orbital data centers is not innovation for its own sake, but sheer necessity. The current trajectory of terrestrial AI compute is unsustainable. By moving this infrastructure off-world, we sidestep these limitations and gain access to the single greatest advantage of space: virtually unlimited and highly efficient solar power.

In an optimized “dawn-dusk” orbit, a solar panel receives near-constant sunlight, allowing it to be up to eight times more productive than an equivalent panel on Earth. This eliminates concerns over cloud cover, atmospheric scattering, and day/night cycles, providing the sustained, high-density power required for massive AI model training. As Google CEO Sundar Pichai articulated in a widely cited analysis:

“When you truly step back and envision the amount of compute we’re going to need, it starts making sense and it’s a matter of time.”

But harnessing this limitless power is meaningless without solving the fundamental physics problem of shedding the immense heat it generates in a vacuum.

Subscribe now

The Vacuum of Space is an Engineering Paradox

The Biggest Challenge Isn’t Heat, It’s Getting Rid of It

One of the most counter-intuitive challenges of orbital computing is thermal management. While the deep cold of space acts as an ultimate heat sink, the vacuum that makes it so cold also prevents heat transfer via convection—the method used by fans and air conditioning on Earth. Without air, the entire thermal control system must rely on conduction to move heat and radiation to reject it into space.

This physical limitation is the defining technical constraint that dictates the entire architecture of an orbital data center. To dissipate the immense heat generated by power-dense AI chips, these facilities must be equipped with massive radiator surfaces. These passive thermal systems often use sophisticated Constant Conductance Heat Pipes embedded within Honeycomb Radiator Panels, which offer an “ideal combination of ultra-low mass, structural integrity and high thermal performance”—all critical in space. The sheer scale of the heat rejection systems needed to cool a gigawatt-scale facility leads directly to the next reality: these structures are simply too big to launch in one piece.

These Giants Won’t Be Launched, They’ll Be Built by Robots in Orbit

Orbital Data Centers Are Too Big for Any Rocket

The gigawatt-scale ambitions for orbital computing mean the final structures will be physically massive—far too large to fit inside the fairing of any existing rocket. The only viable solution is On-Orbit Assembly (OOA).

Orbital data centers will be constructed in space from smaller, modular, and mass-producible components launched on successive missions. These units, sometimes called “satlets”—like the Hyper-Integrated Satlets (HISats) from the DARPA Phoenix program—will be pieced together not by astronauts, but by semi-autonomous robotics. A prime example of this technology is the SSL Dragonfly concept, which uses a highly dexterous robotic arm to assemble satellite components. This marks a fundamental shift away from treating orbital assets as disposable, monolithic satellites and toward building them as adaptable, upgradable infrastructure designed to last for decades.

Subscribe now

The Entire Vision Relies on a Single Breakthrough

The Whole Idea is Economically Impossible Without SpaceX’s Starship

The technical marvels of orbital data centers are irrelevant if the economics don’t work. The financial viability of this entire concept hinges on a radical reduction in the cost to launch materials into space.

According to economic analyses, the price to launch a kilogram to low-Earth orbit must fall to around 200 per kilogram for orbital facilities to become cost-competitive with their terrestrial counterparts. To put that in context, achieving this price point is almost entirely dependent on the success of fully and rapidly reusable heavy-lift launch vehicles, SpaceX′s Starship. The economic models become even more compelling when you consider the endgame: with full reusability, Starship′s theoretical internal costs could plummet to below 15 per kilogram. This single data point makes the $200/kg target seem not just possible, but highly plausible, while also underscoring how the future of a multi-billion-dollar industry rests on one company’s rocket program.

Subscribe now

A Stray Cosmic Ray Could Sabotage an AI’s Training

The Invisible Threat of a “Bit Flip”

Beyond the visible challenges of launch and cooling, orbital data centers face a constant, invisible threat: space radiation. High-energy particles can cause a “Single Event Effect” (SEE), or “bit flip,” where a single bit of data in a processor or memory spontaneously flips from a 0 to a 1. This is a critical distinction when comparing AI inference (running a finished model) and AI training (building a new one).

A bit flip during inference is like a single typo in a finished book—annoying, but isolated. A bit flip during training is like a typo in the printing press itself, corrupting every subsequent copy. An unnoticed calculation error could silently corrupt a multi-million dollar AI model and compromise the integrity of the entire training run. While Google’s TPUs have proven resilient to the total ionizing dose (cumulative damage over time), they are still vulnerable to these spontaneous Single Event Effects. This makes robust, real-time error correction an absolute necessity for operating in orbit.

Subscribe now

The Dawn of Orbital Computing

Moving AI to space is not a choice, but a strategic imperative driven by the hard physical constraints of an energy-hungry digital world. This monumental leap requires radical new approaches that represent the grand engineering challenges of our time, from the physics of vacuum cooling to the microscopic threat of a cosmic ray. The promise is a truly scalable and sustainable future for artificial intelligence, built on adaptable infrastructure that will last for decades.

As we push our digital infrastructure beyond the atmosphere, we must ask a fundamental question: Are we creating the ultimate sustainable solution for AI, or are we simply exporting our insatiable demand for energy to the final frontier?

Rapid Adoption: Small and medium-sized businesses (SMBs) are integrating AI at an unprecedented rate, with adoption figures soaring to nearly 90% in some sectors, driven by accessible cloud-based tools and the undeniable competitive advantage they offer.
Transformative Benefits: AI is delivering substantial productivity gains, ranging from 29% to a remarkable 133%, alongside significant cost reductions and a projected 20% increase in revenue for early adopters. This shift is freeing up valuable human capital for strategic work.
Strategic Imperative: Beyond mere efficiency, AI has become a critical survival strategy, enabling SMBs to offer hyper-personalized customer experiences, make data-driven decisions, and innovate at a pace previously reserved for larger enterprises.

The Deep Dive: A New Era for Main Street

Artificial intelligence, once the exclusive domain of tech behemoths, has decisively arrived on Main Street. In 2026, its integration into small and medium-sized businesses (SMBs) is no longer a futuristic concept but a tangible reality, profoundly reshaping operational paradigms and competitive landscapes. The shift is dramatic: surveys reveal that up to 89% of small businesses are now leveraging AI for automation, a significant leap from just 48% in 2024. This rapid embrace underscores a growing understanding that AI is not just a tool for efficiency, but a catalyst for growth.

The allure of AI lies in its ability to empower lean teams to achieve disproportionate results. Businesses are experiencing substantial productivity boosts, with some reports indicating gains between 29% and 72%, and even up to 133% in specific cases for productivity. These figures are translating directly into increased revenue, with 85% of AI-adopting SMBs anticipating a positive return on their investment. The economic impact is profound, with projections suggesting AI could add an astounding $15.7 trillion to the global economy by 2030.

Central to this transformation is AI automation, which intelligently handles repetitive, time-consuming tasks. Unlike traditional automation that follows rigid rules, AI learns, adapts, and makes informed decisions. This capability allows small business owners and their teams to redirect their focus from mundane administrative duties to strategic planning, creativity, and deeper customer engagement. It’s akin to acquiring a tireless digital team member who continuously learns and improves.

The applications are diverse and growing, touching almost every facet of small business operations. In customer service, AI-powered chatbots and virtual assistants are now commonplace, providing 24/7 support, answering routine inquiries, and routing complex issues to human agents. This not only improves customer satisfaction but can also reduce service costs by up to 50%. For many SMBs, this means delivering enterprise-level responsiveness without the prohibitive overhead.

Marketing and sales are being revolutionized by hyper-personalization. AI tools analyze customer behavior, preferences, and browsing habits to deliver tailored product recommendations, dynamic email content, and highly targeted ad campaigns. This precision marketing, once a luxury for large brands, is now accessible to small businesses, leading to higher conversion rates and stronger customer loyalty. Generative AI, in particular, is a game-changer for content creation, enabling rapid generation of blog posts, social media updates, product descriptions, and email marketing copy, freeing up significant time for business owners.

Beyond the customer-facing roles, AI is driving significant improvements in back-office efficiency. Tools are automating invoicing, scheduling, inventory management, and data entry, drastically reducing manual errors and freeing up employee time. In financial management, AI-powered accounting software provides real-time insights, detects fraud, and automates tax preparation, enabling smarter, data-driven decision-making. This holistic automation strategy is crucial for SMBs navigating economic pressures like inflation and supply chain issues.

Subscribe now

“”The real risk isn’t embracing AI too soon but waiting too long and falling behind more agile competitors.”“

This sentiment, articulated by Benjamin Yeh of ASUS Computer International, encapsulates the urgency driving AI adoption among SMBs. The competitive landscape is evolving rapidly, and early adopters are gaining a significant edge, leveraging AI for better analytics, improved customer responsiveness, and strengthened collaboration. Companies like ASUS are already providing AI-enabled devices that bring real-time transcription, live translation, and enhanced security to everyday business interactions.

However, the journey is not without its challenges. Skill gaps remain a significant hurdle for 44% of small businesses, alongside integration issues cited by 37%. Data privacy concerns and the evolving regulatory landscape also loom large, with 65% of small businesses worrying about new regulations. There’s also the “dark side” of AI adoption, including risks of deepfake scams targeting finance teams, data leaks from poorly trained models, and bias in AI-driven hiring or lending tools. Mitigating these risks requires careful planning, secure platforms, and a focus on responsible AI practices.

The future of AI for small businesses points towards even more integrated and intuitive solutions. No-code AI platforms are making automation accessible to non-programmers, while AI-powered assistants are taking on increasingly complex tasks like scheduling and reporting. Generative AI will continue to evolve, enhancing creativity in design and analytics. Perhaps most exciting are predictive automation capabilities, where AI anticipates customer needs and triggers actions proactively, and the rise of specialized AI agents designed for specific industry niches.

Subscribe now

Visualizing the AI Shift

Insights from recent video discussions further illuminate the practicalities and philosophies behind AI adoption for small businesses. Several reputable YouTube channels have hosted workshops and interviews, consistently reinforcing the narrative of AI as an empowering, rather than displacing, force.

One common thread is the emphasis on starting small and purposeful. Experts advise identifying one or two repetitive, low-value tasks that consume significant time and then seeking AI tools to automate them. This pragmatic approach helps businesses see tangible benefits quickly without feeling overwhelmed. Examples shared include using AI for drafting emails, creating basic marketing content, or managing customer inquiries.

A key misconception addressed in these videos is the fear of AI replacing human jobs. Instead, the consensus among experts is that AI serves as an “intern” or a powerful assistant, augmenting human capabilities rather than outright replacing them. AI handles the “boring stuff” – the repetitive, data-heavy tasks – allowing human employees to focus on higher-value activities that require creativity, empathy, and strategic thinking. This perspective frames AI as a tool for workforce augmentation, enabling teams to achieve more with existing resources.

Videos also highlight the accessibility of current AI solutions. Many off-the-shelf, subscription-based tools require no technical expertise and are user-friendly for small business owners. Popular tools frequently mentioned include ChatGPT Teams for content creation and customer support, Zapier AI for workflow automation across different applications, and Fireflies.ai for meeting transcriptions and summaries. These discussions often include practical demonstrations of how these tools can be integrated into existing workflows to achieve immediate gains.

The importance of data analytics is another recurring theme. Videos emphasize how AI-powered analytics can transform raw data from various business systems (CRM, accounting, sales) into actionable insights. This allows SMBs to predict trends, understand customer behavior, and make smarter, faster business decisions, a capability traditionally out of reach for smaller organizations due to resource constraints.

Finally, the concept of “AI readiness” is explored. This involves not just adopting tools but also documenting existing workflows, training teams on how to effectively use AI, and conducting regular automation audits. The narrative underscores that successful AI integration is as much about process optimization and human adaptation as it is about technology.

Subscribe now

Impact Report: Why This Matters Now

The current surge in AI adoption among small businesses marks a pivotal moment, signaling a fundamental recalibration of competitive dynamics. The sheer speed of this transformation is astounding; between July 2024 and April 2026, the percentage of small businesses regularly using AI jumped from 48% to 68% globally. This isn’t merely incremental improvement; it’s a strategic imperative that is rapidly separating agile, forward-thinking businesses from those resistant to change.

For many SMBs, AI offers a lifeline in an increasingly demanding economic environment. Faced with rising labor costs, intense competition, and customer expectations for instant, personalized service, AI provides the means to maintain profitability and scale operations without necessarily expanding headcount. The ability to automate repetitive tasks, from customer support to marketing and administrative duties, frees up critical time and resources, allowing business owners to focus on strategic growth and innovation.

Moreover, the democratizing effect of AI cannot be overstated. Powerful tools and capabilities once reserved for large corporations with immense budgets are now available to entrepreneurs and small teams through affordable, cloud-based, and no-code solutions. This levels the playing field, enabling smaller entities to compete more effectively by delivering highly personalized customer experiences, generating sophisticated marketing content, and making data-driven decisions with unprecedented accuracy.

However, the rapid embrace of AI also introduces new complexities and risks that demand attention. The increasing reliance on automated decision-making tools, while boosting efficiency, also amplifies potential liabilities, such as errors generated from AI outputs or algorithmic bias. Insurtech companies are already expanding their coverage to address these emerging “affirmative AI risks,” highlighting the need for businesses to understand the legal and ethical implications of their AI deployments. Data privacy and cybersecurity, especially deepfake scams, are growing concerns that require robust solutions and employee training.

The investment in AI is not a fleeting trend but a long-term commitment. Businesses that are thriving are nearly twice as likely to be investing in AI compared to those struggling, and a significant 71% of small businesses plan to increase their AI investment in the coming year. This indicates a strong belief in the sustained value and transformative potential of AI. The future of small business in 2026 and beyond will undoubtedly be defined by how effectively these enterprises integrate AI, not just for automation, but as a strategic partner for innovation, resilience, and sustainable growth. Those who act decisively will not just survive, but lead the next wave of economic evolution.

Hey friends 👋

When I first started playing seriously with AI, I kept running into these strange words:
Context windows. Tokens. Fine-tuning. RLHF...
Everyone seemed to know what they meant — except me.

The problem?
Nobody was breaking it down in normal language. Just endless tech-speak.

So today I want to fix that.

Here’s a short, simple guide to 5 core AI concepts that will help you understand what’s actually happening inside these models — and make you sound 10x smarter at your next AI conversation.

Subscribe now

1️⃣ Context Window — How Much the AI Can "Remember"

Every AI model has a kind of short-term memory called a context window.
The bigger it is, the more information it can process at once.

Imagine this:
Small window = quick chat about where to have dinner.
Big window = deep dive into your 10-year business plan.

Tools like Gemini or Claude 3 have huge context windows, which means they can handle giant documents, full books, or huge conversation threads without getting lost.

Why this matters:
If you're summarizing books, analyzing contracts, or feeding huge datasets into AI — pick a model with a large context window. It’s one of the biggest factors in getting good outputs.

2️⃣ Tokens — The Currency of AI

AI doesn’t see words the way we do.
It breaks text into smaller units called tokens — often little chunks of words.

Example:
The word “playing” becomes “play” + “ing” — two tokens.

Why this matters:
Almost every AI tool charges you based on token usage. Both your input and the AI’s output consume tokens.
Longer prompts? More tokens. Longer responses? More tokens.
Hit your token limit, and you might get cut off mid-response.

3️⃣ Fine-Tuning — Custom Training for Specific Jobs

Most big AI models are trained on huge, general datasets (like all of the internet). But sometimes you want them to specialize — that’s where fine-tuning comes in.

Think of it like this:
You hire a smart intern (the base AI model), but then you train them specifically for your business using your internal documents.

Example:
Hospitals fine-tune medical models on patient records.
Law firms fine-tune models to review contracts.
Startups fine-tune models to handle customer support.

Why this matters:
You don’t have to fine-tune models yourself, but knowing this explains why some niche AI tools massively outperform general chatbots for very specific use cases.

Subscribe now

4️⃣ Latency — How Long You Wait for a Response

Simple but important:
Latency is how long the AI takes to respond after you hit "submit."

Example:
When ChatGPT pauses for a few seconds before replying — that’s latency.

Why this matters:
Low latency = fast, natural conversations.
For real-time apps (think voice assistants, live chat, or translation), low latency makes the experience feel smooth instead of frustrating.

5️⃣ RLHF — How You’re Actually Helping Train AI

RLHF stands for Reinforcement Learning from Human Feedback.
(A mouthful, I know.)

In simple terms, this is how AI gets better: humans rate the AI’s answers, and the model learns from that feedback.

Example:
When you thumbs-up or thumbs-down a ChatGPT response, you’re directly contributing to its training.

Why this matters:
Every time you give feedback, you’re literally helping shape the next version of these models. That’s how AI keeps getting better.

Wrapping It Up

AI can feel like a black box. But once you peek inside, the core concepts are actually pretty simple.

• Context window = how much it can handle at once.

• Tokens = how it counts your words.

• Fine-tuning = custom job training.

• Latency = response speed.

• RLHF = learning from your feedback.

The more you understand how the engine works, the better you'll drive it.

If this was helpful — hit subscribe, share with a friend, or reply and let me know what other AI topics you'd love to see explained. 🚀

Update, 2026: The AI Operator has narrowed its focus to AI and building with AI in production. This post is from before that shift. If that’s what you’re here for, start with I rebuilt Karpathy’s LLM Wiki, I built this for myself. Then 1,374 strangers cloned it., or what The AI Operator is now.

Two decades ago, making a living online meant stitching together ad pennies from a blog, a YouTube channel, or a handful of sponsorships. Today, the creator economy is a global force — a $250+ billion industry reshaping how people work, entertain, teach, and build influence.

But behind the explosion of content lies a harder truth: not all platforms reward creators equally.

Some platforms — like YouTube — have paid out tens of billions to creators over the years. Others, like TikTok, built empires on creator attention, offering only pennies per million views. Meanwhile, Substack reinvented the income model entirely, proving that small, loyal audiences can generate full-time earnings without relying on ads. And LinkedIn, once just a digital resume site, quietly became a new playground for professional creators — even if the direct payouts are still rare.

In this breakdown, we’ll go beyond the headlines and into the real data:
How the creator economy evolved from 2000 to 2025,
Where the money flows across platforms,
And what smart creators — and businesses — need to know next.

Let's follow the money.

Subscribe now

Creator Economy Milestones: 2000–2025 Timeline

A Two-Decade Shift in How Creators Get Paid

In the early 2000s, the idea of individuals earning real money by sharing content online was barely a whisper. By the late 2010s, it became a roar. Platforms once seen as hobbies or side hustles became major economic engines, paying billions to creators worldwide.

The creator economy evolved through three distinct phases: the experimental era (2000–2010), the platform consolidation era (2010–2020), and the explosion and diversification era (2020–2025).

Key Milestones in the Creator Economy (2000–2025):

• 2005: YouTube launches, setting the foundation for online video creators.

• 2007: YouTube introduces the Partner Program, enabling ad revenue sharing with creators.

• 2013: Patreon launches, pioneering direct fan-funded creator income.

• 2017: Substack launches, offering subscription newsletters with direct payments.

• 2017–2018: TikTok expands globally, reshaping content around short-form viral video.

• 2020: TikTok Creator Fund ($1B over 3 years) announced — first attempt at systematic payouts.

• 2020–2021: Substack "boom": top writers start earning six/seven figures.

• 2021: LinkedIn Creator Mode launches and LinkedIn's $25M Creator Accelerator fund begins to nurture professional content creators.

• 2023: TikTok sunsets Creator Fund and launches Creativity Program Beta.

• 2024: YouTube Shorts ad revenue sharing kicks in — short-form creators finally earn at scale.

Subscribe now

YouTube — The Monetization Gold Standard

How YouTube Set the Standard for Paying Creators

When it comes to creator earnings, YouTube set the blueprint.
Back in 2007, it launched the YouTube Partner Program (YPP), allowing creators to share in advertising revenue. It was the first time average internet users could consistently get paid for making content — not through sponsorships, but directly through the platform.

Since then, the numbers have been staggering.
From 2020 to 2023 alone, YouTube paid creators over $70 billion globally (YouTube Official Blog).
That’s more than most Hollywood studios grossed in the same period.

YouTube didn’t just pioneer monetization — it scaled it.
Today, over 3 million channels participate in YPP, and the platform keeps adding new earning methods:

• Ads on videos (classic CPM model)

• Super Chat and Super Stickers during live streams

• Channel Memberships (monthly subscriptions)

• Merchandise Shelf (integrated storefronts)

• YouTube Shorts revenue sharing (since 2024)

YouTube Earnings Model: Ads Rule, but Diversification Grows

YouTube’s bread and butter is still advertising revenue — simple CPM (cost per thousand views).
On average:

• Long-form videos earn creators between $5–$10 per 1,000 views depending on niche, audience, and region (source).

• Shorts (introduced revenue sharing in 2024) earn less per view, but payout scales are improving.

(Shorts CPM estimates vary, but early reports suggest $0.04–$0.06 per 1,000 views — better than TikTok's original payouts.)

Creators who diversify — using memberships, merch, live donations — often double or triple their earnings compared to relying on ads alone.

Key Facts:

• YouTube Shorts payout system now works similar to TikTok’s, but backed by actual ad revenue sharing instead of a static fund.

• A small channel (10,000–50,000 subs) can realistically earn $500–$2,500 per month if content is consistent and monetized well.

• Top creators (1M+ subs) often diversify income streams across sponsorships, ads, memberships, and off-platform (Patreon, Substack, Courses).

Final Thought:

While newer platforms chase virality, YouTube remains the king when it comes to paying creators consistently.
It rewards time invested, audience loyalty, and format mastery — not just fleeting fame.

TikTok — Explosive Growth, Tiny Payouts (Until Now)

From Viral Fame to Monetization Frustration

TikTok exploded onto the global stage between 2017–2019, redefining social media around short-form video.
By 2020, it surpassed 1 billion users worldwide, making it one of the fastest-growing platforms in internet history.

But while creators flocked to TikTok for attention, earning real money proved much harder.

In 2020, TikTok launched the TikTok Creator Fund — a $1 billion promise to pay creators over three years.
It sounded revolutionary.
In reality, it quickly became clear: the payouts were tiny.

TikTok's Monetization Problem: Scale Without Revenue

The TikTok Creator Fund was a static pool — a limited pot split among a growing flood of creators.
As more creators joined, the earnings per view dropped dramatically.

Real-world creator reports showed:

• Earnings around $0.02 to $0.04 per 1,000 views (source).

• A viral video with 1 million views might earn a creator $20 to $40 — barely enough for dinner.

Compared to YouTube’s $5–$10 CPM, TikTok felt shockingly low in payout fairness.

2023–2025: TikTok's Course Correction

By late 2023, TikTok admitted the flaws.
The TikTok Creativity Program Beta replaced the old Fund.

Key changes:

• Longer videos (>1 minute) are prioritized for better payouts.

• Estimated CPM under the new model: $0.50–$1 per 1,000 views — a 10x–20x improvement over the old Fund.

• TikTok Shop (e-commerce), TikTok Live (virtual gifting), and brand deals also grew as alternative revenue streams.

Key Facts:

• TikTok is still attention-rich but revenue-poor compared to YouTube.

• Monetization works best for creators who also sell products or build off-platform income (Patreon, Substack, Courses).

• The new Creativity Program helps, but longer content is now key to real earnings.

Final Thought:

TikTok built the ultimate attention machine.
But for creators chasing money, not just views, the platform's payout game is still playing catch-up.

Subscribe now

Substack — The Paid Subscription Revolution

How Substack Flipped the Creator Economy

When Substack launched in 2017, it seemed simple:
→ Let writers email their audience directly.
→ Let writers charge for that access.
→ Cut out advertisers and platform algorithms entirely.

The result?
Substack sparked a direct-to-audience revolution that changed how creators monetize online.

While YouTube and TikTok monetize views, Substack monetizes trust.
The difference is massive — and profitable.

Substack’s Subscription Model: Small Audience, Big Earnings

Substack’s model is simple but powerful:

• Writers keep 90% of their subscription revenue (10% goes to Substack).

• Most subscriptions cost readers $5–$10 per month.

• A creator doesn’t need millions of readers — 1,000 true fans can generate full-time income.

Example:

• 1,000 subscribers paying $8/month = $8,000/month gross (~$7,200 after fees).

By 2023:

• Substack crossed 2 million paid subscriptions platform-wide (source).

• Top writers (the elite ~0.1%) earned $250,000–$1M+ annually.

Substack also launched features like:

• Substack Chat (private group chats with paying readers)

• Substack Notes (short-form social posts inside Substack)

All designed to keep readers inside the Substack ecosystem — and creators earning.

Key Facts:

• Substack creators own their mailing list — critical for long-term brand building.

• Income is much more stable than ad-based models — subscriptions = recurring revenue.

• However, Substack success skews elite-heavy — most writers earn modestly unless they have a strong niche.

Final Thought:

Substack proved that small, loyal audiences beat viral view counts — if you offer real value.
In the subscription era, creators are not just chasing clicks anymore.
They’re building tribes.

LinkedIn — Indirect Monetization and Professional Leverage

LinkedIn: The Creator Platform You Didn’t Expect

When people hear "creator economy," LinkedIn isn’t the first platform that comes to mind.
But in the 2020s, LinkedIn quietly became one of the most powerful creator tools — just with a very different business model.

Instead of paying creators directly through ads or subscriptions, LinkedIn creators earn indirectly:
→ Through jobs, consulting deals, partnerships, speaking gigs, and authority building.

In short:
No ad revenue checks. Big off-platform paydays.

How LinkedIn’s Creator Ecosystem Works

Starting in 2021, LinkedIn made a serious push into the creator world:

• Launched Creator Mode (turns a LinkedIn profile into a content hub)

• Announced a $25M Creator Accelerator Program (grants, not payouts)

But even today:

• No direct ad revenue sharing for posts

• No native subscription options (like Substack/YouTube)

Instead, LinkedIn content leads to:

• Personal brand growth

• Higher visibility inside professional circles

• Direct inbound opportunities (job offers, client leads)

Key Facts:

• Over 2 million LinkedIn users had activated Creator Mode by 2022.

• Content engagement on LinkedIn rose by +44% year-over-year around 2023 (source).

• Top LinkedIn creators routinely credit the platform for 6-figure consulting deals, paid keynote invites, and high-paying job offers — even though LinkedIn never sends them a check.

Final Thought:

LinkedIn isn’t the platform for quick payouts.
But for serious professionals building long-term authority and business, it’s arguably the most valuable creator platform today — if you know how to leverage it.

Subscribe now

Conclusion: Where the Creator Economy’s Money Really Moves

Twenty years ago, being a "creator" meant uploading videos for free or blogging for pennies.
Today, it's a multi-billion-dollar global economy — but not all platforms reward creators equally.

Here’s the real breakdown:

• YouTube remains the gold standard: consistent, high payouts tied to real ad revenue.

• TikTok built insane attention, but still struggles to pay creators fairly (even after the Creativity Program shift).

• Substack proves that smaller audiences can generate bigger, steadier income through loyalty and subscriptions.

• LinkedIn flips the model completely — no direct payouts, but huge off-platform business opportunities for smart creators.

The lesson is simple:
Platforms control the rules. Smart creators control the strategy.

The creator economy isn’t just about posting.
It’s about understanding where your effort translates into real income — and building your brand across multiple ecosystems.

5 Key Takeaways:

• Attention ≠ Money: Massive views don’t automatically mean massive income. Platform payout models matter more than follower counts.

• Diversification Wins: Top creators don’t rely on one platform. They build multi-channel ecosystems: YouTube + TikTok + Substack + LinkedIn = Maximum leverage.

• Audience Quality > Audience Size: 1,000 true fans can be worth more than 1 million passive scrollers.

• Platforms Are Evolving: YouTube, TikTok, and LinkedIn are still tweaking their creator economies — staying adaptable is survival.

• Ownership Matters: Substack shows that owning your email list and audience is one of the smartest long-term moves a creator can make.

Final Word:

The creator economy isn't slowing down. It's leveling up.
The next generation of successful creators won’t just be content machines —
they’ll be strategists, entrepreneurs, and brand builders.

The money is there.
Now it’s about knowing where — and how — to follow it.

Enjoyed this deep dive?
Subscribe to Azor Data for more data-driven breakdowns on how creators, businesses, and platforms are shaping the future economy — with the numbers to back it up.