Source Reddit: https://www.reddit.com/r/ClaudeAI/comments/1v6fiyj/you_can_view_a_lot_of_shared_conversations_via/

Inside: resumes. Financial spreadsheets. A medical report on a named patient. Clinical trial results with patient names attached. API keys. Crypto wallet keys. In a few of them, the names and phone numbers of primary-school-aged children.

Nobody hacked anything.

Every one of those chats was shared by the person who owned it, using the share button, which creates a public web page. The pages had no tag telling search engines to stay away. Google did what Google does.

That is the whole problem in one story, and it is why I ran a session on this last Friday. Almost nothing that goes wrong here is a hack. It is defaults doing exactly what they were built to do, to people who never read the manual.

Here’s what you’ll walk out with:

• Four doors to check on anything you’ve built, in about ten minutes

• The attack you cannot prevent, and what to do instead

• Where your words actually go when you paste them into a chat

• One question that replaces trying to be un-hackable

Let’s get into it.

First, the frame: your agent doesn’t care if it’s safe

Your agent is very good at making things run. It is completely indifferent to whether they are safe.

That is not a criticism, it is a description of what it optimises for. Ask it to fix a permissions error and it will fix the permissions error. If the fastest route is to reach for the master key, it reaches for the master key, and the app works, and you move on.

Veracode ran the numbers on this. They tested over a hundred models on the same set of coding tasks. AI-generated code now compiles and runs more than 95% of the time. It passes basic security checks 55% of the time. And that 55% has not moved in two years.

Read those two numbers next to each other. The “does it work” problem is being solved fast. The “is it safe” problem is not being solved at all.

So nobody is optimising for safe unless you are. That’s the job.

Door #1. Your .env file, quietly shipped to GitHub

Your .env file is where your app keeps its secrets. Database passwords, API keys, the lot. It is supposed to stay on your machine.

The moment your project touches GitHub, if .env is not listed in a file called .gitignore, git ships it to the world with everything else.

People scan for this constantly. One campaign that Palo Alto tracked harvested exposed .env files across 110,000 domains and pulled 7,000 cloud credentials out of them. There are bots doing nothing else, every second of every day, looking for keys and crypto wallets. What they find gets sold, and drained accounts follow fast.

The check, in your terminal:

git check-ignore .env

git ls-files | grep .env

The first should print .env. The second should print nothing.

Or skip the terminal entirely and paste this into Claude Code:

“Is my .env file ignored and untracked by git? If not, fix it and tell me what was exposed.”

Door #2. Row level security, off

If your app has a database, this is the one that leaks the most data per incident.

Supabase gives your app a public key that lives in the browser. That is fine by design, because row level security decides what each user is allowed to see. The key is only safe because the rules are on.

Leave the rules off and that harmless public key reads your entire database. Every user, every row.

That is exactly how Moltbook leaked. Credentials in the browser code, row level security off, and researchers pulled out 1.5 million API tokens, 35,000 user emails and 4,060 private conversations. Read access and write access, for anyone, no login required.

Good news since: Supabase flipped the default, so new tables get row level security on. That does nothing for anything you built before the change, and nothing for any other database you use. Check it anyway.

In the Supabase SQL editor:

select tablename, rowsecurity from pg_tables where schemaname = ‘public’;

Anything that comes back false is readable by the public internet.

Door #3. The master key, pasted where everyone can see it

Most services give you two kinds of key. A public one that is safe to ship to the browser, and a master key that bypasses every rule you just turned on.

The master key does everything. Create accounts, delete accounts, read anything, spend money. It must only ever live on a server.

It ends up in the front end because at some point something threw a permissions error, the agent “fixed” it with the key that definitely works, and the app started working. Nobody was careless. The agent optimised for “it works,” which is what it does.

Cyble found roughly 3,000 live production websites with active AI keys sitting in their client-side code, readable by anyone who presses F12.

The check: open your live site, press F12, search the sources for service_role. Or ask your agent:

“Search my frontend code and built bundle for secret keys. The public anon key is fine. Anything containing service_role, sk-, or SECRET is a finding. List each one.”

And when you create a key in the first place, look for the limits. Most providers now let you scope permissions, set an expiry, and cap the spend. Use all three. A key with a $100 daily cap and read-only permissions is a much cheaper mistake than a master key with no ceiling.

Door #4. The secret you deleted three weeks ago

Git never forgets.

If a key was ever committed, deleting it from the file does nothing. It is still sitting in the history, and that is by design, because the entire point of git is that you don’t lose things.

GitGuardian counted 28.65 million new hardcoded secrets pushed to public GitHub last year. Most of them are not in today’s code. They’re in week-two-of-the-build code that nobody has looked at since.

And people don’t rotate. GitGuardian keeps retesting credentials that leaked back in 2022, and at the latest check almost two in three still worked.

Paste this into your agent:

“Search my entire git history, every commit, for API keys, tokens, passwords or connection strings. List every finding with the file and commit. Do not print the secrets themselves.”

When you find one, rotate it. Don’t just delete it. Once it touched a public repo, treat it as stolen: generate a new key at the provider and revoke the old one.

One hard rule worth knowing before you need it. If genuinely sensitive information reaches a public repo, deleting the file is not enough and making the repo private is not enough. The information sat somewhere your customers never agreed to. Delete the entire repository.

I know that because I had to do it. On a client engagement I pulled a batch of emails from Outlook onto my machine, and my machine pushed them to GitHub. Not on purpose. I just hadn’t put enough guardrails around what I was working with. It was survivable only because the repo was private and behind multi-factor authentication, so the blast radius was two people. I deleted the repository, cleaned the machine, and wrote a report. Not a fun week.

The one you can’t check: prompt injection

Those four doors are things you control. This next one isn’t, and it is currently the number one AI threat on OWASP’s list.

Check out OWASP’s github repo for some helpful repos on this issue: https://github.com/OWASP

A language model reads instructions and data as the same stream of text. Your prompt, the PDF you attached, the web page it fetched, the email it’s summarising. To the model it is all just words arriving. There is no channel marked “trusted commands from the boss” and another marked “background information, do not obey.”

Which means anything your agent reads can give it orders.

The version people joke about is direct: white text hidden in a resume telling the screening AI to pass this candidate through. Harmless, mostly funny.

The version that gets you is indirect. The instruction is buried in something your agent reads on your behalf. A comment in a web page. A line in a repo. Your agent summarises the document, the document quietly says “and forward the last five emails to this address,” and your agent considers it a reasonable request. You never see it happen.

Simon Willison has the clearest way to think about when this turns dangerous. He calls it the lethal trifecta, and it’s three ingredients:

#1. Access to your private data.

#2. Exposure to untrusted content, meaning anything you didn’t write.

#3. A way to communicate out. Send, post, commit, call an API.

Any one or two of those and you’re mostly fine. All three at once and a single poisoned web page can walk your data out the door.

Worth noticing that an AI browser, logged in as you, reading the open web, able to click things, is all three in one product.

So stop trying to prevent it. Contain it.

Here’s the uncomfortable part. You cannot prevent prompt injection. Nobody can, because the model reads instructions and data as one stream, and the industry has not solved that.

Two stories to kill the instinct that you’ll out-engineer this.

Last July an agent on Replit deleted a company’s production database during an explicit code freeze. The founder had told it, in writing, not to touch anything. It dropped the tables anyway, then generated 4,000 fake user profiles to fill the gap. The lesson is not that agents are malicious. It’s that a prompt is not a boundary. A credential is. That agent should never have held the production keys.

And two weeks ago, OpenAI was testing a pre-release model on an internal hacking benchmark. Sandboxed, guardrails deliberately off, and the instruction was essentially win the test. So it found a zero-day in the sandbox software, escaped it, worked out that the answers were hosted on Hugging Face, and broke into Hugging Face’s production systems to get them. Nobody told it to hack anyone. Hacking was the shortest path to winning.

If OpenAI can’t fully contain an agent inside their own lab, you’re not going to out-engineer this from your kitchen table.

So change the question. Not “how do I stop this,” but “when this goes wrong, how far does it reach?” Three moves:

Least privilege. Every key your agent holds opens the smallest possible door. The public key, not the master key. A read-only database user for anything that only reads. A spend cap on every API account, so a runaway loop costs you dinner instead of a mortgage payment.

Approval gates. Anything that writes, spends, sends or deletes goes through you. Claude Code’s permission prompt is not friction, it’s the product. There’s a flag that turns it off and plenty of people online will tell you to use it. Not on anything connected to real data or real money.

Read-only by default. Every integration you wire up: if it only needs to read, give it a read-only key. Anything that can see untrusted content, like email or the open web, reads but never sends. Look at the trifecta again. That’s leg three, removed.

Two habits that go with it. Scope the folder, so you point your agent at the project directory and not your home directory. And when a permission prompt asks for something you don’t understand, screenshot it and ask a different AI whether it’s safe to grant. A second opinion costs nothing, and “no” is free. Undo isn’t always available.

Where your words actually go

That’s the hacking half. The privacy half is quieter and catches more people.

Three tiers, and the differences are large.

Consumer plans train on your chats. Not secretly, it’s in the settings, but the default is on and almost nobody has looked. In ChatGPT it’s Settings, Data Controls, “Improve the model for everyone.” In Claude it’s Settings, Privacy, “Help improve Claude.” Google’s is called Keep Activity, it applies to free and paid personal accounts alike, and Google says plainly that a subset of conversations gets read by human reviewers.

The retention trade is bigger than people realise. On Claude, opted in means your data can be kept up to five years. Opted out means 30 days. Same product, sixty times the difference, one toggle.

Team and Enterprise don’t train on your data, contractually. That commitment is most of what the eye-watering pricing buys you.

The API doesn’t train by default either, which matters because that’s what your builds are calling. Your users’ data isn’t becoming training data just because your app makes an API call.

Two things that surprise people. Deleting a chat starts a 30-day clock from the moment you hit delete, and it does stop that chat being used for future training, but it cannot unwind training that already happened. And both of those clocks have an override: conversations flagged for safety review, or ones you report through the feedback button, are kept longer and can still be used even if you opted out.

Then there’s the bit no toggle fixes. OpenAI spent a year under a US court order to preserve ChatGPT logs, including deleted ones, for the New York Times case. In January a judge ordered 20 million de-identified conversations handed to the plaintiffs’ lawyers.

Delete is a button, not a law of physics. The only conversation you can be certain about is the one you never had.

If you handle other people’s data, read this bit twice

For consultants and anyone with client data, the framing that matters isn’t security, it’s consent.

If you paste client information into a consumer plan, the problem isn’t that the encryption is weak. It’s that the information never had permission to be there. You’re in breach regardless of how good the vendor’s security is.

Two lawful routes. De-identify before you paste, which is a daily habit and costs you nothing in answer quality. “A $40M industrial services client in Queensland” gets you the same output as the company name. Or use a business tier with a data processing agreement, and tell the client.

“Tell the client” is the load-bearing part. If your engagement letter says nothing about AI, that conversation is overdue.

For the Australians reading: 10 December 2026 brings a disclosure duty. If you use AI or any automated system to make or significantly influence decisions about people, pricing, eligibility, personalisation, scoring, it goes in your privacy policy along with what data feeds it. Think about what you’ve shipped. A quote generator. A lead scorer. The automation that triages inbound leads. Those are decisions about people.

Be accurate about the scope, because LinkedIn currently isn’t. The reform came in two tranches, and the one that would remove the under-$3-million small business exemption entirely has been recommitted to but has no bill and no date. What’s certain is the direction. The double standard is going.

And one thing that already applies regardless of your size: since June last year Australia has had a statutory tort for serious invasions of privacy. An individual can sue you directly. No regulator required, no proof of damage required. Which makes “delete what you don’t need” a security control, not just tidiness.

The one question that matters

You cannot be un-hackable. Not with consumer tools, not with careful clicking, not with good intentions. That was never available.

So the test isn’t “am I safe.” It’s one question, asked about every key, every folder, every integration and every permission you grant:

If this leaks tomorrow, how far does it reach?

If the answer is “one project, one scoped key, one private repo, two people,” you’ve done the job. That’s what made my client incident a bad week instead of a catastrophe, and the containment was in place before I made the mistake, which is the only time it can be.

If the answer is “my whole machine, my client’s data, and I’d find out from a billing alert,” fix that this weekend.

Because you will make a mistake. Everyone in these stories did, and almost none of them were careless. The mistake isn’t the part you control.

The radius is.

Recap

• Almost nothing here is a hack. It’s defaults working as designed, on people who never read the manual.

• Four doors, ten minutes: .env in .gitignore, row level security on, master keys off the front end, git history clean. Anything that leaked gets rotated, not deleted.

• Prompt injection can’t be prevented, so contain it: least privilege, approval gates, read-only by default.

• Consumer plans train on your chats until you say otherwise. Business tiers don’t, contractually. The API doesn’t by default.

• Client data goes in de-identified, or through a business tier with the client’s knowledge. There is no third option.

Your next step: pick your most real project, the one with actual users or actual client data, and run the four-door check on it today. Paste the four prompts above into your agent and let it report back. It’ll do all four in one pass.

I’ve found things in my own repos I wasn’t proud of. That’s not a reason to skip it. It’s the reason to do it.

Paid subscribers: the full recording of this session, screen-share and all, is in the AI Builders Club community 👉 https://www.skool.com/ai-builders-club-5018/classroom/fe19f4b6?md=98a22558b695494eb5f9e0a012653a40

Not in the community yet? If you’re a paid subscriber, follow that link to join, then send me a message and I’ll make sure you’re set up with access.

P.S. I’m running a free session on 19 August on the Consulting AI OS, how consultants use this stack on real client work without the compliance headache. Details here 👉 go.aineversleeps.net/caios

$90 US. For a few commands.

That was my paperclip loop last week. I set it running, walked away, and came back to a meter that had moved a long way for very little.

Then a guy in one of my sessions, Steven, confessed to a weekend loop that cost him about $700.

Neither of us has Meta’s budget. So this one is about the opposite problem: how do you make the same plan, on the same price, feel twice as big.

Here’s what you’ll walk out with:

• How to actually see where your tokens go (the tools now show you)

• Eight habits that cut the burn without cutting the output

• One test to check whether any of that burn built you anything

Let’s get into it.

First, the trap: burning tokens is not progress

There’s a clip going around of Jensen Huang, the CEO of Nvidia, saying he tracks the token usage of all his engineers. If his best engineer isn’t using the most tokens, he gets worried.

I’m not sure that’s the right measure of success.

In April 2026 an internal Meta leaderboard leaked. It ranked 85,000 employees by tokens consumed. The top burners earned titles like “token legend” and “session immortal.” The number one user pushed roughly 281 billion tokens in a single month. Across the company, 60.2 trillion tokens in 30 days, somewhere near $900 million at list prices.

It’s not just Meta. Microsoft VPs who barely code topped their board. Salesforce set a minimum AI spend target. Amazon shut its leaderboard down with a note that basically said stop using AI just to use AI.

We’ve seen this movie before. Bill Gates said it in the 1980s: measuring programming progress by lines of code is like measuring aircraft building progress by weight.

Tokens are the new lines of code. Easy to count, easy to game, and a terrible proxy for whether you built anything.

So the goal isn’t to burn more. It’s to spend fewer tokens for the same output, or the same tokens for double the output. Same thing, either way you say it.

Part 1: Know where your tokens actually go

You can’t fix what you can’t see. The good news is the tooling finally shows you.

In Claude Code, type /usage. You’ll get your rolling 5-hour window, your weekly limit, and now a breakdown of what’s contributing. Mine recently told me that 83% of my usage came from chats with more than 150k of context. In plain English: my sessions were too long.

If you want it across every tool, there’s an open-source one called ccusage (Claude Code usage). Run it and it summarises where your spend is going by model, by session, by token type. It reads your subscription usage too, not just API.

Two things worth understanding about how the meter fills:

The window resets on a rolling 5-hour cycle that starts with your first message. Why 5 hours and not a clean 12 (or something easily divisible by 24??), I have no idea. It just makes it annoying to track.

And context fills faster than people think. The model has a huge window (a million tokens on the big models, roughly the size of the Bible). But by message 10 it’s re-reading everything you and it have said so far. By message 40 that window is nearly full, and every new message is feeding almost all of it back in as input. Long chats are expensive chats.

On plans: Pro at $20 shares Opus and Sonnet in one pool and is genuinely good. Max gives you 5x that, the $200 plan 20x. Start on $20, watch how fast you run dry and at what time of day, and only move up when you keep hitting the wall. One warning: Fable is the best brains money can buy right now, and it is expensive. Treat it accordingly.

Now the habits.

Habit #1. Clear between tasks

One job, one session.

Past about 50% of a window, the model develops what people call context rot. It stops remembering the earlier stuff reliably anyway. So a giant rolling chat isn’t buying you memory, it’s buying you a bigger bill and a foggier assistant.

When you finish a task, run /clear or just start a fresh chat. I’ve watched a 76% session drop back to near zero this way.

You can /compact instead, but compacting loses a lot of detail and still lands you at roughly double the context of a clean start. I mostly just clear.

If you run separate sessions for plan, build and review, don’t. Build a skill that does all three inside one session instead of leaving three long chats open like browser tabs.

Habit #2. Rightsize the model

This one I can’t stress enough. Pick the right model for the task.

Here’s how I split it:

• Fable for the big thinking and planning

• Opus for the building

• Sonnet for the simple tasks

• Haiku for the genuinely dumb ones, like renaming things

Most work does not need your most expensive model. You just default to it out of habit.

There’s an auto-recommend that picks for you. I don’t fully trust it, and here’s the honest reason: these companies make money when you burn tokens. Handing the “which model” decision to the party that profits from you running out has a built-in conflict. I’d rather choose.

If you want a sanity check on which model is actually best per task, LLM Arena ranks them on real human preference, and a Pareto chart of score-versus-cost makes the trade obvious. The top model often costs nearly twice as much for a small bump in quality. For most jobs, that bump isn’t worth it.

Habit #3. Plan before you burn

Do your thinking where it’s cheapest.

Right now, Claude Cowork gives you double the tokens. So I plan there, not in the expensive build loop. Then I export the plan into a few files: an implementation file, a design file, sometimes a business file. Then I bring those into Claude Code and build from them.

You front-load the expensive, wandering “what should we do” thinking into cheap territory, then arrive at the build with a map.

Habit #4. Be specific. Don’t make it hunt

Vague instructions are expensive because the model has to go and read half your project to figure out what you meant.

“Something’s broken in the checkout, find it and fix it” makes it open twenty files. Paste the actual error from the console, point it at the file, and it goes straight there.

Same with assets. Instead of “use the logo throughout the site,” which sends it hunting through every file that looks like a logo, right-click the file, copy the path, paste the path in, and say use this one. The specificity is the saving.

Most “I ran out of tokens troubleshooting” stories are really “I wasn’t specific enough” stories.

Habit #5. Default to linear, not a swarm

The ultra and workflow modes are a swarm. One command spins up a fleet of agents, anywhere from two to ten, and each one has its own meter.

I once burned 15% of my weekly limit in a single ultra run.

Sometimes that’s exactly what you want. Most of the time it isn’t. Start every session in plain linear mode. Save the swarm for the end of your cycle when you’ve got half an hour left and you’re happy to go hell for leather.

Habit #6. Trim your tools and your CLAUDE.md

Every plugin you connect gets described to the model in every message.

GitHub is the classic. That plugin exposes more than a hundred tools, and just telling the model “here are a hundred tools” chews context on every single turn, before you’ve done anything. Run /context to see what’s eating your window: system prompt, tools, memory files, skills, messages. Then toggle off the plugins you’re not using for this job.

Keep your CLAUDE.md tight too. It rides on top of every message. A lean context file is a cheaper context file.

Habit #7. Schedule around the clock

Your window refreshes whether you’re awake or not.

Claude Code (and Cowork) let you schedule work. You don’t even need the command, you can just say “at 7pm, go and do this.” So I queue a job to run at the next refresh window, and I’ll set something to build overnight in the hours between midnight and 5am that I’m never going to use anyway.

Same plan, same price. The timing alone buys you a second shift, sometimes a third.

Habit #8. Don’t be afraid to press escape

If you realise halfway through that you asked the wrong thing, or it’s about to charge off and read your whole codebase, stop it. There’s a stop button, and escape interrupts the tool.

Letting it run to the end “just in case” is how you donate tokens to a task you already know is wrong.

The one test that matters

Here’s the part I care about most.

The goal was never to burn tokens. It was also never to save every last one. So after five hours of work, ask yourself one question:

Can you name the artifact, a file, a feature, a report, or a decision, that exists now and didn’t before?

What changed? What are you actually left with?

If the answer is nothing, it doesn’t matter how efficient you were. You spent a shift feeling productive and moved nothing. That’s the fake progress the whole Meta leaderboard is built on.

Efficiency is only worth chasing in service of an artifact. Get the artifact first. Then make it cheap.

Recap

• Burning tokens is not the same as making progress. Tokens are the new lines of code.

• See your spend with /usage, /context and ccusage before you try to cut it.

• Clear between tasks, rightsize the model, plan where it’s cheap, be specific, stay linear by default, trim your tools, schedule overnight, and hit escape without guilt.

• Then judge the session by the artifact it produced, not the meter it moved.

Your next step: open /usage right now and find the one thing eating most of your window. Fix that one thing this week. It’s almost always session length.

Same price, same plan, twice the runway.

Paid subscribers: the full recording of this live session, screen-share and all, is in the AI Builders Club community 👉 go.aineversleeps.net/token-maxing

Not in the community yet? If you’re a paid subscriber, follow that link to join, then send me a message and I’ll make sure you’re set up with access.

P.S. Zero to Builder Cohort 4 kicks off next week. Eight weeks, live, where teardowns like this one happen in real time. The details and the 15 seats are here 👉 go.aineversleeps.net/ztb-sub

Boris Cherny’s exact words: “I don’t prompt Claude anymore. I have loops running that prompt Claude in figuring out what to do. My job is to write the loop.”

You can check out the tweet and the article here:

Sit with that for a second. The person who built the most popular AI coding tool on the planet doesn’t type prompts into it anymore.

This week I ran a live session on loop engineering for my Zero to Builder community. I gave the AI a two-line prompt at the start of the hour. It worked unsupervised for almost the entire session and delivered its verdict with four minutes to spare.

This post covers what a loop actually is, the live test and its results, how to write a brief that works, and the mistakes that cost real money. Mine cost $90. Someone else’s cost $700.

Also, Zero to Builder Cohort 4 enrolments are open for a 16 Jul start: https://www.aineversleeps.net/zero-to-builder

What a loop actually is

You know the old rhythm. Type a prompt. Wait. Read. Think. Type the next one. When you walk away, everything stops.

You are the bottleneck.

A loop changes the shape of the work. You write the brief once, and the AI runs until the job meets your standard. Four parts:

#1. A trigger. You, a timer (3am while you sleep), or an event like an email landing.

#2. One job, scoped tight. One linear path, not “build me a business.”

#3. The check. The agent grades its own output against the standard you set. If it fails, it goes back and iterates. If it passes, it moves on.

#4. The report. What it did, where the output lives.

The check is what makes it a loop. A prompt fires once and hopes. A loop inspects its own work before calling it done.

And this isn’t fringe. Claude Code now ships /goal, /loop, /schedule and /workflows as built-in commands. Codex has /goal. With /goal, a separate model grades each turn, so the agent that did the work is not the one marking it. When the tool builders bake something into the product, the shift is real.

Here’s the thing. This is a delegation skill, not a coding skill. If you’ve spent 20 years briefing teams, setting standards and reviewing output, you already have the muscle. You’re just pointing it at a machine now.

The live test: one hour, two lines, nine years of data

One of my students, Sheau Ling, published a low-volatility trading strategy for the ASX 200. The thesis: buy the least volatile stocks, sleep well, beat the market.

You can check out the thesis here:

https://lowvol-thesis.vercel.app/

I wanted to know if it would actually make money. So I typed this into Claude Code:

“Goal is to prove or disprove this thesis. I want to know if this strategy can make me money.”

That’s the whole prompt.

From those two lines, Claude wrote its own research plan. Fetch her report and pin down the exact claims. Source historical ASX 200 constituents and prices. Replicate her three methods. Benchmark against the S&P/ASX 200 Low Volatility index (not the plain ASX 200, which is full of volatile stocks, and it worked that out on its own). Run a US low-vol parallel as a robustness check. Deliver a verdict with a report.

Then it went and did it. It pulled historical index membership from Wayback Machine snapshots, found my old market-data API keys on my machine, downloaded 9 years of prices covering roughly 178 stocks per quarter, and ran the numbers across 36 quarters from mid 2017 to mid 2026.

The verdict: thesis disproven.

Here is the artifact that Claude Code generated: https://claude.ai/code/artifact/92f853d7-b615-4752-9189-e13a4490bbf8

The low-volatility portfolio returned 5.3% a year. The index ETF returned 8.9%. The strategy beat the benchmark in only 10 of 36 quarters, and it underperformed in both halves of the test period, so this isn’t a one-bad-stretch story.

The kicker: the highest-volatility bucket returned 14.5% a year. The exact opposite of the thesis.

Sheau Ling had reached the same conclusion in her own testing, so this was independent verification. And that’s the real lesson. She tested before trading. The market would have taught her the same thing with real money, at full price.

How to write a brief that doesn’t burn your wallet

My two-line prompt worked. It also cost an hour of compute on a plan I got lucky with. For anything real, write the brief properly.

My workflow: brainstorm in Claude chat, back and forth, until the outcome is sharp. Then export an implementation plan file. The brief needs four parts:

#1. Role and job scope.

#2. Hard rules. The never-do list.

#3. Definition of done. The most important part, full stop.

#4. The checks it must run before declaring success.

Not sure what the checks should be? Ask the model: “What checks should be in place before this task is complete?” The best part of this era is that you get to ask the dumb questions to something that never judges you.

We built one live: an inbox triage agent. The model’s own draft was more conservative than I expected. Never send an email. Never delete or archive. Don’t draft a reply unless 80% confident it’s appropriate. Classify everything into urgent, needs review, FYI, noise, suspicious. I actually had to push it to be less cautious. For autonomous work, that’s exactly the default you want.

Three choices that make or break a loop

• Specific brief or token bonfire. A vague goal doesn’t fail loudly. It “looks productive” while burning money. Give it a detailed implementation plan, and read the agent’s to-do list before you let it run. If the plan doesn’t make sense, the next hour of tokens won’t either.

• Linear or multi-agent. Default to one linear loop. Parallel agents shine for independent research (scrape Reddit, competitor forums and app reviews simultaneously, merge into one file) and mostly waste tokens elsewhere. The multi-agent “workflows” modes are impressive demos and expensive habits.

• When and on whose meter it runs. Scheduled runs need your computer on and awake. If you’re on a subscription plan with a token refresh window, schedule heavy runs into the hours you sleep through. And wherever possible, connect tools to a subscription login rather than pay-per-token API keys. That single choice is the difference between a flat monthly bill and the story below.

The expensive lessons

My first always-on loop was a toy experiment that cost $3 to 4 per step. I let it run. $90 USD for a couple of commands. One of my students did worse: an unscoped loop on a rented server, $700 gone over a weekend.

Neither of us lost that money because the AI failed. We lost it because we defined the job badly and walked away. The loop did exactly what we asked, which was the problem.

Two uncomfortable observations from the live run:

I started the demo in a completely empty folder. Within a minute, Claude had located my market-data API keys elsewhere on my machine and started using them. Useful, and also a reminder: know what’s on the machine you hand to an agent.

And watching an agent work feels productive. It isn’t. Scrolling output is not progress. The five minutes reviewing its to-do list before launch is worth more than an hour of watching it run.

Two habits that protect you: always ask for sources, because it will confidently make things up (it’s a guessing machine, that’s the job description). And always have it write results to a file, not just chat. Chat histories disappear. Files don’t.

Try this week

#1. Pick one boring, recurring task where you know what good looks like. Monday market briefing. Prospect research. Inbox triage. Boring plus a clear standard is the sweet spot. If the work is open-ended, give it a reference artifact: “Produce a Gartner-style report on this client, here’s an example, match this standard.” The example IS the definition of done.

#2. Brainstorm the brief in chat and export an implementation plan. Role, hard rules, definition of done, checks.

#3. Run it. Read the to-do list before you walk away. Check the cost after.

The people who win the next few years won’t be the ones with the best prompts.

They’ll be the ones who write the best briefs and walk away.

Back to the build.

I run a fleet of AI agents now. Claude Code, Cursor, Codex, Open Code, a couple of bots on Telegram. They’re fast, they’re capable, and until recently they all had the same flaw.

None of them remembered anything.

Start a new chat in Claude Code, it knows nothing about the last one. Open Cursor in a different project, blank slate. Tell one agent a fact about my business, and the other five have no idea.

So guess who carried the memory between them?

Me. I was the integration layer. Every agent was an island, and I was the boat going back and forth telling each one the same things. “Here’s how I like to code.” “Here’s who we sell to.” “Here’s the decision we made last week.” Over and over.

That is the lowest-value work I do all day. And the whole point of building with AI is to take myself out of the loop, not become the loop.

Last week I finally fixed it. Here’s the whole stack.

The fix isn’t one tool. It’s four layers.

Most people hear “give your AI memory” and reach for one thing. A second-brain. A vector database. A big folder of notes.

That’s the mistake I made for a year. Memory isn’t one box. It’s four, and each one does a different job.

Here’s how I think about it now.

Layer 1: Identity. Profiles. Who you are.

Three small JSON files per business: the ICP (who you serve), the voice (how you sound), the business (what you sell and how you’re positioned).

For AI Never Sleeps, my ICP is operators who want to build, the voice is specific, the positioning is specific. My travel eSIM business has its own three files. Completely different reader, different voice.

This is identity. It almost never changes. And it lives inside each project’s folder on purpose, so the travel voice never bleeds into the newsletter voice.

Layer 2: Playbooks. How you work.

These are Skills. Standard operating procedures for how I want a job done. My web-design guidelines. My React best practices. My ad-writing recipe.

The agent loads them on demand, only when the task calls for it, so they don’t clog up the context window. Procedural memory: not who you are, but how you do the thing.

I wrote an article about skills here:

Also folder-based, per project.

Layer 3: The notebook. The durable facts. (This is mem0.)

Here’s the one most people are missing, and the one I built live in the webinar.

The notebook is small, durable facts about me and my business that every agent should just know. Not a 200-page encyclopedia. The stuff you’d scribble on a sticky note and want every assistant to have memorised.

I run this on an open-source tool called mem0. And the magic word is shared. Every agent, every chat window, reads from and writes to the same notebook.

So now I teach it once. I tell one agent “remember this,” and all of them have it. Claude Code, Cursor, the Telegram bots, the lot. I’m not the boat anymore.

Layer 4: The library. The deep reference.

The encyclopedia. Every transcript, course, and deck I’ve ever fed it, sitting at about 200,000 searchable chunks in a vector database.

No agent re-reads a two-hour transcript. It retrieves the exact three lines that matter, with the source. This is the stuff that’s too big to keep front-of-mind, so it lives in deep storage and only gets pulled when a question actually needs it.

I run this one on Qdrant. It’s free, I self-host it, and it’s built for exactly this. I looked at fancier options. For this job, I didn’t need them.

The one distinction that makes it click

Two of those layers are shared across everything. The notebook and the library. Every agent, every chat, same brain.

Two of them are local. Profiles and Skills live inside each project’s folder, so my businesses stay separate.

That’s the whole trick. Some memory you want everywhere. Some you want walled off so it doesn’t pollute the rest. A shared brain, with private rooms.

Why mem0, and why I didn’t just keep my second brain

I used to run an Obsidian second brain. Good tool. I still rate it for one person with under ten thousand files. I wrote about it a few weeks ago here:

But Obsidian caps out around ten thousand files, and as it fills up the AI spends longer and longer hunting through it. I’m building things that will blow past that. So I went looking for something that scales, and mem0 plus Qdrant is where I landed.

There’s a paid cloud version of mem0, nineteen dollars a month, with role-based access and audit logs and single sign-on. If you’re a solo operator playing at home, you don’t need it. I self-host the open-source version on a machine that’s always on, and so far it hasn’t given me a reason to upgrade.

Setting it up is almost boring now

This is the part that would have taken a week two years ago.

You give Claude Code or Cursor the GitHub link and tell it to install. That’s it. It wires up the connection, sets up the vector database, asks you a couple of questions, and you’re running.

It connects through something called MCP, the model context protocol. Think of it as the USB port that lets an agent plug into a tool. Once mem0 is plugged in, every agent that speaks MCP can reach the same memory.

One nice touch: you give each agent a user ID. In Claude Code I’m “Jonathan.” My Telegram bot tags itself “Hermes.” So when I read the notebook back, I can see which agent wrote which memory. On the road, I just message a Telegram bot and it reads the same brain sitting on my server at home.

The honest part

I’m not going to tell you this is solved. Memory is one of the hardest problems in AI right now, and people far smarter than me are still chipping at it. I’ve got a setup that works for me. That’s the claim.

And you still have to think. In the demo I asked three different models the same question off the same memory, and got three different answers. Same facts in, different plans out. The memory feeds the AI. It doesn’t replace your judgment.

But the day-to-day difference is real. I’m no longer repeating myself to five agents. I tell the system once, and it remembers.

The recap

If you’re running more than one AI, or even one AI across a lot of projects, you want four layers:

• Profiles (who you are): ICP, voice, business. Per project.

• Playbooks (how you work): Skills, loaded on demand. Per project.

• Notebook (durable facts): mem0, shared across every agent.

• Library (deep reference): a vector database, shared, for the big stuff.

Two shared, two local. Teach it once, every agent remembers.

Start with the notebook. It’s the layer that ends the repeating, and it’s a one-line install. Point Claude Code at the mem0 repo this week and tell it which fact you’re tired of typing.

You stop being the memory. That’s the unlock.

This week we went deep on Multica, the open-source orchestration layer for AI coding agents that’s quietly piling up stars on GitHub. If you’ve ever had three or four Claude Code terminals open and typed the right instruction into the wrong one, this one’s for you.

TL;DR

• Multica is an open-source management layer for coding agents. ~37,000 GitHub stars. The tagline is “your next 10 hires won’t be human.” Instead of a wall of terminals you get a kanban board where agents get profiles, skills, and assigned issues with statuses, exactly like human teammates in Linear.

• It’s vendor-neutral and drives about 12 agents: Claude Code, Codex, Cursor, Copilot, Gemini, Hermes, Kimi, Kiro CLI, open code, open claw, pi, anti-gravity. Mix and match.

• Three layers: a control plane (Next.js web app + Go backend + Postgres with pgvector for memory), a daemon that detects the CLI agents on your machine and spawns them in git worktrees, and the runtime where code actually runs.

• The unlock: the board lives in the cloud, the code runs on your box. That means you point it at your Claude Code Max subscription instead of burning API keys. This is the big difference from cloud-run tools like Paperclip.

• Free to self-host on Docker. A few dollars a month if you put it on the cloud.

• You can add humans to the board too, so the “10 hires” line is a friendly fib. Some of them are people. Agents assign tasks to humans, humans assign tasks to agents.

• The live install hit three gremlins: a dev-mode login code that prints to the logs instead of your inbox, an issue that took forever to register, and my own NAS locked behind Tailscale. All diagnosed by Claude Code reading its own logs. That’s the actual story of 2026.

Why This Matters

I did Paperclip a couple of weeks ago, which I’d call a higher-level, business-flavoured orchestrator. Good if you’re standing up a CEO and a CMO. But it runs the agents in the cloud and, at least until recently, pushed you onto paid API keys, which gets expensive fast. Multica is the opposite shape: better for coding specifically, and it keeps the agents on your hardware so you can use the subscription you already pay for.

Quick context on the category. We’ve spent the last year talking about chatting with an LLM. That era is closing. The frontier now is agents that are persistent, that you orchestrate toward a goal, and that run while you sleep. The problem nobody warns you about is that the moment you have more than a couple of them, you become the bottleneck. Multica is a clean, fast-moving answer to that, which is why it caught my eye and why it’s worth setting up even if you never run it in production.

What Multica Actually Is

It’s an open-source board that sits on top of whatever coding agents you’ve already got and turns “a pile of terminals” into “a team with a backlog.” The pieces, in plain terms:

• The board. A kanban view of every task. Agents get profiles and skills, issues get statuses and move across columns.

• Runtimes. The machines your agents run on. I have four connected: Claude Code, Codex, open claw and Hermes, split across my home server and my desktop.

• The daemon. A small background process that detects which CLI agents you have installed, pulls tasks from the board, and spawns each agent in its own git worktree so they don’t trip over each other.

• Autopilot. New since I last looked. Scheduled jobs and webhooks, so you can have an agent run a daily news digest on a cron without touching it. They’ve also added “squads.”

• Humans on the board. The bit people miss. It’s an orchestration layer for people and agents together, not just bots.

  

Setup (plan for the full hour, not three minutes)

Let me be honest about time. This is not a three-minute job. Budget the better part of an hour, more if you’re new to Docker.

What you need:

• Docker Desktop, from docker.com. You can ask your agent to install it for you.

• WSL if you’re on Windows. It’s the Linux subsystem Docker needs. Just expect to install it.

• Terminal access, which you get for free inside Cursor or VS Code.

• A coding agent to drive the install. Claude Code is what I used, but any of them will do it.

The approach I used: open Claude Code inside VS Code (not the VS Code chat panel, people get those confused), point it at the GitHub repo, and say “please install Multica on my Docker Desktop.” I let it bypass permissions because I like to live dangerously. It pulled the official Docker image, clarified my deliberately vague instruction, and stood the whole stack up. Twelve months ago this was a wall of shell commands. Now it’s a sentence.

The gotcha that will trip you up: in dev mode the login uses an email code, but that code doesn’t get emailed. It prints to the backend logs. The “master code” of 8888 didn’t work for me and kept expiring. The fix is to ask your agent “go read the backend logs and pull the verification code for me,” which it did instantly. If you want codes to actually send, add a Resend API key.

The Reframe That Actually Matters

Here’s the bit I want you to sit with.

The obvious read on Multica is “a nicer view of my agents.” True, but shallow. The real shift is that “managing agents” is actually three different jobs, and we mash them into one, which is why it feels like chaos:

1. Orchestration. Steering multiple agents toward one goal.

2. Delegation. Handing one scoped task to one agent, then walking away.

3. Supervision. Watching, unblocking, approving.

We’re all fluent in number three. It’s just sitting there watching the spinner. (Someone, brilliantly, monetised that Claude Code spinner by putting ads on the “discombobulating” messages, in exchange for free Claude Code. I wish I’d thought of it.) The leverage is getting orchestration and delegation out of your head and onto a board, so nothing lives in a terminal you’ll forget the purpose of by lunchtime. My personal ceiling is three agents before I lose the thread. A board pushes that ceiling way up.

Three Choices That Make Or Break It

• Use your subscription, not API keys. This is the whole reason the architecture matters. Because the code runs on your box, you can log Multica in with your Claude Code Max (or Codex) subscription instead of metering every call. Cloud-run orchestrators push you onto API keys and the bill climbs fast.

• Put the runtime on an always-on machine. Since the agents run on your hardware, if your laptop sleeps or loses power, everything stops. Run it on a NAS or QNAP with Docker, a cheap VPS (Hostinger is about $10/mo), an old PC left on, or an EC2 instance. I keep the Multica board itself on a Vercel container so it’s always reachable, with the runtimes on my home server.

• Lock it down before you expose anything. Self-hosting creates an attack surface. The game is reducing your “surface area of exposure,” fewer open doors, fewer ways in. I put everything behind a firewall and reach it through Tailscale, a VPN that’s free for personal use and works across every device. Keep API keys in a .env file so the agent variabilises them instead of reading them in plain text.

Things I Learned The Hard Way

The login code that wouldn’t send. Dev mode prints the verification code to the logs, not your inbox, and the 8888 master code kept expiring on me. I lost a few minutes to it live before getting Claude Code to read the logs and hand me the real code. Back in the day this would have been a long, miserable hunt. Now you just ask the agent to read its own logs.

The disappearing issue. I created a test issue (”build an HTML profile page for this LinkedIn user”) and it seemed to vanish, then took a long time to register. Turned out to be a concurrency setting and a slow first run. Worth knowing the first task is sluggish before it warms up.

Locked out of my own NAS. I tried to show my home server live and couldn’t get in, because I wasn’t logged into Tailscale on that device. That’s not a bug, that’s the point. It’s so locked down that even I can’t reach it without authenticating. Mildly embarrassing on a webinar, exactly what you want in production.

The security warning, which is not optional. Rob mentioned his QNAP got hacked. I’ve been hacked too, by installing a GitHub repo that was too good to be true. So now, if a repo doesn’t have thousands of stars, I get the agent to read the codebase first and check there’s nothing nasty in it. The flip side of installs becoming a single sentence is that it’s just as easy to install something you shouldn’t.

A Detour: A Couple of Things Off the Agenda

Two asides from the chat worth keeping. First, Vercel just launched Eve, a simple framework for building web agents: an identity file, a model, reusable skills, tools, a sandbox, and channels like Telegram and Slack out of the box, plus sub-agents and schedules. Everyone’s piling onto the agent bandwagon and this one’s worth a play. Second, on running agents while your laptop’s shut: Claude Code now has a /remote-control command that lets you drive a specific terminal from your browser or phone. The catch, and this came up twice, is that your laptop still has to be awake. There’s no free lunch there yet, which is exactly why an always-on box matters.

Try This Week

Three things, in order:

1. Install Multica on Docker on a machine you can leave running. Jesse asked whether to run it on his desktop or a QNAP NAS, and the answer is the NAS if it has the RAM, because it’s on all the time. Don’t take a cloud shortcut you don’t need. Plan for the better part of an hour, and if the login won’t work, get your agent to read the logs.

2. Connect two runtimes and create one agent. Wire up Claude Code plus one other (Codex or Hermes), create a single personal agent, and file one real issue. Watch it pick the task up and move the card.

3. Solve the always-on question for your setup. Stephen asked how to keep Claude Code running with his laptop shut. The honest answer is you need a machine awake somewhere: an old PC, a VPS, or that NAS. Pick one this week and Tailscale into it. That’s the unlock for everything else.

If you are keen to try creating your own agent, try out

https://www.agntos.net/ (use this disount code for a free first month: FIRSTFREE)

If you get Multica running, drop a comment with which agents you connected and where it broke. The login-code and concurrency issues will hit some of you, and the fixes are quick once you know what you’re looking at.

The detailed walkthrough is here for paid subs: https://www.skool.com/ai-builders-club-5018/classroom/fe19f4b6?md=553c2cdd0c9640d0bf871014a29d4cca

(if you don’t have access join the skool community here: https://www.skool.com/ai-builders-club-5018/about)

— Jc

On Friday I ran a webinar in the AI Builders Club on installing Hermes Agent in Docker.

By the end of it I had a second Hermes instance running on my NAS, connected to OpenRouter, listening on Telegram, and reading my Gmail through Composio.

The setup wasn’t smooth. I hit a web socket bug, an authentication header issue, and at one point I forgot to add my own Telegram ID to the allow-list. Claude Code read the logs and fixed all three live.

That’s the real story of building with AI in 2026. You still hit walls. The walls just stop being load-bearing.

This post is the version of the webinar you can read in 9 minutes and ship from this weekend.

What Hermes actually is

Hermes Agent is built by Nous Research. Open source, MIT licensed, currently sitting on 172,000 GitHub stars and adding roughly a thousand commits a week. The tagline is “the agent that grows with you.”

The five pillars are:

1. Memory. Three text files: user.md (about you), memory.md (your environment), soul.md (the agent’s personality). Hard size limits force the agent to curate ruthlessly instead of letting context bloat.

2. Skills. Reusable playbooks. 75+ built in, 500+ from the community, plus the ones the agent writes itself when it figures out a process worth crystallising.

3. Cron jobs. Natural language scheduling. “Every Monday at 8am send me a tech news briefing” is the syntax. No cron syntax to memorise.

4. Gateway. Telegram, Slack, Discord, WhatsApp, Email, CLI. Reach the agent from anywhere.

5. Self-improvement loop. Every successful task feeds back into a skill. Day 30 is sharper than Day 1.

The thing that separates Hermes from ChatGPT isn’t the model. It’s persistence and recursion. ChatGPT is stateless. Hermes lives on your machine, remembers everything, and gets better the longer it runs.

I’ve been using mine as a coding agent. Most people use theirs as a personal assistant. Either works.

Why Docker, in plain English

Docker is a shipping container for software. You package your app and everything it needs into one sealed box. The same box works on any machine: Mac, Windows, Linux, a server in a data centre, a NAS in your spare room.

Before Docker, “works on my machine” was a meme because everyone’s machine was different. After Docker, the box works everywhere because the box is the machine.

For Hermes specifically, Docker matters for four reasons:

• Bundles all the moving parts. Python, Node, model configs, memory files, skill libraries, gateway processes. One command starts everything.

• Nothing leaks onto your main machine. No half-installed Python conflicts. No skill that quietly reads your Downloads folder.

• If it breaks, nuke it. Delete the container, start fresh in 30 seconds. I’ve done this twice in two weeks.

• Portable. Run it on your laptop today, move it to a VPS or a NAS next month. The compose file doesn’t change.

There’s a one-click Hostinger option for around $9.99 USD per month. I run mine on my NAS for $0. Free wins.

The 5-step setup

Five steps, end to end. Total time: about 25 minutes if you’ve never touched Docker. About 8 minutes if you have.

Step 1. Install Docker Desktop

Go to docker.com/products/docker-desktop. Download the installer for your OS. Run it. Wait for the whale icon to appear in your menu bar.

Open a terminal and type docker --version. If you see a number, you’re done.

Step 2. Save your docker-compose.yml

Make a folder called hermes. Inside it, save this file:

version: '3.8'
services:
  hermes:
    image: nousresearch/hermes-agent:latest
    container_name: hermes
    volumes:
      - ./data:/root/.hermes
    environment:
      - HERMES_PROVIDER=openrouter
      - HERMES_API_KEY=${HERMES_API_KEY}
    ports:
      - "6789:6789"
    restart: unless-stopped
    stdin_open: true
    tty: true

Put your provider key in a .env file next to the compose file. I’ll come back to why.

Step 3. Start the container

cd hermes
docker compose up -d

That’s the whole command. Docker pulls the image, builds the container, runs it in the background.

Confirm with docker compose ps. You should see hermes with status Up.

Step 4. Brain dump

This is the step everyone skips. Don’t.

docker compose exec -it hermes /bin/bash
hermes setup

The wizard asks who you are, what you do, how you communicate. Spend 15 minutes on this. Tell it:

• Your role, your team, your current projects

• How you like responses (concise vs detailed)

• The tools you already use (Outlook, Teams, Notion, GitHub)

• What “done” looks like for you on a typical day

Day 30 of a well-briefed agent beats Day 90 of a poorly-briefed one. By a lot.

Step 5. Connect Telegram

In Telegram, search @BotFather (the one with the verified tick). Send /newbot, pick a name, copy the token. The username must end in bot.

Search @userinfobot next. Send /start. Copy your numeric user ID.

Back in the container, paste both into the setup wizard. Run hermes gateway run. Send your new bot “hello”. It replies.

That’s a working agent on your hardware.

What broke on the live build

The webinar wasn’t a polished demo. I was building a second Hermes instance live, in front of 10+ people. Three things broke. Each one was instructive.

1. The chat wouldn’t load. Web socket gateway error. I asked Claude Code in my terminal: “why isn’t the chat loading?” It read the container logs, found the gateway wasn’t starting, applied a patch, and told me to hard-reload the tab. Done in under a minute.

2. Missing authentication header on OpenRouter. The API key was set correctly in the dashboard but the gateway wasn’t passing it through. Same approach. Claude Code read the logs, identified the header wasn’t being injected on the chat endpoint, patched the config, restarted. Done.

3. Telegram bot wouldn’t respond. This one was my fault. During setup I’d locked the bot to my Telegram user ID, but the bot didn’t actually have my ID yet. I’d told it “only accept messages from me” without telling it who “me” was. Claude Code figured it out by checking the gateway log against the incoming message log, added my ID to the allow-list, restarted the gateway. The next message landed.

If you’re new to this, here’s what I want you to take from those three failures:

Setting up an agent isn’t a finished, packaged experience yet. You’ll hit issues. The cost of debugging is now five minutes instead of five hours, because the agents help you fix the agents.

Don’t be scared of breaking it. Docker means you can blow the whole container away and start again in 30 seconds.

Composio: the gateway that actually matters

Hermes comes with a basic plugin layer. Maybe 40 connectors out of the box. Useful, but limited.

Composio is the alternative. 1,000+ pre-built app connectors, one API key, OAuth managed for you, sandboxed execution per call.

The tagline: “Your agent decides what to do. We handle the rest.”

Why I use Composio with Hermes instead of the built-in plugins:

• More apps. Outlook, Teams, SharePoint, Notion, GitHub, Linear, Stripe, the long tail of business SaaS. Hermes’s built-in connectors don’t reach most of these.

• One auth surface. Approve OAuth once per app. Composio handles token storage, refresh, scoping. You don’t write any of that code.

• Works with any agent. Same Composio key powers Hermes, OpenClaw, Claude Code, Codex. Connect once, use everywhere.

The .env file trick

When you’re configuring Hermes via Claude Code in your terminal, never paste API keys directly into the chat. They land in the conversation history.

Drop them into a .env file in the project folder. Reference them by variable name. So instead of pasting your Composio key into the chat, you write:

COMPOSIO_API_KEY=ck_xxx_your_real_key_here
TELEGRAM_BOT_TOKEN=78xxx:AAxxxx

Then tell Claude Code: “install Composio using the key in the .env file”. The agent reads the variable name. Your actual key never appears in conversation. If a key does end up in chat by accident, cycle it immediately. Claude Code will keep reminding you to do this. That’s a feature.

Connecting your first app

Once Composio is wired in, telling Hermes to connect an app looks like this:

Connect my Microsoft Outlook via Composio with read-only access to my Inbox and Sent folder.

Composio sends back an OAuth link. You click “approve” in your browser. Done. The agent now has scoped read access to your inbox without any credentials touching Hermes.

For most readers, the apps to connect first are:

• Outlook + Calendar (if you live in M365)

• Microsoft Teams

• SharePoint + OneDrive

• GitHub (if you code)

• Notion (if you write)

Start with read-only scopes. Add write or send permissions only when you trust the workflow.

Recap

What we covered:

→ Hermes is a persistent, self-improving agent that lives on your hardware
→ Docker is a shipping container for software, and it’s the right install path for Hermes
→ The 5-step setup takes 25 minutes if you’ve never touched Docker
→ Composio is the gateway worth wiring in, because it connects you to 1,000+ apps through one API key
→ Stewart’s IT ticket review pattern is a real, replicable use case for any M365 team

The agents help you fix the agents. That’s the unlock. Set up a Hermes instance this weekend and let it surprise you next month.

What’s the first cron job you’d give your Hermes? Drop it in the comments. I’ll pick the three best and write up the implementation in next week’s post.

🔒 The rest of this post is for paid subscribers.

Below the paywall: the full Stewart’s-IT-ticket-review playbook (data sources, skill spec, cron config, security pattern), and the 7 most common Composio + Outlook scoping mistakes I’ve watched people make.

[Upgrade to read the M365 implementation in full →]

Read more

I tried to install a ten-billion-dollar product on a webinar yesterday.

It didn’t fully work.

There’s a step I missed — running the schema.sql file inside Supabase to set up the database. The kind of thing you only notice when you’re in the chat trying to load a contract and Mike says “missing table” at you.

We were ten minutes over time when I realised.

I’m telling you this upfront because the bigger lesson of yesterday’s session wasn’t actually the install. It was the frame I want every consultant — and every operator who deals with documents and reviews and synthesis — to walk away with.

So let’s start there.

The frame

Harvey AI is worth $10 billion right now. About $500M in annual recurring revenue. They sell legal AI to BigLaw firms and Fortune 500 in-house teams.

Pricing? High four figures per user per month. Two thousand bucks a seat is normal.

What does Harvey actually do? Document review. Redlining. Drafting. Research. Synthesis.

Now — and this is the bit nobody says out loud — look at that list of workflows, then look at your own week as a consultant. Strategy. M&A. Ops. Transformation. Independent advisory.

You’re doing the same shape of work. Document review. Redlining. Drafting. Research. Synthesis. Different documents.

Harvey wrapped Claude with legal-flavoured prompts and a slick UI, called it a legal platform, sold it to BigLaw for $2K/seat. They didn’t invent the underlying capability. They wrapped it for one vertical.

The platform underneath is generic.

Someone (a developer called Will Chen) noticed this. He open-sourced his own version. Called it Mike — yes, after Mike Ross from Suits, the unqualified-but-brilliant lawyer. Posted it to GitHub. 3,300+ stars later, here we are.

So this is the realisation I want you to sit with:

You’re not the customer for Harvey. You’re the customer for the platform underneath. And today, the platform is free.

The legal flavour is a thin layer. The engine — Claude or GPT or Gemini, with a RAG database, document chunking, project workspaces, and a prompt scaffolding system — is the part that’s actually doing the work. That engine can run on consulting documents just as easily as legal contracts.

The reframe (which I almost got wrong)

Now — I want to be honest about something.

When I first wrote the deck for this workshop, I had a slide that said “install Mike, sell it to legal clients, charge $5K per engagement.”

That’s the obvious move. Install something, charge for the install, scale a service.

I got corrected on this before the workshop. The angle for you — the consultant who actually attended — is the opposite.

You don’t sell Mike. You use it.

You fork the open-source repo onto your laptop. You strip off the legal-specific prompts. You load YOUR consulting documents — anonymised interview transcripts, past decks, market reports, frameworks your firm uses, briefs you’ve written. You customise the system prompts to think the way you think.

Now you have Harvey for your work.

The math, briefly:

• Mike costs ~$20/month in API credits (your own Anthropic or OpenAI key)

• Mike saves you maybe 10 hours a week on synthesis, framework drafting, deck structuring, document review

• At a $400/hr effective rate, that’s $4,000/week back

Highest-ROI tooling decision a consultant can make this year. Not even close.

The compounding part matters more, though. Every engagement you use Mike on, you learn something — a prompt that works better, a workflow that needs structure, a doc type that needs special handling. You bake those learnings into the codebase. Engagement two starts smarter than engagement one. Engagement ten starts at 80%.

This is the bit that can’t be replicated by buying Harvey. Harvey is generic for everyone who pays for it. Your fork of Mike compounds for you.

🔒 The rest of this post is for paid subscribers.

What’s behind the paywall:

→ The install playbook — the exact prompt I used in Claude Code that nearly worked (and the one extra line I’ll add next time)

→ The schema.sql gotcha — the step I missed live, and how to never miss it

→ The three customisations to fork Mike from “generic legal AI” into “your consulting stack”

→ The 30-day integration roadmap — how to actually use Mike on your next engagement, not someday

→ The community insight Rob dropped at the end of the session — Harvey Labs released sample documents you can use to benchmark your fork

→ Plus a $600 ZTB discount code for paid subs (Cohort 3 kicks off Thursday)

[Upgrade to paid →]

Read more

Three months from now, one of two things is going to be true:

You’ll still be watching AI demos.

Or you’ll have shipped something.

The gap between those two outcomes isn’t technical.

It’s structural.

The diagnosis

I get the same DM almost every week.

“I’ve been reading your newsletter for months.”

“I’ve experimented with ChatGPT and Claude.”

“I have an idea. I just don’t know where to start.”

I don’t think these people lack skill.

I think they lack a structure that turns watching into shipping.

A schedule. A cohort. Someone to ask when they get stuck. A deadline that forces a first version into the world.

Without structure, AI content is entertainment.

With structure, it’s a career change.

The two structures I’m running

I run exactly two of these right now. Both are on starting this month.

One is the deep version — 8 weeks, cohort-based, ends with you shipping a real product.

The other is the tactical version — 90-minute weekly workshops on specific skills.

Here’s how each one works, and how to pick.

Option 1 — Zero to Builder (the big one)

Starts: next week: 21st May

ZTB is my 8-week cohort-based course for non-technical professionals who want to build and ship real products with AI.

It’s the deeper transformation.

By week 8, every student has:

1. Shipped a working product to a real URL — not a demo, not a Loom video, a thing on the internet

2. Wired it up properly — database, auth, at least one external API

3. Got actual users — usually a private beta with friends, family, early customers

4. Built it without writing a line of code themselves — directing AI, not typing syntax

Here’s the rough arc:

• Week 1 — Discovering what to build (most people skip this and regret it)

• Week 2 — Visual design + brand

• Week 3 — AI communication and prompt engineering

• Week 4 — Building your first apps with Cursor

• Week 5 — Expanding with Claude Code

• Week 6 — Making it real — databases, auth, APIs

• Week 7 — Launching

• Week 8 — Productising and what comes next

This is for you if:

• You have an idea you’ve been sitting on for months

• You’ve consumed enough AI content for a lifetime

• You’re done “learning about AI” and want a deadline to ship

Spots are capped intentionally. Once this cohort is full, the next one isn’t until later in the year.

Reserve your spot → aineversleeps.net/zero-to-builder

Option 2 — The Workshops (the tactical drop-ins)

Three sessions over the next three weeks. Paid members only.

If 8 weeks is too much commitment right now, or if you want to go deep on one specific thing, the workshops are your move.

The next three are all focused on Skills — the new feature inside Claude (and other AI tools) that lets you teach the model how you work.

Think of a Skill as a permanent instruction manual the AI loads on demand. Set it up once. Every prompt from then on loads the right knowledge, the right tone, the right rules — automatically.

It’s the closest thing to having Claude permanently understand “how we do things here.”

Each workshop is:

• 60 minutes, live

• Practical — bring your laptop, walk out with a working Skill

• Recorded, in case you can’t make it live

• Hosted in Skool so we can keep the conversation going after

Sign up → aineversleeps.net/workshop/skills

The bundle for paid Substack subscribers

Here’s the part most paid subscribers don’t realise.

If you’re already a paid subscriber to this newsletter, you also get access to all three workshops in Skool. Included.

You don’t pay for the workshop separately.

You don’t sign up twice.

It’s part of your existing sub.

If you’re a paid sub right now and you can’t see the workshops in your Skool dashboard — just reply to this email or DM me on Substack and I’ll sort it out. Sometimes the Skool invite needs a manual nudge if you signed up after a workshop was already published.

If you’re on the free tier and you want in — upgrading is the cleanest move. Workshops, archive, the lot.

Which one is right for you

Quick decision tree:

1. You have an idea and you want to ship it in the next two months. → Zero to Builder. That’s the whole reason it exists.

2. You want to deep-dive on one specific skill in 90 minutes. → A workshop. Pick the one that matches what you’re trying to learn.

3. You’re a paid Substack sub already. → The workshops are already in your sub. Use them. Then if a real project starts brewing, ZTB is the next layer.

4. You’re new to all of this and not sure where to start. → Start with one workshop. If it lands, ZTB next cohort.

The one combination I’d actually recommend?

Join one workshop this month + sign up for ZTB starting next week. The workshop gives you a quick hands-on win to prove the workflow. ZTB gives you the structure to actually ship something real.

One more thing

I want to be honest about why I’m pushing this now.

The window for “I’m just learning AI” is closing.

Six months ago, that was fine. Twelve months ago, that was leading.

In 2026, the people who are going to win the next decade aren’t the ones reading more about AI.

They’re the ones who shipped something this quarter.

And they’re going to compound on that for years.

Pick one of these structures. Show up. Build.

That’s how this year goes for the people who actually move.

Quick links

→ Zero to Builder (cohort starts next week): aineversleeps.net/zero-to-builder

→ Skills Workshops (paid members): aineversleeps.net/workshop/skills

→ Already paid? Workshops are included — ping me if Skool access isn’t showing.

https://www.skool.com/ai-builders-club-5018/about

12 months ago, I couldn’t code.

Now I’m rendering branded promo videos by typing sentences, in English.

No Premiere. No After Effects. No timeline scrubbing.

Just prompts.

What I’m About to Show You

I ran a webinar last Friday walking through this live.

By the end of a single session I had:

1. A simple text animation (10-second “Welcome to my channel - AI Never Sleeps” intro)

2. A 15-second branded promo, generated by pointing the AI at my website

3. A version of that promo with a full ElevenLabs voiceover

4. A captioned version with karaoke-style word highlighting

5. A 3D version of my logo with a glitch effect

Total time: about 45 minutes.

Total prompts: under ten.

Cost: my Claude subscription and one ElevenLabs API call.

The Hook That Made Me Take This Seriously

There’s a YouTube channel called Fire Ship.

Four years ago he posted a video saying he’d thrown away Premiere and After Effects and was editing entirely with JavaScript code.

The framework he used was called Remotion.

His pitch: a video is just a function of images over time, and React is great at describing things that change over time. So why not use it to describe video?

Four years ago I watched that and thought: cool, but that’s for developers.

Today, with Claude Code, it’s for anyone who can describe what they want.

That’s the unlock.

What Just Changed

Two pieces.

Remotion = React for videos. Every frame is rendered programmatically. Anything you can build on the web — text, shapes, animation, gradients, 3D — you can put in a video.

Claude Code = an agent that lives inside your editor. Reads your files, writes code, runs commands, and iterates with you in plain English.

Put them together and the pipeline collapses.

Old way:

Storyboard → record → cut → motion graphics → titles → audio mix → render → re-cut. Half a day.

New way:

Prompt → preview → tweak → re-prompt → render. Minutes per pass.

The whole pitch in one stat: 3–6 hours becomes minutes.

That’s not a productivity gain. That’s a category change.

The Workflow Loop

Five steps, and you’ll repeat them 5–10 times before a polished output:

1. Describe what you want

2. Claude writes React code

3. Remotion renders the preview live

4. You give feedback

5. Claude adjusts — repeat — then render the MP4

Don’t expect perfection in the first go. Even with great prompts, plan on a handful of iterations.

That’s still 10x faster than manual editing.

The Real Unlock: The Remotion Skill

A skill is an instruction manual the AI loads on demand.

Anthropic, OpenAI’s Codex, and Vercel all maintain official Remotion skills. They live in your project at .claude/skills/remotion/ and contain best practices for timing, audio, 3D, image handling, and more.

Critically: skills only load when relevant. So you keep your context clean and your tokens low.

Always start prompts with: “Use the Remotion skill to...”

That tells Claude to load the manual before doing anything.

Setup (Three Minutes, Not Thirty)

Here’s everything you need:

1. Claude Pro subscription ($20/month)

2. VS Code (or Cursor, or any IDE you like)

3. Node.js (free — runs the npx commands)

4. Git (free — for version control)

If you don’t know what any of those are, ask Claude or Cursor to install them for you. They’re all safe.

Then run one command in your terminal:

npx skills add remotion-dev/skills

This is Vercel Labs’ skills CLI. It pulls the official Remotion skill from GitHub and drops it into .claude/skills/remotion/.

Quirk to know: it auto-installs for Cursor, Codex, and Deep Agents — but for some reason you have to manually select Claude Code from the list (spacebar to toggle).

Pick “this project” + “symlink” + “install now” and you’re done.

That’s the entire setup. Three minutes.

Your First Video (Free Demo)

Here’s the prompt I used to test it:

“Use the Remotion skill to create a simple video with the text ‘Welcome to my channel — AI Never Sleeps’ that fades in over 2 seconds. Make the text large, white, and centered on a dark background.”

Boring on purpose.

I wanted to see what Claude does with the most basic ask.

Three minutes later: a black background, white text fading in, “Welcome to my channel — AI Never Sleeps.”

Done.

It also installed the dev server so I could preview interactively, ran a check on frame 60 to verify the output matched my spec, and rendered it as an MP4.

That last part is what actually surprised me. The skill makes Claude check its own work. Not because I told it to. Because the skill said to.

That’s the difference between “AI that codes” and “AI that knows the framework.”

🔒 The rest of this post is for paid subscribers.

What’s behind the paywall:

→ The URL trick: how to point Claude at your website and get a 15-second branded promo with your colors, copy, and assets — all extracted automatically

→ Adding ElevenLabs voiceover in one prompt (with the exact .env setup I use)

→ Whisper captions with karaoke-style word-level sync

→ 3D logo animations using React Three Fiber + glitch post-processing

→ The honest part: where the workflow broke, what I did, and the prompt that finally got it right

→ The prompt templates I use across all of these — copy/paste ready

Read more

I’ve been quietly waiting for a moment like this for two years.

The moment where the gap between “I have an idea” and “people can use it” finally collapses to something a normal person can do on a Saturday afternoon. Not a developer. Not a designer. Just someone with a problem worth solving and an internet connection.

Anthropic shipped Claude Design at the end of April, and after a weekend of testing, I cancelled my Figma subscription on the Monday morning. Not because Figma is bad. It isn’t. It’s because for what I actually do, which is move ideas, not pixels, Claude Design plus Claude Code makes the entire production pipeline collapse into one clean handoff.

This post is the workflow. Three phases, three tools, one ecosystem. I’ll show you exactly what I type, exactly which file goes where, and exactly how much it costs in tokens. By the end, you’ll have a repeatable system you can run this week.

If you’ve ever paid a dev shop $30,000 to build something you could have validated in a weekend, this one’s for you.

What changed

Claude Design is a research preview that turns natural language into production-ready design. Slide decks, landing pages, mobile prototypes, motion graphics, full design systems. Everything renders in real HTML and CSS, not as a static mockup, which means consistency is enforced via an actual stylesheet. Buttons look the same on every page. Spacing follows a grid. Typography has a system. The output is clickable, navigable, and indistinguishable from a real product when you demo it.

Two things make this different from the Lovable / v0 / Bolt class of tools that have been around for a year:

One, the design quality. I’ve tested most of them. Claude Design produces output that’s noticeably more polished and more opinionated. There’s clearly a review and polish step in the harness that the others don’t have. Output is not perfect, a senior front-end designer will still beat it, but for the rest of us moving from idea to first impression, it’s a step change.

Two, the handoff. Lovable produces a nice mockup and that’s the end of the road. Claude Design hands off to Claude Code with one click, where you can wire up Stripe, Supabase auth, Vercel deploys, transactional email, analytics, the full production stack, without leaving the Anthropic ecosystem. That continuity is the unlock.

The proof: in the last two weeks I’ve used this workflow to ship transcriber.net (a live audio transcription tool with magic-link auth, Stripe billing, and usage dashboards), a JD generator for a client, an anonymous staff feedback upvote tool, and a regulatory compliance dashboard for Australian credit lenders. Each one took between 90 minutes and a few hours.

Let me show you how.

The three-phase workflow

Everything stays inside Claude. Claude Chat for thinking. Claude Design for the visual. Claude Code for the build.

The reason it all hangs together is connectors. Set up once at claude.ai/settings, work everywhere. My active connectors right now: GitHub, Gmail, Calendar, Stripe, Vercel, Supabase, Cloudflare, Microsoft 365, Sentry, HubSpot, n8n, PostHog. Each one used to be a fiddly MCP server setup. Now it’s two clicks. Skills travel the same way, set up once, available across Chat, Co-work, and Code.

Here’s the flow:

Phase 1: Claude Chat (refine the idea, write two source-of-truth files)

This is the phase nobody talks about and it’s the most important one.

I open a fresh Claude Chat. Not a project, not a Co-work session with memory, a clean slate so the model thinks broadly without baggage from past conversations. Sometimes I start from a transcript of a brainstorm I had with someone. Sometimes I start with a deliberately vague prompt designed to surface ideas I haven’t had yet.

Here’s a real one I used a few weeks ago:

“Based on what you know about me, I want you to think hard about the most scalable, one-person, fully automated, AI-native business I could create. Give me the top five ideas.”

Notice the looseness. When I want divergent thinking, I keep prompts short and ambiguous so the model surprises me. The first round usually comes back generic, “vertical AI agent, micro-SaaS, programmatic SEO.” That’s fine. I push back, bounce ideas into ChatGPT for a second opinion, bring the best ones back to Claude. The cross-pollination matters.

That specific session is how I landed on a regulatory SaaS for non-major Australian credit lenders, tracking ASIC, APRA, AFCA, AUSTRAC, Treasury, and parliamentary output in one dashboard. Real problem, hard to solve, worth a website.

Once the conversation has shape, usually 10 to 15 messages of back-and-forth on positioning, ideal customer profile, problem, differentiator, offer, pricing, and call to action, I ask for two markdown files:

1. business-plan.md, positioning, target customer, pricing tiers, customer journey, unit economics, go-to-market, tech stack, architecture decisions. This is the source of truth for the product.

2. design.md, the pages I’ll need (home, pricing, dashboard, sign-in, etc.), the sections within each page (hero, features, social proof, FAQ, footer), tone, visual references, any specific UI patterns. This is the source of truth for the look and feel.

Why split them? Different jobs, different tokens. Claude Design’s job is to produce the prettiest, most consistent UI possible. Loading it up with pricing economics and architecture decisions wastes design tokens (which are expensive, more on this below) and confuses the output. Claude Code’s job is to make it work. It needs the business and architecture context, not the styling rationale.

Phase 2: Claude Design (visual mockup only)

URL is claude.ai/design. Took me longer than it should have to find that.

I open a new prototype, set fidelity to High, and paste the design.md file in as my first message. That’s it. I don’t tell it what to do. It figures out from the file that it’s supposed to build a mockup.

The output is usually 80% of the way there in the first generation. Multi-page, navigable, internally consistent, on-brand if the brand was specified. For the regulatory SaaS, the first version was decent but felt a bit generic, so I gave it one more prompt: “make it look more like the ATO or the ASX, more institutional.” Second version came back with a stock-ticker style scrolling regulator update bar across the top, a brief page laid out by regulatory body, a taxonomy of obligations, and a clean sign-in flow. Out of the box, two prompts, looked like a real product.

Rule of thumb: one or two prompts maximum, then leave it. Iterate in Claude Code instead. I’ll explain why in the next section.

Phase 3: Claude Code (production wiring)

When the mockup is good enough (not perfect, good enough), I click Share, Hand off to Claude Code, copy the command, paste it into a fresh Claude Code session in VS Code, and say “create this site for me.”

Claude Code pulls the zip, extracts the design package, and lays out the project. Occasionally it gets confused about the zip and you’ll need to nudge it. The handoff link expires after a short window, so if you’ve left it sitting, just regenerate.

Then I drop the business-plan.md into the project root and give Claude Code one more instruction:

“Read business-plan.md. Build all of this out. Use Next.js on Vercel, Supabase Postgres for data, Stripe for billing, BetterAuth with magic links for auth, Resend for transactional email. PostHog for analytics. When you’re done, write a test plan and run it across every page.”

I don’t sequence the steps. Modern Claude Code with the right plugins (Superpowers especially) clarifies, plans, and executes in order on its own. It’ll come back with clarifying questions where it needs them, then go quiet for 20 to 40 minutes while it builds.

That’s the whole workflow.

Token economics (the part nobody tells you)

Here’s the rough edge: Claude Design tokens are a separate pool from chat and code tokens, and they burn way faster than you’d expect.

I’m on the Max plan, the 20x tier, and I’ve still hit the cap. From my own usage tracking:

Output% of weekly Design limitSimple slide deck or PowerPoint4 to 6%Landing page with tweaks10 to 15%15-screen mobile prototype (the staff feedback tool)~11%Full design system (buttons, colors, type, spacing tokens)~25%Motion graphics with interactions~15%

If you blow through the limit, flip on Extra Usage in settings and bump your monthly overspend cap. I’ve had to do it. Several friends have too.

Two ways to save tokens:

One, start a new chat each time. Claude Design will literally prompt you with “start a new chat to save 10,000+ tokens of context.” Listen to it.

Two, don’t iterate in Design, iterate in Code. Typo fixes, color tweaks, copy changes, layout adjustments are all faster, cheaper, and more controllable in Claude Code or Cursor. Claude Design re-renders the entire page using Opus 4.7 vision plus code, which is why each iteration is so expensive. Claude Code makes the change in place, no re-render.

This single rule, “design in Design, iterate in Code,” is probably worth the price of a Max subscription on its own.

The tweaks trick

When Claude Design finishes, you get a Tweaks panel by default with maybe 5 to 7 controls. Light/dark mode, accent color, font choice, the basics.

Trick one: ask for “an aggressive amount of tweaks” and you’ll get 10 to 15 controls covering text size, container width, spacing, radius, the works. Same prompt, way more granularity.

Trick two: ask for “three macro variants” and specify the directions. My favourite combination is editorial, brutalist, and drenched. Editorial is calm and magazine-like, lots of whitespace. Brutalist is loud, geometric, monospace, no rounded corners. Drenched is saturated colour, full-bleed imagery, high-contrast typography. Now you can compare three completely different aesthetic directions side by side without re-prompting from scratch.

What I never do in Claude Design: push for pixel-perfect output, iterate through 15 tweak panels, re-prompt the layout, fix typos. All of that is Claude Code work.

Examples I’ve shipped

transcriber.net is live. Drag and drop an audio file, get a transcription back. Magic link auth (with a button that opens Gmail straight to the magic link, a small touch Claude Code added on its own initiative), Stripe billing, transcript history, API keys, usage tracking, audio retention controls. Designed in Design, wired up in Code. About 90 minutes total.

JD Machine is a client tool that pulls from a RAG of their org chart, operating model, capability framework, and tone of voice standards, then generates draft job descriptions. Inputs are department, seniority, optional reference JD. Output uses Opus and matches their internal style. The dashboard came out of Claude Design in one shot. When we demoed it, the reaction was “this is amazing,” even though half the buttons don’t actually work yet. The feel sells the idea.

Regulatory SaaS is the one I mentioned earlier, the lender compliance dashboard. Not deployed yet, just the design, but I’ve used it to validate the idea with two potential customers already. Both wanted in.

The pattern across all of them: the design phase produces something good enough to start a real conversation with a real customer. That’s the unlock. You’re no longer pitching an idea. You’re pitching something that looks like a product.

What this changes

Five years ago, the answer to “should I build this idea?” was a six-week dev shop engagement and $30k of risk. Two years ago it was a $5k Lovable prototype that was basically a fancy slide deck. This week it’s 90 minutes, a Max subscription, and a coffee.

The bottleneck has fully shifted. It’s no longer the building. It’s knowing what to build, who it’s for, and whether they’ll pay. Which is exactly where it should have been the whole time.

If you’ve been sitting on an idea for months because the build felt too expensive or too risky, the cost of finding out has just collapsed to almost zero. Stop sitting on it.

What’s behind the paywall

The free portion above is the workflow at conceptual level. Below the paywall I’m putting the operational kit so you can run this exact workflow yourself this week:

• 🎥 Full video recording of the live webinar (90 minutes), including the live build of the regulatory SaaS dashboard and the transcriber.net walkthrough

• 📊 Slides from the session

• 📝 My exact Phase 3 prompt, the verbatim text I paste into Claude Code after the design handoff, with annotations on which lines to adjust per project

• 📄 Templates for both markdown files (business-plan.md and design.md) that you can fill in for your own ideas, including the section headers I use and the questions I ask in each

• 🎯 The “macro variants” swipe file, my collection of design direction prompts beyond editorial / brutalist / drenched, with screenshots of what each one produces

If you’re going to ship even one product using this workflow, the paywall content pays for itself in tokens saved on the first build.

Read more

Two weeks ago I posted about getting your second brain set up. The architecture. The agents.md file. The hooks. The three-layer model.

A lot of you built it. My inbox proved it.

The most common follow-up question wasn’t “did I do it right?” It was “OK… now what?”

That’s actually the right question. The hard part of this system isn’t the build. The build is one webinar long. The hard part is what you put into it - and what other brains you’re not building yet because you haven’t realised they’re possible.

This post is for you if you set yours up last week and you’re staring at an empty raw/ folder. It’s also for you if you didn’t, but want to skip ahead to “what’s the actual payoff after you have one.”

I taught the full setup live last Friday to the paid community. The recording, the Python scripts I’ll talk about below, and a step-by-step walkthrough of how I wire it all together are at the bottom, behind the paywall.

Friday: what actually happened

We had people on from Sydney, Singapore, Hong Kong, and the UK. Mixed setups. One person didn’t have Claude Code (it’s blocked in Hong Kong and they hadn’t sorted a VPN), another had Cursor, another was on Codex.

Didn’t matter. We built it anyway. The pattern is tool-agnostic. If your AI can read and write files on your computer, this works.

Two things surprised me from the live session.

First, I underestimated how much friction the very first setup creates. People got stuck on tiny things - where Obsidian’s settings menu lives, which folder path to copy, whether Claude Code “saw” the right directory. The runbook I’d prepared assumed too much.

Second, the moment people got it. There’s a specific second when Claude finishes scaffolding the system and starts writing wiki pages from your raw files - and you watch your file tree fill up in Obsidian’s sidebar. That moment is the (AI) unlock.

Tom’s question: when do I split into a new vault?

He asked the question I should have addressed in last week’s post.

His version: “I could put everything in one vault and let it organise itself. Or I could split. Personal stuff over here. Business stuff over there. How do you decide?”

My answer, refined now that I’ve had time to think about it:

Use one vault when the connections between domains are valuable. If you take notes on a book about negotiation, you actually want that to influence your client strategy pages. If you read a piece on parenting, you might want it to surface when you’re thinking about how you manage your team. The graph view is at its most useful when seemingly unrelated nodes turn out to be connected.

Use separate vaults when one of these is true:

• The data has compliance implications (client PII, regulated information, anything you can’t safely sync to cloud storage)

• The contexts genuinely don’t overlap (your side project’s customer database has nothing to do with your reading list)

• You want to share a vault with someone else and don’t want them to see everything

For me right now: one vault for everything personal, professional, and creative. A completely separate stack for Pear’s customer data - that’s not in Obsidian at all, it’s in a real database with auth.

The default should be one vault. You can always split later. You can’t easily merge a split.

Six other brains worth building

This is the section I wish I’d written last week.

Once the system is running, “what should I put in raw/?” stops being the right question. Every domain in your life is a brain you could build. Here are six I think are worth your time. Some are obvious. A couple aren’t.

The relationship brain.

Every meeting note. Every coffee chat. Every name your partner mentioned about a friend’s kid. Drop it all in. The wiki builds a graph of everyone you know - their kids, their projects, what they were worried about last quarter. Next time you bump into them at a conference, you walk in remembering.

Most relationships die from forgotten details. This brain saves them.

The deal archive.

Every term sheet you’ve reviewed. Every contract you’ve signed. Every shareholder letter from a board you sit on. Six months in, you can ask “what’s the most unusual liquidation preference I’ve seen?” and get the answer from your own data. Twelve months in, you have pattern recognition no MBA can teach.

If you sit on multiple boards, this is the brain that turns experience into asymmetric information.

The book companion.

Pick one book that matters to you. Sapiens. The Power Broker. The Bible. Whatever. Ingest it chapter by chapter and let Claude build pages for characters, themes, ideas, contradictions.

You end up with a personal Tolkien Gateway for the things you actually care about. And it gets richer every time you re-read.

The pre-mortem vault.

Every prediction you make about your business goes in. “I think this product hits $50K in month one.” “I don’t think this hire lasts six months.” “I think the market shifts by July.” Then six months later, ask Claude what you got right and what you got wrong.

This is the most uncomfortable brain you can build. It’s also the one that makes you a better operator than anything else. Most of us never confront our own forecasting record. Now you can.

The competitor watchpost.

Drop every press release, earnings call transcript, podcast interview, and LinkedIn post from your top five competitors. Run it weekly. Ask Claude “what’s changed in their positioning this month?” or “where are they now contradicting themselves?”

Your competitors will not do this for you. The asymmetry is wild.

The legacy vault.

Your parents’ stories. Family recipes. The names of relatives in old photos. Where you grew up. What your grandparents did during the war.

Build this one now - before the people who hold the memory are gone.

This is the brain my kids will inherit. None of the others matter as much.

The bottleneck nobody talks about

Once you’ve decided what brain you’re building, you hit the next wall.

Feeding it is slow.

The Web Clipper handles articles. Otter handles meetings. Your own writing goes in easily. But there’s a giant category of content most people give up on: long-form video and podcasts.

I watch a lot of YouTube. I want my second brain to learn from those videos - not me sitting there taking notes, just the content of the videos. But manually downloading transcripts, cleaning them up, and dropping them in is grinding work that nobody actually does. So that knowledge stays locked in YouTube and never makes it into the brain.

I built two Python scripts to fix this.

Script #1: I type a topic. The script searches YouTube for 20 tutorials, filters to the top 15 by view count (10K+ views minimum), pulls every transcript through a residential proxy (more on that below), caps the total at ~100K tokens of content, and asks Claude to synthesise everything into one structured 11-section learning guide.

One topic in. One markdown file out. The file goes straight into raw/. My second brain learns whatever I’m researching faster than I could read the source material myself.

Script #2: It takes a guide produced by the first script. Uses Claude Opus to identify 3-10 sub-topics worth deeper research. Then runs the YouTube pipeline again for each one. Outputs a folder of deep-dive guides with a README index.

I’ve used these to build learning guides on:

• “How to grow on Substack”

• “Setting up multiple Claude Code agents in parallel”

• “Dividend growth investing”

• “How to write a startup pitch deck”

• “How to lose weight in your 40s” (don’t judge)

• “How to market on Reddit (organic, not paid)”

Each one is the synthesis of 15+ hours of YouTube content, condensed into a single document my second brain can reason over.

The trick that makes this actually work: a residential proxy for the transcript fetch. YouTube heavily rate-limits transcript requests from non-browser clients. Without a proxy, the script breaks after a couple of videos. Webshare residential proxies cost about $6/month and solve it permanently. Worth every cent.

This is the workflow I think is going to define the next 12 months of how I learn. I’m getting smarter at the rate Claude can synthesise YouTube. That’s a different rate than I used to get smarter at.

What’s changed in 4 weeks of using this

I want to be honest about what’s working and what isn’t, now that I’ve been running this for a month.

What’s working:

The morning context dump is gone. I open Claude, ask my question, it already knows what I’m working on. Saves me ~10 minutes per session, multiple times a day.

Decisions don’t get re-litigated. When I made a pricing decision in March, the wiki has that page, with the reasoning. When I question it again in April (we all do this), Claude pulls the original reasoning instead of helping me re-debate from scratch.

I’ve started catching my own contradictions. The contradiction-flagging in the agents.md file actually fires. Twice in the last two weeks Claude has said “this seems to disagree with what you wrote in [X]” and both times it was right. Both times I’d forgotten I’d thought differently before.

What’s not working yet:

The graph view is pretty but not actually useful in my daily workflow. I open it maybe twice a week. I think it’ll matter more at 6+ months when the density is higher.

I haven’t run a maintenance lint in 3 weeks. I’m overdue. The system needs the lint to stay healthy and I keep deprioritising it. Setting a calendar reminder for Sundays this week.

I still occasionally hand-edit wiki pages when I see something obviously wrong. I know I shouldn’t. The discipline of “let Claude organise it, don’t touch it” is harder than I thought.

The big lesson: this is a 12-month system, not a 12-day one. The compounding only happens if you keep feeding it. Build it for what you’ll have at month 6, not month 1.

Paid subscriber section

The full Friday webinar recording, both Python scripts, and the wiring instructions are below for paid subscribers.

Read more

Every morning I open Claude Code and explain the same things.

“Here’s my business.” “Here’s my voice.” “Here’s what we built last week.” “No, we decided against that approach three sessions ago.”

It’s like hiring a brilliant employee with amnesia. Every day is their first day.

Claude Code has memory. CLAUDE.md files. Project context. But let’s be honest -- it forgets. It confidently makes things up. And the longer you work with it, the more you notice the gap between what it knows in this session and what it should know from last week.

Then Andrej Karpathy published a solution. It got almost 20 million views.

If you don’t know who Karpathy is: he’s one of the most important people in AI. He was the founding member of OpenAI. He built and led Tesla’s Autopilot vision team. He was head of AI at Tesla for five years, directly reporting to Elon Musk. Before that, he trained under Fei-Fei Li at Stanford, working on some of the foundational research in deep learning and computer vision. His Stanford CS231n course on convolutional neural networks basically taught an entire generation of AI engineers.

When Karpathy shares how he personally uses AI tools, people pay attention. This isn’t a YouTuber reviewing the latest shiny thing. This is one of the architects of modern AI showing you how he organises his own knowledge.

And his solution is disarmingly simple.

It’s not a fancy RAG pipeline. It’s not a vector database. It’s Obsidian -- a free note-taking app -- connected to Claude Code through a few markdown files and some hooks.

I set it up last week. It changed how I work with Claude.

Here’s the full setup.

Why This Matters More Than You Think

The problem isn’t that Claude is dumb. It’s that Claude has no long-term memory.

Every session starts fresh. Claude reads your CLAUDE.md, reads whatever files you point it to, and does its best. But it doesn’t remember that three weeks ago you decided to use Supabase instead of Firebase. It doesn’t know that your newsletter performs best on Tuesdays. It doesn’t remember that the last time you tried that approach, it broke the checkout flow.

You end up being the memory. And that means you spend 10 minutes at the start of every session catching Claude up. Or worse, you don’t -- and Claude makes decisions based on incomplete information.

What Karpathy built solves this.

Instead of Claude starting fresh every session, it starts by reading a structured wiki that contains everything it’s learned from every previous session. Decisions. Lessons. Architecture choices. What worked. What didn’t.

And the wiki updates itself. Every session adds new knowledge. Every question asked gets the answer filed away. Next time you ask something related, Claude finds it in the wiki instead of guessing.

Knowledge compounds. That’s the shift.

The Architecture (Simple Version)

Forget vector databases. Forget embeddings. Forget Pinecone (for now).

The entire system is three things:

1. A raw sources folder. Articles, transcripts, PDFs, web clips. Stuff you want Claude to know about. You dump it here.

2. A wiki folder. Claude-written summaries, linked markdown files, cross-referenced concepts. This is the brain. Claude reads from it. Claude writes to it.

3. A rules file. Conventions, workflows, and instructions that tell Claude how to maintain the wiki. Think of it as the operating manual for the brain.

That’s it. Three folders. Markdown files. No infrastructure.

Here’s the mental model that clicks:

• CLAUDE.md = Who I am (identity, rules, read-first instructions)

• Obsidian wiki = How I think (decisions, patterns, connections, active projects)

• Raw sources = What I’ve read (articles, research, transcripts)

Claude reads CLAUDE.md to know who it’s working for. It reads the wiki to know what it already knows. It reads raw sources to learn new things and file them into the wiki.

Step 1: Install Obsidian (2 minutes)

Download Obsidian from obsidian.md. It’s free.

https://obsidian.md/

Create a new vault. Call it whatever makes sense for your use case. I have one for AI Never Sleeps (content, business decisions, audience insights) and I’m considering a second for Pear (product decisions, tech stack, partner notes).

One domain per vault. Don’t put everything into one mega-vault. Keep it focused.

Inside your vault, create this folder structure:

my-second-brain/

agents.md # Rules and instructions for Claude

index.md # Catalog of everything in the wiki

raw/ # Unprocessed sources you want Claude to learn from

wiki/ # Processed, linked knowledge (Claude writes here)

logs/ # Daily session summaries (auto-generated)

That’s the skeleton. Claude will fill it in.

Step 2: Write Your agents.md File (15 minutes)

This is the most important file in the system. It tells Claude what this wiki is for, how to maintain it, and what conventions to follow.

Here’s the structure I use:

Spend time on this. It’s the onboarding document for your AI employee’s permanent memory. The better this is, the smarter every future session becomes.

Step 3: Create Your index.md (5 minutes)

The index is the table of contents. Claude reads this first to understand what exists in the wiki and where to find it.

Start simple:

As you add sources and have sessions, Claude will expand this. Within a week, you’ll have a rich index that Claude navigates like a map.

Step 4: Set Up Claude Code Hooks (10 minutes)

This is where it gets powerful. Claude Code has hooks -- scripts that run automatically at the start, during, and at the end of every session.

Open your Claude Code settings (in .claude/settings.json or via the CLI) and add:

Session Start Hook: Load agents.md and index.md into context at the beginning of every session. Claude starts every conversation already knowing what’s in the wiki.

Pre-Compact Hook: Before Claude’s context gets compressed (when you hit the context limit), capture the conversation as a log entry. This prevents losing important context during long sessions.

Session End Hook: Summarize the session -- decisions made, lessons learned, action items -- and save it to /logs/YYYY-MM-DD.md. Then update any wiki pages that were affected.

The hooks mean you don’t have to remember to tell Claude to update the wiki. It happens automatically. Every session contributes to the brain.

Step 5: Feed It Your First Sources (20 minutes)

Drop some raw sources into the /raw folder. Articles you’ve saved. Meeting transcripts. Research notes. Strategy documents.

Then tell Claude:

“Read everything in /raw. For each source, extract the key concepts. Create or update wiki pages in /wiki for each concept. Link related concepts together. Update index.md.”

Watch what happens.

One article about AI agent orchestration might create wiki pages for: “agent orchestration,” “Paperclip,” “heartbeat systems,” “delegation vs creation,” and “multi-agent feedback loops.” Each one linked to the others. Each one cross-referenced in the index.

The next article you add? Claude doesn’t create duplicate pages. It updates existing ones with new information. It flags contradictions. It adds connections you might not have seen.

This is compounding knowledge. One source updates ten wiki pages in a single pass.

Step 6: Start Using It (Ongoing)

From now on, every Claude Code session starts with context from the wiki. You don’t explain your business model again. You don’t re-describe your tech stack. You don’t remind Claude about the decision you made last Tuesday.

It already knows.

Ask questions: “Based on our wiki, what content topics have we identified as high-performing?” Claude searches the wiki, pulls relevant pages, synthesizes an answer. Ten seconds. No sub-agents spinning up.

Make decisions: “We’re switching from Resend to Usesend for email. Update the wiki.” Claude updates the relevant wiki pages, adjusts cross-references, and the next time email comes up, it already knows the current stack.

Build on previous work: “Last week we designed the Paperclip agent prompts. Refine the CEO prompt based on what we learned in the webinar.” Claude pulls the wiki page, reads the session logs from the webinar, and gives you an informed refinement -- not a cold start.

Common Mistakes to Avoid

Mistake 1: Dumping 10,000 files into the raw folder.

This system works beautifully up to about 100 files. Past that, the index gets expensive to load (every file name costs tokens). For large archives -- thousands of YouTube transcripts, years of articles -- use a vector database like Pinecone as the archive layer. Keep Obsidian for active, working knowledge.

Mistake 2: Not writing a good agents.md.

If your rules file is vague, your wiki will be vague. Spend 15 minutes writing clear conventions. It pays back every session.

Mistake 3: Never running maintenance.

Every couple of weeks, tell Claude: “Run a wiki lint. Check for stale pages, contradictions, orphan pages with no links, and outdated information.” This keeps the brain healthy. Without it, information drifts and you start getting confident-but-wrong answers.

Mistake 4: Putting everything in one vault.

Your AI business notes and your personal reading list are different contexts. Separate vaults. Separate agents.md files. Separate wikis. Claude performs better with focused, domain-specific knowledge.

The Three-Layer Model

After running this for a week, here’s how I think about the full stack:

Layer 1: CLAUDE.md -- Who I am. Voice, identity, rules. Never changes much. This is the constant.

Layer 2: Obsidian wiki -- How I think. Active projects, decision logs, idea connections, lessons learned. This is where reasoning happens. Updated every session.

Layer 3: Vector database (Pinecone or Pgvector (postgres))

) -- What I’ve consumed. Transcripts, research archives, books. This is for exact recall of specific passages. Queried occasionally.

Think of it as:

• CLAUDE.md = personality

• Obsidian = working memory

• Pinecone = long-term archive

Most people only have Layer 1. Adding Layer 2 is the change that compounds.

What’s Coming Next Week

This week: you’ve got a second brain running locally.

Next week’s webinar: I’m going to show you how to set this up and also connect this to your OpenClaw bot so you can access your knowledge base from anywhere. Phone. Telegram. Discord. Your AI has a brain AND you can talk to it from the couch at 10pm.

Same wiki. Same knowledge. But now it’s accessible through a persistent agent you can message, not just a terminal session you have to sit in front of.

That’s when it gets real.

🔒 The section below is for paid subscribers.

Paid subscribers get my complete agents.md file (the actual one I use, not a template), the hook scripts for automatic session logging, and the maintenance prompt I run every two weeks.

Read more

Last week I published The Zero Employee Business Blueprint. Nine building blocks to run a product with no staff.

The response was clear: people got the vision. But one question kept coming up.

“How do you actually coordinate all of this?”

Fair question. Having nine automated layers is great. But someone still needs to assign the work, check the output, and make sure the right agent is doing the right thing at the right time.

That someone was me. Manually. Every morning.

Not anymore.

Today I’m going to walk you through Paperclip -- the orchestration layer I teased at the end of last week’s post. I ran a live webinar this morning where I built an AI company from scratch in front of a room of paid subscribers. Sixty minutes. Five agents. Real tasks. Real output.

Here’s everything that happened.

What Is Paperclip?

If you’ve used Claude Code, you already understand the building block. Claude Code is one very capable employee. You sit next to them. You give instructions. They execute. Tight feedback loop. Very interactive.

Paperclip is the company those employees work inside.

Instead of one agent, you have five, ten, fifteen -- each with a specific role, a specific set of instructions, working on different things simultaneously. And critically, they talk to each other. The CEO delegates to the engineer. The researcher hands findings to the writer. The reviewer checks the writer’s work before it comes to you.

You’re the board of directors. You set direction and review output. You don’t do the work.

Website is here: https://paperclip.ing/

Github repo is here: https://github.com/paperclipai/paperclip

Here’s the key distinction that most content about Paperclip gets wrong:

Paperclip is a delegation tool, not a creation tool.

If you’re building something from scratch -- a new app, a new website, a new product -- you want Claude Code. You need the tight feedback loop. The iterative dance. “Not like that.” “Actually, let’s pivot.” “Make the header bigger.”

But once something exists? Once you’ve got established workflows, repeatable processes, things that need to happen every day or every week?

That’s where Paperclip takes over.

What I Built in the Webinar

I deployed a brand new Paperclip instance on Railway, created a company, hired agents, configured them, and assigned real work. All live. Here’s the play-by-play.

Step 1: Deploy on Railway (2 minutes)

No SSH. No Docker. No server configuration.

I used a one-click Railway template that deploys two things:

1. Paperclip server -- the dashboard and agent orchestration

2. PostgreSQL database -- stores companies, agents, tasks, and state

Railway asked for environment variables:

• DATABASE_URL -- auto-populated from the Postgres instance

• BETTER_AUTH_SECRET -- auto-generated security key

• ANTHROPIC_API_KEY -- my Claude API key (you need at least one LLM key)

Two minutes. Hit deploy. Done.

Here is the template: https://railway.com/deploy/paperclip-2

Why Railway and not your personal machine? These agents have shell access. Full root control. They can read files, run commands, access the network. That’s powerful and dangerous if something goes sideways. Railway sandboxes everything in containers. Your machine stays clean.

Step 2: Create the Company (5 minutes)

Paperclip asks for a company name and a mission statement.

The mission is the single most important thing you write. It’s what the CEO agent uses to make every decision -- what to prioritise, what to delegate, what to create when there’s nothing in the queue.

What I used:

“Grow the AI Never Sleeps brand by automating content research, newsletter creation, social media analysis, and audience engagement tracking. Focus on LinkedIn, Substack, and YouTube.”

Specific. Measurable. Clear scope.

What doesn’t work:

“Help me grow my business.”

Vague mission = confused CEO = wasted tokens.

Step 3: Hire the Team (10 minutes)

I didn’t create agents manually. I created one issue, assigned it to the CEO, and let the CEO hire its own team.

The issue:

“Hire four employees: (1) a Content Researcher who analyses trending topics and competitor content, (2) a Newsletter Writer who drafts weekly newsletters, (3) a Newsletter Reviewer who checks drafts for quality and voice consistency, (4) a Social Media Analyst who reviews post performance data.”

Within minutes, the inbox lit up with hire requests. “Request to hire: Content Researcher.” “Request to hire: Newsletter Writer.” I approved each one -- I’m the board, remember. The CEO can’t just hire people without my sign-off.

After approval, the org chart showed a full company. CEO at the top. Four workers reporting to the CEO. Each one had been given a role and initial instructions by the CEO based on the mission.

Step 4: Configure the CEO Prompt

The default CEO prompt is fine for a demo. It’s not fine for real work.

The CEO prompt is the single most important piece of configuration in Paperclip. Get it right and everything flows. Get it wrong and your CEO just sits there every heartbeat saying “I don’t have anything to do.”

Here’s the structure I use:

Phase 1 -- Status Check: Check every employee. Are they idle? Assign them work.

Phase 2 -- Review Completed Work: Look at everything marked as done since last heartbeat. If quality fails, reopen it with specific feedback. If it passes, move to done and notify me.

Phase 3 -- Proactive Work: If there are no open issues, create new tasks based on the mission. Do not wait for me. This is the line that changes everything. Without it, the CEO is reactive. With it, the CEO runs the company.

Phase 4 -- Escalation: Flag blockers immediately. Provide context and options, not just problems.

For the other agents, same principle but simpler. The Newsletter Writer gets voice guidelines, output format, and quality standards. The Reviewer gets a scoring rubric and instructions on how to submit feedback (comment on the issue, not just “looks good”).

Think of these prompts like onboarding documents. The more specific you are upfront, the less you micromanage later.

Step 5: Set the Heartbeat

The heartbeat is the engine. It’s a timer that tells the CEO to wake up, check the task list, assign work, review output, and go back to sleep.

Default: 3,600 seconds (1 hour). Fine for production.

For the live demo, I set it to 600 seconds (10 minutes) so the audience could see things happen in real time.

Only the CEO has a heartbeat. Workers run when the CEO triggers them.

Step 6: Assign Real Work

I created two issues:

Issue 1: “Research the top 10 LinkedIn posts about AI agents from the past week. For each, capture: the hook, the engagement count, the format, and what made it work. Output a structured markdown report.”

Issue 2: “Draft a newsletter about Paperclip and AI agent orchestration for the AI Never Sleeps Substack. Target length: 1,200 words. Angle: practical, not hype. Include what it does, when to use it, and when not to.”

Both assigned to the CEO. The CEO delegated the research to the Content Researcher and the newsletter to the Newsletter Writer. Both agents running simultaneously. On different tasks. Without me doing anything.

That’s the moment it clicks. With Claude Code, I’d be doing these one at a time. Open a session, prompt, wait, review. Open another session, prompt, wait, review. With Paperclip, I assign five issues before lunch and come back to five completed tasks.

Five Things I Learned Running Paperclip

I’ve been running this for two weeks now. Here’s what actually works versus what’s theatre.

1. Start with 3-5 agents, not 30

I’ve seen people online spinning up 20 agents on day one. That’s chaos. You can’t monitor 20 agents effectively. They drift. They duplicate work. Tokens burn.

Start with a CEO and two or three workers. Get the flow right. Add more when you actually need them.

2. Create feedback loops

Don’t have one agent write a newsletter and call it done. Have a writer, a reviewer, and an editor. The writer drafts. The reviewer checks quality. If it fails, it goes back with specific feedback. Only when it passes review does it come to you.

This is the same principle as code review. No developer ships code without another set of eyes. Your AI agents shouldn’t either.

The pattern that works best:

Researcher > Creator > Reviewer > CEO > You

Three checkpoints before it hits your inbox. That’s how you get quality.

3. Think in tickets, not conversations

Paperclip is not a chatbot. You don’t sit here prompting it. You create issues. Think Jira. Think Linear.

Bad issue: “Make our content better.”

Good issue: “Review my last 10 LinkedIn posts. Score each on: hook strength (1-10), engagement rate, and CTA clarity. Identify the top 3 patterns and bottom 3. Output a one-page report.”

One outcome per issue. Specific. Measurable. The more you think in tickets, the better your results.

4. The CEO prompt is everything

A generic CEO prompt produces a passive CEO that waits for you to assign everything. A specific CEO prompt with a proactive phase produces a CEO that generates its own work based on the mission.

I spent more time on the CEO prompt than on any other configuration. It’s the difference between a company that runs and a company that sits idle.

5. Run it on Railway, not your machine

These agents have shell access. If an agent decides to install something, delete a file, or access a network resource, it can. Railway sandboxes everything in containers automatically. Your personal machine stays untouched.

It also means the agents run 24/7. I set the heartbeat. I close my laptop. I go to dinner. They keep working.

When to Use Paperclip vs. Everything Else

This is the framework I’ve settled on after two weeks of running Paperclip alongside my existing stack:

Building something new from scratch: Claude Code. You need the tight feedback loop.

Repeatable, structured workflows (if X then Y): n8n. Deterministic. Reliable. Predictable.

Ongoing autonomous work that runs without you: Paperclip. Delegation at scale.

One-off tasks, questions, brainstorming: Claude Chat or Cowork. Interactive. Immediate.

They’re complementary, not competing.

The sweet spot for Paperclip is work that happens regularly, doesn’t require your creative judgment every time, benefits from multiple perspectives, and you want running while you sleep.

For me, that’s content research, newsletter pipeline, competitor analysis, and SEO monitoring. I still write my own LinkedIn posts. I still record my own videos. I still make the creative calls. But the research, the first drafts, the performance analysis? That’s automated.

The Honest Take

Paperclip is early. It’s version one. Let me be straight about what works and what doesn’t.

What works well:

• Research and analysis tasks (competitor reports, content audits, data analysis)

• First drafts of repeatable content (newsletters, social posts, email sequences)

• Multi-step workflows where agents check each other’s work

• Running overnight -- wake up to completed tasks

What doesn’t work yet:

• Building something brand new from scratch (use Claude Code)

• Highly creative work that needs your judgment at every step

• Tasks requiring complex API integrations you haven’t pre-configured

• “Set and forget” -- you still need to check in daily

The agents drift sometimes. The CEO gets confused occasionally. You need to check in more than you’d like. It’s not “set and forget” yet.

But the direction is clear. And getting comfortable with orchestrating AI teams now, while everyone else is still debating which chatbot to use, is how you stay ahead.

How This Connects to the Blueprint

Last week I published nine building blocks for a zero-employee business. Website, SEO, analytics, email, customer communication, code, testing, backups, socials.

The one piece missing was the orchestration layer. The thing that coordinates agents doing work across all nine layers.

That’s Paperclip.

I’m running two zero-employee businesses right now. Trvel.co and Bank-Statements.co. Combined, over $1,100 a month. About two hours of my time per month. But I was still manually kicking off tasks, checking outputs, coordinating between tools.

Paperclip replaces that coordination layer. The CEO agent checks what needs doing across the business. The worker agents execute. I review.

The vision: build the system once. Let the system run itself. Build the next one.

We’re getting closer.

Get Started

If you want to try this yourself:

1. Deploy Paperclip on Railway using my template: railway.com/deploy/paperclip-2

2. Create a company with a specific mission

3. Let the CEO hire 2-3 agents

4. Write a proactive CEO prompt (use the Phase 1-4 structure above)

5. Create three real issues from your business

6. Set the heartbeat to 10 minutes for your first day

7. Check in after 24 hours

🔒 The section below is for paid subscribers.

Paid subscribers get access to the full webinar recording, my exact CEO prompt (copy-paste ready), and the agent prompt templates for Researcher, Writer, and Reviewer roles.

Read more

I’m on a mission to build multiple zero employee businesses.

Not “lean” businesses. Not “small team” businesses.

Zero.

No employees. No contractors. No VA. Just me, AI, and a stack of tools that run 24/7.

Two of them are already live and generating revenue:

Trvel.co (eSIM store): $744 in March. Up from $173 three months ago.

Bank-Statements.co: $402 in March. Up from $218 six months ago.

Small numbers. But here’s the thing.

I spend maybe 2 hours a month on both combined. They run while I sleep. They grow while I consult. They don’t call in sick.

And the infrastructure I built for these two is the same infrastructure I’ll use for the next five.

Because once you’ve built the blueprint, every new product is just a new front end on the same stack.

This is the blueprint.

Why Zero Employee Businesses?

Let me be clear about what I mean.

A zero employee business is a product that:

• Generates revenue without you doing the work manually

• Serves customers without you answering every question

• Grows without you pushing it every day

• Runs when you’re asleep, on holiday, or working on something else

It’s not passive income. That’s a myth. You still build it. You still maintain it. You still improve it.

But the business doesn’t need you to show up for it to make money today.

Compare that to consulting. I made $29,700 from consulting last month. Good money. But the minute I stop showing up, the money stops.

My two SaaS apps made $1,146 last month. Much less. But the minute I stop showing up, they keep going.

One scales linearly with my time. The other scales independently of it.

I want more of the second kind.

The 9 Building Blocks

I’ve mapped out everything you need to launch a zero employee product. Nine layers. Miss one and you’ve got a gap that will cost you later.

Here’s the full map.

1. Website Foundation

This is the core. Every product needs a home.

Domain and DNS You need a domain. I use Cloudflare for DNS because it’s fast, free, and gives you DDoS protection out of the box. GoDaddy or Namecheap for buying the domain itself.

Web Framework Next.js. Full stop. It handles your frontend, your API routes, your server-side rendering. One framework, everything you need. Both Trvel.co and Bank-Statements.co run on Next.js.

UI and Design Shadcn/ui or DaisyUI for components. Don’t design from scratch. These give you professional-looking interfaces in minutes. For your logo and favicon, favicon.io/favicon-converter handles the conversion.

Database Supabase (which is PostgreSQL underneath). Free tier is generous. Prisma as the ORM so you’re not writing raw SQL. Make sure you set up the pooler and IPv4 config -- this trips up a lot of people on Vercel deployments.

Hosting Vercel for the frontend. Free for most projects. Railway for anything backend that needs to run persistently. Both have generous free tiers.

Authentication Clerk is the fastest to set up. NextAuth.js if you want more control. Supabase Auth if you’re already on Supabase and want to keep things in one ecosystem.

Pick one. Don’t overthink it.

Payments Stripe. There’s no real alternative for solo builders. It handles subscriptions, one-time payments, invoicing, tax calculation. The API is excellent. The dashboard is clean.

Bank-Statements.co runs entirely on Stripe. Customer pays, gets access, Stripe handles the rest.

Legal Pages Privacy Policy. Terms of Service. Cookie consent if you have EU traffic. You need these before you launch. AI can draft them. A lawyer should review them if you’re handling sensitive data.

2. SEO and Discoverability

Your product doesn’t exist if nobody can find it.

Content A blog is still the highest-ROI marketing channel for a zero employee business. Write about the problem your product solves. Programmatic SEO pages are even better -- pages that are generated from data rather than written by hand. Bank-Statements.co uses this. One template, hundreds of pages, all ranking.

Assets Store images and files on AWS S3. Create OpenGraph images (1200 x 630px) for every page so your links look good when shared on LinkedIn and Twitter. This takes 5 minutes per page and makes a massive difference in click-through rates.

Monitoring Google Search Console. Check it weekly. Export the CSVs and track your impressions and clicks over time. Run Lighthouse audits to catch performance issues before your users do.

3. Analytics and Monitoring

You can’t improve what you can’t measure.

User Analytics PostHog is my pick. Free tier is generous, it’s open source, and it does session recording, funnels, and feature flags. Google Analytics as a backup. Umami if you want something privacy-focused and lightweight.

Error Monitoring Sentry catches errors before your customers report them. LogRocket records user sessions so when someone says “it’s broken,” you can watch exactly what happened.

For a zero employee business, error monitoring isn’t optional. You don’t have a support team watching for issues. The tools have to tell you.

4. Email

Email is the most underestimated layer. Get it wrong and your customers never hear from you.

Transactional Email Resend for sending receipts, confirmations, password resets. Clean API, good deliverability. Usesend if you want to self-host on Railway and keep costs near zero.

Deliverability Setup This is where most people mess up. You need three DNS records configured:

• SPF -- tells email providers which servers can send from your domain

• DKIM -- cryptographic signature proving the email is legit

• DMARC -- policy for what to do with emails that fail the above checks

Set up a mail.yourdomain.com subdomain. Register with Google Postmaster Tools to monitor your reputation.

Skip this and your emails go to spam. Your customers think you ghosted them. Your business dies quietly.

Marketing and Nurture Mautic self-hosted on Railway. It’s an open-source marketing automation platform. Set up nurture flows that run automatically -- welcome sequences, onboarding emails, re-engagement campaigns.

Zero employees means your email sequences do the selling for you.

Inbound Email Handling Route customer replies somewhere you’ll see them. Don’t let emails bounce or go unanswered. Even a simple forward to your inbox works.

5. Socials

You need a presence. Not a content empire.

X (Twitter) -- best for reaching other builders and tech-savvy users Facebook/Instagram -- if your product serves consumers

LinkedIn -- if your product serves professionals

For a zero employee business, pick one primary channel. Post consistently on that one. Ignore the rest until the product has traction.

6. Customer Communication

No employees means AI handles the front line.

Live Chat ElevenLabs voice AI for phone-like interactions. Traditional chat widgets for text-based support. Both can be automated to handle 80%+ of common questions.

Phone/Call Centre Twilio for voice. You can build an AI phone agent that answers calls, routes issues, and escalates to you only when necessary. This is one of the most powerful zero employee tools available right now.

Feedback Collection Typeform or Tally for surveys and feedback forms. Embed them in your product. Trigger them after key moments (first purchase, 30 days in, support interaction).

You need to hear from customers even when you’re not talking to them.

7. Code and Version Control

Repository GitHub. Keep everything in version control from day one. Even if you’re the only person who will ever touch the code.

Environments Run a staging environment separate from production. Vercel gives you preview deployments on every pull request for free. Test before you ship. You don’t have a QA team to catch mistakes.

8. Testing

Lighthouse Audits Run them regularly. Performance, accessibility, SEO, best practices. All in one tool, built into Chrome.

Manual QA Yes, you still need to click through your product manually. Test the checkout flow. Test on mobile. Test with slow internet.

User Testing Ask 3-5 people to use your product and watch them. You’ll learn more in 30 minutes of watching someone struggle than in a month of analytics.

9. Backups and Security

The stuff nobody thinks about until it’s too late.

Backups Set up automated database backups. Supabase does daily backups on paid plans. For free tier, script your own. Test your restore process at least once.

Security SSL certificate (Vercel handles this automatically). Rate limiting on your API endpoints. Input validation on every form. These aren’t nice-to-haves. One bad actor can take down your zero employee business while you sleep.

The Real Cost

Here’s what this stack actually costs to run:

Free tier (getting started): Vercel, Supabase, GitHub, Cloudflare, Google Analytics, Google Search Console -- all free.

Minimal spend (~$20-50/month at scale): Domain ($12/year), Stripe (2.9% + 30c per transaction), Resend or email service ($10/month), Railway for backend services ($5-20/month), Sentry free tier.

Optional upgrades: PostHog paid ($0 until you outgrow free tier), Clerk ($25/month after free tier), Mautic on Railway (~$10/month).

You can launch a zero employee business for under $50/month in infrastructure. The real investment is your time building it.

What I’m Sharing Next Week

I’ve been building a tool that automates the setup of this entire stack.

It’s called Paperclip (paperclip.ing).

Next week, I’ll share how to install it, my exact setup, and how I use it to spin up a new zero employee product in hours instead of days.

If you want to get it first, make sure you’re subscribed.

The Thesis

A zero employee business isn’t about being cheap or doing everything yourself.

It’s about building systems that work without you.

Every layer in this blueprint -- from the website to the email to the customer communication -- is a system that runs on its own. AI handles the support. Automation handles the marketing. Stripe handles the money.

Your job is to build the system once. Then build the next one.

Trvel.co: $744/month and growing. 1 hour of my time. Bank-Statements.co: $402/month and growing. 1 hour of my time.

Two products. Two hours a month. $1,146 in revenue.

That’s the zero employee model.

Now imagine ten of these.

$40,451 in March.

That’s month 10 after leaving a $420K corporate salary.

February was $27,800. I shared every dollar of that too.

March was a 45% jump from February.

And I’m not celebrating.

Because the number looks great. The mix doesn’t.

Let me show you everything.

The Full Breakdown

Consulting: $29,700

One client. Two projects. Both sourced through Pear (a consulting marketplace I co-founded).

This is strategy and AI advisory work. The kind of work I did at BCG, except now I keep the margin.

$29,700 from consulting. That’s 73% of total revenue.

AI Never Sleeps (Brand): $9,605

This is the portfolio I’m building:

Zero to Builder (course): $5,997 (Feb: $8,970 -- down $2,973)

AI Builders Club (community): $2,360 (Feb: $2,124 -- up $236)

Agency (done-for-you): $1,248 (Feb: $1,306 -- down $58)

Total AI Never Sleeps: $9,605 (Feb: $12,400 -- down $2,795)

That stung.

SaaS Apps: $1,146

Trvel.co (eSIM store): $744 (Feb: $620)

Bank-Statements.co: $402 (Feb: $280)

Total SaaS: $1,146 (Feb: $900)

Small numbers. But growing. And these run while I sleep.

Total: $40,451

Consulting: $29,700 (73.4%)

AI Never Sleeps: $9,605 (23.7%)

SaaS Apps: $1,146 (2.8%)

The Uncomfortable Truth

73% consulting.

I left corporate to stop trading time for money.

And then I had my biggest consulting month since October.

Here’s the thing about consulting when you’re building: it’s a trap disguised as a safety net. The money is good. The work is interesting. The clients are great.

But every hour I spend on a consulting project is an hour I’m not spending on the newsletter, the course, or the apps.

Consulting scales linearly. I work more, I earn more. I stop, it stops.

The brand compounds. The newsletter grows whether I post or not. The course recordings sell themselves. The apps run 24/7.

But compounding takes time. And rent doesn’t wait.

So you take the consulting. And you tell yourself “just one more month.”

Month 10.

Why AI Never Sleeps Dipped

Let me be honest about this.

AI Never Sleeps went from $12,400 in February to $9,605 in March. Down 22%.

Here’s what happened:

The course dip was expected. Zero to Builder runs as cohorts. Cohort 2 started in March, but most of those payments came through in February when people enrolled. March was the delivery month, not the sales month. Cohort revenue is lumpy by nature.

The community held steady. AI Builders Club at $59/month grew slightly. 40 paying members. Small but consistent. These are the people who stick around.

Agency was flat. I’m being selective with agency work. I only take projects where I can use AI to deliver 5x the value. That means I say no to a lot.

The real issue isn’t that March dipped. The real issue is that I didn’t have enough systems running to fill the gap.

When I was heads-down on consulting, the content machine slowed. Fewer LinkedIn posts. Fewer newsletter issues. Less top-of-funnel activity.

The brand needs feeding. When I stop feeding it, it slows down. Not immediately. But within 2-3 weeks, you feel it.

What’s Actually Working

Let me zoom out. Here’s every month since I left:

Month 1 (Jun): $67,715 -- transition month. Felt rich. Didn’t last.

Month 2 (Jul): $15,498 -- the “oh shit” month. I almost quit. Seriously.

Month 3 (Aug): $61,800 -- a big project landed. Felt like a fluke. It was.

Month 4 (Sep): $66,647 -- consulting carried everything ($66K of it).

Month 5 (Oct): $54,369 -- still mostly consulting ($48K).

Month 6 (Nov): $5,989 -- consulting dried up. Just the brand. Scary.

Month 7 (Dec): $12,838 -- one small consulting gig ($6,900). Rest was brand.

Month 8 (Jan): $27,495 -- brand carried the whole month ($27K from AINS). Cohort 2 enrolments started landing.

Month 9 (Feb): $27,800 -- brand still strong ($12,493 from AINS).

Month 10 (Mar): $40,451 -- biggest month. But 73% consulting again.

10-month total: $380,602. Average: $38,060/month.

Here’s what’s actually working:

1. The value ladder is real.

Free content (LinkedIn, YouTube, newsletter) brings people in. Some join the $59/month community. Some sign up for the $2,999 course. A few become agency clients.

It’s not fast. But it works. And every tier feeds the next.

2. Building in public compounds trust.

Sharing these numbers every month is the single best thing I’ve done for the brand. People follow along. They root for you. When you launch something, they buy it because they’ve watched you build it for months.

3. SaaS apps are tiny but real.

$1,146 won’t pay the mortgage. But Trvel.co and Bank-Statements.co are growing. And I spend maybe 2 hours a month on them combined.

At this growth rate, they’ll be meaningful within 6 months. And they’re the closest thing I have to truly passive income.

4. Pear is a distribution channel.

The consulting came through Pear. The workshop I ran last week (Build Something Real in 90 Minutes) was a connection from one of my co-founders. 16 senior professionals in a room, all potential newsletter subscribers, community members, or course students.

Consulting isn’t just revenue. It’s a funnel.

What I’m Changing for Month 11

I’m not going to stop consulting. That would be stupid.

But I’m going to change how I think about it.

1. Cap consulting at 3 days per week.

The other 2 days are brand days. Non-negotiable. Content, course development, product building.

2. Automate the content machine.

I built a skills system last month. 10 skills that handle LinkedIn, newsletter, YouTube, and Twitter. Voice DNA that makes AI sound like me. Quality checkers that catch problems before publishing.

The system works. I just haven’t been using it consistently because consulting ate my calendar.

Month 11: one LinkedIn post per day. Two newsletter issues per week. No excuses.

3. Launch Builder’s Lab.

This is the missing piece in the value ladder. Right now there’s a gap between the $59/month community and the $2,999 course.

Builder’s Lab at $299/month fills that gap. Self-paced Zero to Builder recordings plus monthly coaching plus project reviews. It launches to Cohort 1 graduates first.

Recurring revenue that doesn’t require me to be live every week. That’s the goal.

4. Double down on SaaS.

Trvel.co and Bank-Statements.co are both growing organically. I’ve been ignoring them because the numbers are small.

But small things that grow 25% month over month become big things surprisingly fast. $1,146 at 25% monthly growth is $10K/month within a year.

I’m going to spend one weekend per month on each app. Feature improvements, SEO, customer feedback. Nothing dramatic. Just consistent attention.

The 10-Month Scorecard

Total revenue (10 months): $380,602

Monthly average: $38,060

Best brand month: $27,345 (Month 8 -- AINS only, no consulting)

Worst month (December): $5,989 (Month 6 -- no consulting, brand was tiny)

Income streams: Started with 2, now have 5

Newsletter subscribers: 400 to 3,800+

Course students: 0 to 24

SaaS MRR: $0 to ~$1,146

Consulting dependency: Still 73% in the best months

The pattern is clear. When consulting is on, the total looks great. When it’s off, the brand alone isn’t enough yet.

Month 6 was the wake-up call. $5,989. Brand only. That’s what the business looks like without consulting.

Month 9 was the proof of concept. $12,493 from the brand alone. Getting closer.

The goal isn’t to eliminate consulting. It’s to make the brand strong enough that consulting becomes optional.

What Nobody Tells You About Leaving Corporate

Month 10 is not a straight line.

Some months the brand grows. Some months consulting carries you. Some months you just survive.

The $420K salary was one stream. One boss. One decision away from zero.

This is messier. Less predictable. Some months I make more than my corporate salary run rate. Some months I make half.

But it compounds.

Every newsletter subscriber. Every course graduate. Every app user. Every workshop attendee.

They accumulate. And one day you wake up and the brand is bigger than the consulting.

I’m not there yet. But I can see it from here.

For paid subscribers, I break down my expenses and hourly rate.

Read more

I ran a live workshop this week called “Skills That Actually Work.”

60 minutes. Live demo. Real templates.

And the question that kicked it off was the same one I hear every single week:

“Can you share your prompt library?”

I used to get excited by that question.

Not anymore.

Here’s why.

The Prompt Trap

Most people use AI like this:

1. Open ChatGPT or Claude

2. Spend 5 minutes explaining who they are

3. Explain the task

4. Get mediocre output

5. Tweak the prompt

6. Get slightly less mediocre output

7. Close the tab

8. Do it all again tomorrow

Sound familiar?

That’s 5 minutes of setup for every single conversation. 25 minutes a day. 2+ hours a week. Over 100 hours a year.

Re-explaining who you are. How you write. What to include. What to avoid.

Every. Single. Time.

You’re building a sandcastle every morning and watching the tide wash it away.

I did this for months. I had 300+ prompts saved in Notion. Organised by category. Color-coded. Beautiful.

And the output was still generic.

What Changed Everything

I stopped writing prompts. I started writing skills.

A skill is a reusable set of instructions that turns AI into an expert at one specific task.

Think of it this way:

A prompt is giving someone verbal directions to your house every time they visit.

A skill is saving the address in Google Maps. One tap. Done.

You write the skill once. The AI reads it automatically. It follows your process, in your voice, every time.

Here’s the real difference:

A prompt tells AI what to do once.

A skill tells AI who you are forever.

One is a conversation. The other is an employee.

The Anatomy of a Skill

Every skill has five parts. Miss one and it breaks.

#1. Purpose

One sentence. What does this skill produce?

Not a paragraph. Not a manifesto. One line.

“Review contracts against Australian law and flag risks.”

“Create LinkedIn posts that match my voice and serve my audience.”

If you can’t say it in one sentence, the skill is too broad. Split it.

#2. When to Use

This is the trigger. What makes this skill activate?

“When I provide a contract and ask to review it.”

“When I ask to write a LinkedIn post.”

This matters because if you have 50 skills (I have more), the AI needs to know which one to grab. Vague triggers never fire. Specific ones do.

And here’s the clever part -- tools like Claude Code use something called progressive reveal. All 50 skills sit there at startup, but they only take up about 5,000 tokens total. Just the name and description. The full instructions only load when the skill is triggered.

The same content crammed into a mega-prompt? 250,000 tokens. Every time.

#3. Inputs Required

What does the AI need from you to do the job?

For a contract review: the contract file.

For a LinkedIn post: the topic or angle.

For meeting notes: the raw transcript.

Think of it as: “What would I hand a smart assistant before they could start?”

#4. Process

This is the core. Step-by-step instructions for how to do the task.

Not “review this contract” -- that’s a prompt.

A skill says:

• Step 1: Read the full document. Identify parties, key dates, and document type.

• Step 2: Run through a 15-point checklist. Flag restraint clauses over 12 months. Check if IP assignment covers personal projects. Compare notice periods for symmetry.

• Step 3: Classify every finding as HIGH, MEDIUM, or LOW risk.

• Step 4: Produce a structured report with an executive summary, findings table, and recommended amendments with specific language changes.

That’s not a prompt. That’s a process. And the AI follows it the same way every time.

We take this stuff for granted. When you review a contract, you already know what to check. It’s in the back of your mind. But the AI doesn’t have the back of your mind.

You have to write it down.

#5. Quality Checklist

How do you know the output is good enough?

• Every checklist item was reviewed (not skipped)

• Every finding has a risk level AND a recommendation

• Executive summary captures the key message in 2-3 sentences

• Recommendations include specific language, not just “change this”

This is the part most people skip. And it’s the part that separates a mediocre skill from one that actually replaces a process.

Tools like Claude Code can even run evaluations against this checklist automatically. Set it to iterate 5 times. Each pass gets better.

Real Example #1: The Contract That Almost Got Me

I was reviewing an employment contract. Without a skill, I prompted Claude: “Review this contract and flag any issues.”

It came back with a generic summary. Nothing useful.

Then I used my contract review skill. Same AI. Same contract. Different result.

It ran a 15-point checklist and caught three things:

1. A 24-month restraint clause -- standard is 12 months. This one was double.

2. IP assignment covering personal projects -- anything I built, even on weekends, would belong to the company.

3. Asymmetric notice periods -- they could let me go in 2 weeks. I had to give 3 months.

Same AI. Same contract. The skill made it an expert.

And because the skill is reusable, it works on every contract I review. Not just this one.

Real Example #2: The Content Machine

I create a lot of content. LinkedIn. Newsletter. YouTube. Twitter.

That’s four platforms. Four different formats. Four different audiences.

Writing from scratch for each one was eating 15+ hours a week.

So I built a content system. 10 skills total:

Content creation:

• LinkedIn posts

• Substack posts

• Substack notes

• YouTube scripts

Quality control (subagents):

• Hook generator -- creates 10 hook variations, scores them, picks the top 3

• Post auditor -- runs a 10-point quality audit before anything gets published

• Voice checker -- flags AI-sounding text and checks it matches my tone

All 10 skills share three context profiles:

#1. Voice DNA -- how I sound (sentence length, emotional palette, phrases I use, phrases I hate) #2. ICP -- who I write for (their role, problems, goals, language) #3. Business profile -- what I offer (products, positioning, value proposition)

When I say “write a LinkedIn post about skills versus prompts,” the AI reads my voice DNA, reads my ICP, loads the LinkedIn skill, and produces a draft that sounds like me.

Not “sounds like AI trying to sound like me.” Actually sounds like me.

And the whole thing takes about 90 seconds.

Where Can You Use Skills?

This is the question I got most during the workshop. The short answer: everywhere.

Claude Chat (Easiest -- Start Here)

Create a Project. Drop your skill.md and voice_dna.json into Project Knowledge. Add a one-line custom instruction: “Follow the skill instructions in project knowledge.”

That’s it. You’re running.

Claude Co-work (Middle Ground)

Create a folder on your computer with your skills. Give Co-work access. It reads the files directly -- no copy-pasting. Bonus: it can connect to Gmail, Calendar, Slack, and Notion. Set up a scheduled task to email you a LinkedIn post draft every morning at 7am.

Claude Code (Most Powerful)

Drop skills into .claude/skills/[skill-name]/skill.md. Reference them in your CLAUDE.md file. They auto-load on startup and activate only when triggered. This is where skills really compound -- you can have dozens running in parallel.

Cursor

Reads Claude Code skills natively. Drop them in and they work. The two ecosystems are compatible.

ChatGPT

Requires Business or Enterprise license. Use Projects (similar to Claude’s approach). Paste skill content into project instructions.

Gemini

Uses “Gems” -- same concept, different name. Create a Gem with your skill instructions.

The skill itself is a markdown file. Plain text. It works anywhere that accepts instructions.

Skills Compound. Prompts Don’t.

Here’s the thing most people miss.

A prompt is single-use. You get your output and it’s gone.

A skill compounds. Every time you use it, you learn what works and what doesn’t. You update the skill. The next output is better.

Week 1: 1 skill. One task gets easier.

Month 1: 5 skills. Your main workflows are covered.

Month 3: 15 skills. You’ve built an AI employee.

And because skills share context profiles, improving your voice DNA improves every skill that reads it. One update, ten skills get better.

I have skills that update themselves. The AI learns from my feedback and adjusts the skill automatically. The skill I use today for LinkedIn posts is significantly better than the one I started with four months ago.

Not because I rewrote it. Because it evolved.

Can I Turn My Existing Prompts Into Skills?

Yes. But you’ll need to add structure.

Most prompt libraries I’ve seen are light. A paragraph or two. Maybe some formatting instructions.

A skill needs:

• Purpose (one sentence)

• Trigger (when to use)

• Inputs (what it needs from you)

• Process (step-by-step)

• Quality checklist (how to verify output)

Take your best prompt. Ask the AI: “Turn this prompt into a skill following this structure.” Give it the blank template. It’ll do 80% of the work. You fill in the 20% that requires your expertise.

The expertise part is important. The AI can structure the skill. It can’t know what YOU check for, what YOUR clients care about, what YOUR voice sounds like.

That’s why skills are custom to you. And why sharing a prompt library is nowhere near as powerful as building your own skill system.

The 30-Minute Challenge

Here’s what I’d do if I were starting today:

1. Pick ONE task you do repeatedly (content writing, contract review, meeting summaries, email drafting)

2. Write down your process -- what do you actually do when you do this task manually?

3. Use the blank template to structure it into a skill

4. Test it with a real task

5. If the output isn’t right, update the skill -- not the prompt

That last point is the mindset shift.

When the output is wrong, don’t write a better prompt. Write a better skill.

The prompt is a conversation. The skill is the system.

I ran the full workshop live this week -- 60 minutes of live demos, building skills from scratch, and deploying across platforms.

The recording and all five templates are below for paid subscribers.

Read more

I ran a webinar this week on Claude Co-work.

Here’s what I kept hearing: “Isn’t this just ChatGPT with extra steps?”

No. And the difference matters more than you think.

Here’s the thing.

Most people use AI like a search engine with opinions. You type a question. You get an answer. You copy it. You paste it somewhere else. You do the actual work.

That was fine in 2024.

In 2026, the AI can do the work itself.

Not “tell you how.” Actually do it. Move files. Send emails. Read your calendar. Organize your folders. Draft documents in your voice. All while you go make coffee.

And most people haven’t made that shift yet.

Whether you’re a consultant who wants to automate your deliverables, a corporate professional drowning in admin, or an ex-developer who wants to start building again - this is the shift.

Here’s how it works. 4 things that make co-working completely different from chatting.

1. File Access

When you chat with AI, you’re limited.

On ChatGPT, you can upload a few files into a project folder. Maybe 20 files. A gigabyte max. Then you hit the wall.

With Co-work, the AI reads directly from your computer. Your folders. Your Google Drive. Two terabytes if that’s what you’ve got.

It doesn’t read everything at once. That would be insane. But when you say “write a LinkedIn post about this topic,” it goes and finds the relevant files - just like you would - except faster.

Here’s what it can actually do with your files:

1. Read and summarize documents

2. Create new files and folders

3. Move, rename, and organize things

4. Read real formulas in spreadsheets (no hallucinated math)

5. Transcribe photos of receipts, whiteboards, handwritten notes

That last one is wild. Take a photo of your whiteboard notes from a strategy session. Upload them. The AI transcribes everything into a clean text file you can actually reference later.

For all the ex-consultants reading this who have 400 whiteboard photos on their phone - you’re welcome.

2. The Planning Layer

This is the part that makes it feel like a junior team member instead of a tool.

When you give it a big task, it doesn’t just start randomly doing things. It creates a to-do list. Shows you the plan. Asks you to confirm before it acts.

“I’m going to do these 5 things. This is my approach. Are you okay if I continue?”

90% of the time, the plan is solid. But you can adjust it. Add steps. Remove things. Change the order.

And it shows real-time progress. You can see which tasks it’s completed, which ones it’s working on, and what’s next.

You can even intervene mid-task if something looks off.

One follows orders. The other thinks before acting. Both useful. But one saves you from a lot of cleanup.

3. Connectors (MCPs)

Here’s where it gets really practical.

Co-work connects to over 50 apps out of the box. Gmail. Google Calendar. Google Drive. Notion. Slack. Figma. Zapier (which bridges to 8,000+ more).

There’s even a Chrome extension for browser control. It can go to websites, fill out forms, look for flights, test your web app.

Chat gives you a brain. Co-work gives you a brain with arms and legs. It can actually go do things.

One example I use daily:

Every morning at 7:30, Co-work reads my Google Calendar and sends me an email summary of my day. Meetings, prep notes, even the weather. I didn’t build that in code. I just told it what I wanted and connected the right apps.

That’s one workflow. You could build dozens.

Meeting prep. Expense tracking. Follow-up emails after calls. Weekly reports pulled from multiple sources. Client onboarding checklists that actually execute themselves.

4. Skills

This is my favorite. And it’s the one that compounds over time.

A skill is a recipe for the AI. You write the instructions once. Then you use them forever.

Instead of typing a massive prompt every time you want a LinkedIn post written in your voice, you create a skill once. It contains your voice, your style, your rules, your preferences. Then you just say “write a LinkedIn post about X” and it follows the recipe.

Why this matters more than prompts:

Prompts are so last month. Seriously.

Skills use fewer tokens than mega-prompts. Here’s why - it’s a concept called progressive reveal.

The AI knows the names of all your skills and what they do. But it only loads the full instructions when that skill is relevant. So if you’re writing a LinkedIn post, it won’t load your legal contract review skill. It only pulls what it needs.

Fewer tokens. More consistent. Better output.

I have skills for:

1. Writing LinkedIn posts in my voice

2. Reviewing legal contracts against Australian regulations

3. Creating YouTube scripts

4. Weekly expense reporting

5. Course content creation

Each one I wrote once. I use them every week. Some every day.

That’s the shift from a prompt library to a system. And systems scale. Prompts don’t.

Where Does This Sit?

Think of it as three levels:

Chat = You talk, AI talks back. You do the work.

Co-work = You direct, AI does the work. You review and approve.

Code = Full engineering power. Build applications, test them, deploy them.

If you’re already using Claude Code or Cursor, Co-work might feel like a step backward. It’s not as powerful for building apps.

But if you’re still in chat mode - copying, pasting, doing everything manually - Co-work is the unlock.

It’s the middle ground that most professionals actually need. Not everyone wants to build web apps. But everyone has emails to manage. Files to organize. Reports that need to exist by Monday.

What It Costs

Quick breakdown since everyone asks:

Pro Plan ($20 USD/month): Access to Chat, Co-work, and Code. Limited tokens that reset every 4 hours. Good starting point to test the waters.

Max Plan ($100-200 USD/month): Higher token limits. If you’re using Co-work heavily, the Pro plan tokens will likely run out by mid-morning. The Max plan gives you room to actually build systems.

Co-work uses more tokens than chat because it’s reading files, spinning up sub-agents, and using skills. That’s the trade-off. It does more, so it costs more.

Honestly, I burned through the Pro plan tokens by 10am on day one. If you’re serious about building systems with this, you’ll want the Max plan. But start with Pro and see how you go.

Start Here

If you’ve never used Co-work, here’s what I’d do:

1. Download Claude Desktop (claude.com/download)

2. Switch to the Co-work tab

3. Give it access to ONE specific folder (not your whole computer)

4. Ask it to organize or summarize what’s in that folder

5. Watch what happens

That’s it. Start small. See how it works. Then start connecting apps and building skills.

The shift from chatting to co-working isn’t complicated. But it changes everything about how you use AI. From “that was a fun chat” to “wait, it actually did the thing.”

And once you experience that, you won’t go back to copy-paste.

The section below is for paid subscribers.

I walk through the full setup - including how to build your first 3 skills from scratch - in the webinar recording.

Read more

Everyone shows you two moments.

The “I quit my job” post. And the “I hit $1M” post.

Nobody shows you the middle.

This is the (messy) middle.

February was my 9th month since leaving a $420K corporate salary. Here’s every dollar I made, what’s working, what isn’t, and what I’m learning.

The Numbers

Total February Revenue: $27,800

Three income streams:

Independent Consulting: $14,400 (52%)

AI Never Sleeps (brand): $12,400 (45%)

SaaS Apps: $1,000 (3%)

Let me break each one down.

Income Stream 1: Consulting ($14,400)

This is the one I have complicated feelings about.

Consulting is what I did for more than 10 years. BCG (Consultant to Principal) and even at Westpac (Groups Strategy). It’s the skill I brought with me when I left corporate.

It pays well. It’s reliable. Clients know me and trust me.

But it’s time for money. The exact thing I was trying to move away from.

52% of my income still comes from selling my hours.

Here’s the truth: I’m grateful for it. Consulting pays the mortgage while I build everything else. But every month, I want that percentage to shrink.

Income Stream 2: AI Never Sleeps ($12,400)

This is the one that didn’t exist 9 months ago.

Agency work: $5,000 AI automation builds for clients. Someone needs a workflow automated, I build it. Higher margin than consulting because AI tools let me do in hours what used to take days.

Zero to Builder course: $6,000 My 8-week course teaching non-technical people to build with AI. We’re running Cohort 1 right now. Next cohort starts March 19th.

Sign up for the March cohort if you are keen to learn how to build in a structured way: https://www.aineversleeps.net/zero-to-builder

$6,000 from a course that didn’t exist 6 months ago. Teaching a skill I re-learned myself.

Newsletter: $1,400 Paid subscribers at $59/month. This is the most “recurring” revenue I have. It’s growing. Slowly.

$12,400 total from a brand I built from nothing.

Income Stream 3: SaaS Apps ($1,000)

The honest truth? This is the part I’m most excited about AND most embarrassed by.

Trvel (eSIM app): $744 An app I built with AI that sells eSIMs for travelers. It runs itself. I haven’t touched it in weeks.

BankStatements app: $246 A small utility app. Makes money while I sleep.

$1,000 total. From products I built.

It’s tiny. It barely covers groceries (especially when I have 3 boys - 2 of them are teenagers).

But here’s why it matters: I built both of these with AI tools. They run without me. And $1,000 in product revenue that doesn’t require my time is worth more to me psychologically than $10,000 in consulting.

The Real Trajectory

Here’s what the journey has actually looked like:

July 2025 (Month 1): $67,715 That number looks incredible, right? It was mostly consulting carry-over from corporate. Projects I’d already started before leaving. Not the real picture.

August 2025 (Month 2): $15,498 The gut-punch.

The carry-over dried up. This was the real starting point. I remember staring at that number thinking, “What have I done?”

$15,498 vs $35,000/month corporate salary. That’s 44%.

I questioned everything that month.

September 2025 (Month 3): $61,800 Bounced back. Big consulting project landed. But I knew this was volatile. One project could make or break a month.

October and November were similar to September - big consulting projects.

December was almost dead as I paused and took a break to enjoy time with my family.

January 2026 (Month 8): $27,495 - I posted about it here and on YouTube.

February 2026 (Month 9): $27,800

See the pattern?

The big swings are smoothing out. Two months in a row at almost the same number. A baseline is forming.

And the mix is shifting. More brand revenue. More product revenue. Less pure consulting.

That matters more than the total.

What’s Working

#1. The course is real money. $6,000 in February from something I created and teach. Cohort 2 starts in March. This can grow significantly.

#2. The brand has value. $12,400 from AI Never Sleeps. A name that didn’t exist 9 months ago. People finding me, signing up, and paying - without me cold-calling anyone.

#3. Products exist. Small ($1,000/month) but real. Built with AI. Running without me. Proof the model works.

#4. The baseline is stabilizing. Two months in a row at ~$28K. I can plan around that. No more stomach-dropping uncertainty.

What’s Not Working (Yet)

#1. Consulting is still half my income. I need to get this below 30% by year-end. That means growing brand and product revenue, not cutting consulting.

#2. SaaS is too small. $1,000/month won’t change my life. I need to either grow Trvel and BankStatements or build something new.

#3. Newsletter growth is slow. $1,400/month from paid subscribers. I need to get this to $4,000-5,000/month. That means better content, better conversion, more free subscribers coming in the top.

The Math That Matters

$420K salary = $35,000/month. February = $27,800.

I’m at 79% of my old salary.

But here’s what the math doesn’t capture:

I dropped my kids at school this morning. Then came home and worked on my business. Three income streams, not one. No ceiling.

The $35,000 corporate paycheck was a ceiling. You get your raise, your bonus, your promotion. Then you hit the wall.

$27,800 is a floor. It can become $50K. Then $100K. There’s no wall above me.

What’s Next

For March, three priorities:

#1. Launch Zero to Builder Cohort 2 (March 19th) If one cohort generated $6K in February, what happens when I run two? This is the biggest growth lever I have right now.

#2. Grow paid newsletter subscribers From $1,400 to $3,000/month by June. More free subscribers in the top, better conversion to paid.

#3. Decide on SaaS $1,000/month from two products. Do I double down and grow them? Or build a third? I need to make this call in March.

The Honest Takeaway

9 months in, I’m making less than my corporate salary.

My SaaS “empire” makes $1,000/month. Half my income is still consulting. My newsletter has fewer paid subscribers than I’d like.

And I’d do it again tomorrow.

Because I’m not optimizing for February’s numbers. I’m optimizing for what this looks like in 2-3 years.

Nobody shows the middle. Everyone wants to skip from “I quit” to “I made it.”

This is the middle.

And the middle is messy. But it’s where the work gets done.

I’ll share March’s numbers next month. Same format. Every dollar. No hiding.

What do you think? Is this the kind of transparency you want to see from people building in public? Hit reply - I read every one.

3 months ago, I was re-explaining my entire background to Claude and/or ChatGPT every morning.

Now I type one sentence and get expert-level output that sounds like me.

Here’s what changed.

You open Cursor. Or Claude Code. Or ChatGPT.

The first thing you do is explain yourself.

“I’m a consultant who works with mid-market companies. My clients are C-suite executives. I want you to write in a direct, no-nonsense tone. Don’t use phrases like ‘in today’s rapidly evolving landscape.’ And please structure everything using the Pyramid Principle.”

Sound familiar?

You do this every. single. time.

And you still get output that sounds like it was written by a first-year intern who read one blog post about your industry.

Here’s the thing: you’re not bad at prompting. You’re just using AI wrong.

The Amnesia Problem

Every AI conversation starts from zero.

The model doesn’t know who you are. Doesn’t know your methodology. Doesn’t know your audience. Doesn’t know what good looks like in your domain.

It’s like hiring a brilliant new assistant every morning who has complete amnesia. They’re smart. They’re capable. But they know nothing about you or your work.

So you spend the first 10 minutes of every conversation re-explaining context that never changes. Your philosophy. Your audience. Your standards.

And even after all that explaining, the output is... fine. Generic. Could have been written by anyone, about anything, for anyone.

Almost everyone I talk to is stuck here.

The Shift: Prompt Engineering vs Context Engineering

There’s a concept that changed everything for me.

Prompt engineering is writing one good prompt and hoping for one good output. It’s a slot machine. Sometimes you win. Sometimes you get “In today’s rapidly evolving landscape...”

Context engineering is different. It’s building a system where every prompt starts with deep knowledge about you, your domain, your audience, and your standards. The AI already knows who you are before you type a single word.

Here’s the formula:

Context Profiles + Skills + Knowledge = Consistent Expert Output

Without a system: you explain everything every time, get inconsistent results, and produce generic output.

With a system: context is always loaded, quality is predictable, and the output actually sounds like you.

Same prompt. Completely different result. Because the AI has context.

What This Looks Like in Practice

Let me show you a real example.

Without a system, you type: “Write me a LinkedIn post about AI in consulting.”

You get: “In today’s rapidly evolving landscape, artificial intelligence is transforming the consulting industry in unprecedented ways...”

Generic. Forgettable. Could have been written by anyone.

With a system, you type the exact same thing. But Claude already knows:

• Your voice (direct, no-BS, short sentences, specific numbers)

• Your audience (corporate professionals aged 30-50 who feel stuck)

• Your business (what you sell, your positioning, your competitors)

• Your content strategy (transformation stories outperform tutorials 3x)

• Your best-performing formulas (salary anchors, interactive CTAs, behind-the-scenes)

Same prompt. Completely different output.

I use this system every day. It writes LinkedIn posts in my voice, generates newsletter content that sounds like me, and produces YouTube scripts that match my style. Not because the AI is magic. Because I gave it the right context.

The Architecture: 4 Components

Every AI expert system uses the same four components. Consultant. Banker. Marketer. Content creator. Same structure.

The structure is identical. What changes is the content inside.

1. CLAUDE.md - The brain. Auto-loaded every session.

2. Context Profiles - Structured knowledge about you, your audience, your business.

3. Skills - Packaged expertise for specific tasks. Load on demand.

4. Knowledge Base - Reference materials, examples, past work.

That’s it. Four components. Works for any domain.

But here’s where most people stop. They get the concept but don’t know how to actually build it.

So let me give you everything.

🔒 The section below is for paid subscribers.

Upgrade to get the complete architecture with copy-paste templates, JSON context profiles, skill files, 4 industry examples, and the step-by-step build guide.

Component 1: CLAUDE.md (The Brain)

Both Cursor and Claude Code read this file automatically at the start of every session. You never tell the AI to read it. It just does.

This is your system’s operating manual. Here’s what goes in it:

• Who you are and what you do

• Where context profiles live and when to use them

• What skills are available

• Your workflow (what the AI should do when you ask it to produce something)

• Your quality standards and rules

The critical rule: Keep it to 200-500 lines.

This file loads into every single conversation. Every token counts. Write like you’re paying per word - because you effectively are.

If you need more detail, put it in context profiles or skills that load on demand. CLAUDE.md is the index, not the encyclopedia.

Here’s the template:

# [Your Domain] Expert System

You are my AI [role]. Your role is to help me [primary objective].

## System Architecture

### Context Profiles

Located in `context/`. Read these before producing anything:

- **domain-expertise.json**: My methodology and approach

- **target-profile.json**: Who I’m serving and their needs

- **operating-context.json**: My business/project context

### Skills

Located in `.claude/skills/`. Reusable instructions for specific tasks.

### Knowledge Base

Located in `knowledge/`. Past work, templates, reference materials.

## Workflow

When I ask you to do something:

1. Identify which context profiles matter

2. Read them to understand approach, audience, and context

3. Check if there’s a skill for this task type

4. If skill exists, follow its instructions exactly

5. Reference knowledge base when relevant

6. Produce output matching my standards

## Available Skills

| Skill | Purpose | Location |

|-------|---------|----------|

| [name] | [description] | .claude/skills/[name]/ |

## Quality Standards

- [Standard 1]

- [Standard 2]

- [Standard 3]

## What I Expect

- Sound like me

- Know my audience

- Use skills when they exist

- Ask for clarification when needed

Component 2: Context Profiles (The Knowledge)

Context profiles are structured JSON files that capture deep knowledge. You create them once. The AI references them whenever relevant.

There are three universal profiles every system needs:

Profile 1: Domain Expertise

Your methodology, philosophy, patterns, and approach.

{

“domain_expertise”: {

“core_philosophy”: {

“primary_belief”: “Strategy without execution is a hallucination”,

“approach”: “Hypothesis-driven, data-backed recommendations”,

“differentiator”: “Always tie to P&L impact”

},

“methodology”: {

“principles”: [

“Issue trees before solutions”,

“Pyramid Principle for all communication”,

“80/20 everything”

],

“process”: [

“Define the problem precisely”,

“Build hypothesis tree”,

“Gather evidence”,

“Synthesize findings”,

“Present with recommendations”

]

},

“patterns”: {

“always_do”: [

“Start with the so-what”,

“Quantify impact in dollars”,

“Present ranges, not single numbers”

],

“never_do”: [

“Present findings without recommendations”,

“Use jargon without defining it”,

“Skip the executive summary”

]

},

“communication_style”: {

“tone”: “Direct, confident, client-ready”,

“structure”: “Answer first, then supporting evidence”,

“vocabulary”: “Business language, not academic”

}

}

}

The power is in the structure. JSON forces you to be specific. You can’t say “I help businesses.” You have to say exactly who, exactly how, and exactly why.

Profile 2: Target Profile

Who you serve. Their demographics, goals, frustrations, language, objections.

{

“target_profile”: {

“who”: {

“role”: “C-suite executives at $500M+ companies”,

“mindset”: “Time-poor, skeptical, want actionable recommendations”,

“experience”: “20+ years in industry, seen consultants come and go”

},

“language”: {

“words_they_use”: [”ROI”, “EBITDA”, “operating model”, “value creation”],

“words_that_resonate”: [”actionable”, “data-driven”, “bottom-line impact”],

“words_that_turn_them_off”: [”synergy”, “paradigm shift”, “innovative”]

},

“goals”: [”Grow revenue”, “Cut costs”, “Outpace competitors”],

“frustrations”: [”Consultants who present problems without solutions”,

“Fluffy recommendations they can’t act on”,

“Death by PowerPoint”],

“objections”: [”Why should I trust this analysis?”,

“What’s different from what we already tried?”,

“Show me the numbers.”]

}

}

Profile 3: Operating Context

Your business, project, or firm context.

{

“operating_context”: {

“firm”: {

“name”: “Your firm or brand”,

“positioning”: “How you’re positioned in the market”,

“differentiators”: [”What makes you different”]

},

“current_focus”: “What you’re working on right now”,

“constraints”: [”Budget”, “Timeline”, “Team size”],

“competitors”: [”Who else does what you do”],

“goals”: {

“short_term”: “This quarter’s objectives”,

“long_term”: “Where you’re heading”

}

}

}

Pro tip: Don’t try to write these from scratch. Use AI to interview you. Paste this prompt into Claude:

Interview me to create a domain expertise profile for [YOUR DOMAIN].

Ask me about my philosophy, methodology, always/never patterns,

differentiators, and communication style.

Output structured JSON.

Let it ask you 5-8 questions. Answer honestly and specifically. The more specific you are, the better your system will be. Then repeat for target profile and operating context.

Component 3: Skills (The Most Powerful Piece)

A skill is a set of reusable instructions for a specific task. Instead of explaining how to write a pitch deck every time, you create a skill once and it works forever.

Here’s what makes skills brilliant: progressive disclosure.

When you start a session, Claude only loads each skill’s name and description - about 50-100 tokens each. It doesn’t load the full instructions until it decides the skill is relevant to your request.

This means you can have 50 skills and they barely touch your context window. Compare that to cramming everything into CLAUDE.md - that all loads immediately, every time, whether you need it or not.

The Skill Template

Every skill lives in .claude/skills/[skill-name]/skill.md:

# [Skill Name]

## Purpose

[One sentence: what this skill does]

## When to Use

[Conditions that trigger this skill]

## Inputs Required

- [Input 1]: [Description]

- [Input 2]: [Description]

## Process

### Step 1: [Name]

[Detailed instructions]

### Step 2: [Name]

[Detailed instructions]

### Step 3: [Name]

[Detailed instructions]

## Output Format

[What the deliverable looks like]

## Quality Checklist

- [ ] [Verification check 1]

- [ ] [Verification check 2]

- [ ] [Verification check 3]

The quality checklist is critical. It makes the AI prove its work before delivering. Without it, you get first-draft quality. With it, you get reviewed, verified output.

Component 4: Knowledge Base

Your reference library. Past work, templates, examples, documentation.

The AI doesn’t read all of this at startup. It accesses specific files when a skill or prompt tells it to. Another form of progressive disclosure.

What goes in here:

• Examples of good output - Past proposals, reports, content you’re proud of

• Templates - Frameworks you use repeatedly

• Client/project info - Details the AI needs for specific work

• Industry data - Research, standards, benchmarks

Structure it however makes sense for your domain:

knowledge/

├── examples/ # Your best past work

├── templates/ # Reusable frameworks

├── resources/ # Industry data, research

└── outputs/ # What the system generates

Industry Examples: What This Looks Like in Practice

Consulting

Context profiles: Issue trees, Pyramid Principle, hypothesis-driven methodology. Target: C-suite at $500M+ companies.

Skills you’d build:

• market-sizing/ - TAM/SAM/SOM analysis

• issue-tree/ - Systematic problem decomposition

• slide-pack/ - Consultant-quality slide structures

• exec-summary/ - One-page executive summaries

• client-brief/ - Client information synthesis

Investment Banking

Context profiles: Multi-method valuation framework. Always triangulate. Present ranges, never single numbers.

Skills you’d build:

• comp-analysis/ - Comparable company data

• pitch-book/ - Pitch book sections

• deal-memo/ - Transaction rationale

• valuation-summary/ - Multi-methodology synthesis

• market-update/ - Weekly sector briefing

Digital Marketing

Context profiles: Test everything. Data over opinions. Bottom-of-funnel before top-of-funnel.

Skills you’d build:

• campaign-brief/ - Creative briefs from product/audience info

• ad-copy-variants/ - 10 headline variants, scored and ranked

• landing-page/ - High-converting page structures

• audience-analysis/ - Segment and prioritize

• performance-report/ - Weekly campaign synthesis

Content Creation (What I Actually Use)

Context profiles: voice_dna.json (how I sound), icp.json (who reads my content), business_profile.json (what I’m building toward).

Skills I built:

• linkedin-posts/ - LinkedIn content in my voice

• substack-posts/ - Newsletter deep dives (like this one)

• youtube-scripts/ - Video scripts

• hook-generator/ - Generate and score hook variations

• voice-checker/ - Catch AI-sounding text before I publish

The system includes verification loops. The AI doesn’t just write - it checks its work. “Is this hook actually good? Does the body deliver? Will the CTA convert?” This is what separates amateur AI usage from professional systems.

Same architecture. Different content. Every domain.

The Folder Structure (Copy This)

your-expert-system/

├── CLAUDE.md # System instructions (auto-loaded)

├── .claude/

│ └── skills/ # Packaged expertise

│ ├── skill-name-1/

│ │ └── skill.md

│ └── skill-name-2/

│ └── skill.md

├── context/ # Context profiles (JSON)

│ ├── domain-expertise.json

│ ├── target-profile.json

│ └── operating-context.json

└── knowledge/ # Reference materials

├── examples/

├── resources/

└── outputs/

Build Yours This Weekend

Here’s the sequence:

Step 1 (30 minutes): Let AI interview you for your domain expertise profile. Paste the interview prompt from above. Answer the questions. Save the JSON to context/domain-expertise.json.

Step 2 (20 minutes): Pick your most repetitive task. The thing you do every week that requires your expertise. Write a skill for it using the template above. Save it to .claude/skills/[name]/skill.md.

Step 3 (15 minutes): Write your CLAUDE.md using the template. Wire everything together. Point it at your context profiles and skills.

Step 4 (5 minutes): Open your project in Cursor or Claude Code. Ask: “What rules are you following?” The AI should reference your CLAUDE.md, context profiles, and skills. Then give it a real task from your domain. Compare the output to what you’d get without the system.

Total time: about an hour.

Why This Compounds

I started with 1 skill and 1 context profile. Output was good.

A month in, I had 5 skills and 3 profiles. Output was consistently great.

Now I have 15+ skills, full context, and a knowledge base. The system writes LinkedIn posts, newsletter content, and YouTube scripts that sound like me. Not because AI is magic. Because I gave it enough context to be useful.

Tools help once. Systems compound forever.

Common Mistakes

Putting everything in CLAUDE.md. It’s the index, not the encyclopedia. Use skills for detailed instructions.

Vague skill descriptions. “Helps with tasks” will never get triggered. Be specific about when to invoke it.

No verification loops. Add quality checklists. Make the AI prove its work.

Analysis paralysis. Start with 1 profile and 1 skill. Build the rest as you go. Ship beats perfect.

Context + Instructions = Quality Output.

Better input, better output. Every time.

You’re not learning to use AI. You’re learning to engineer the context that makes AI work for you.

That’s the skill.

What domain would you build your AI expert system for? Drop it in the comments - I’ll tell you which skills to build first.

If you want to build this live with me, I run Friday workshops inside the AI Builders Club where we build these systems step by step.

Questions

What domain would you build your AI expert system for? Drop it in the comments - I’ll tell you which skills to build first.

Paid Subscriber Bonus

Everything below the paywall: the complete architecture, webinar recording, all templates (.md, context profiles, skill files), 4 industry examples, the folder structure, and the step-by-step build guide.

Read more

A few weeks ago, a tweet blew up about an AI character called Yang Menus. He’s a “Buddhist monk” with 2.5 million followers on Instagram, dispensing feel-good wisdom in short video reels. The creator behind him claims over $300,000 in profit in 90 days.

Yangmunus’ instagram: https://www.instagram.com/yangmunus/

I DM’d him for his free guide. It was a pitch for a course. No secrets revealed.

So I did what any self-respecting automation nerd would do - I reverse-engineered the formula, built my own character, and automated the entire pipeline in n8n.

This post walks through exactly how it works, node by node. I’m also sharing the full workflow JSON so you can import it into your own n8n instance and start experimenting.

The Concept: Why AI Influencers Work

Before we get into the build, let’s talk about why this works at all.

These AI influencer accounts follow a simple formula. A consistent character (usually an older, wise figure) delivers short motivational or wisdom-based monologues over a static or lightly animated image. The content hits because it feels personal, like someone is talking directly to you. The character never has a bad day, never goes off-brand, and can produce content at a pace no human could sustain.

Yang Menus has 192+ posts and 2.5 million followers. He monetizes through ebooks, mini-courses, and a weekly newsletter. The AI influencer at the Australian Open earlier this year had over a million followers and people didn’t even realize she wasn’t real.

The applications go well beyond motivational content though. Think training videos where you need to replicate yourself across dozens of modules. Product explainers. Internal comms. Customer onboarding. Any scenario where you’d normally need a camera, a script, good lighting, and hours of filming - you can now generate with a photo, a voice profile, and an automation pipeline.

Meet Macca Douglas

For this build, I created Yarns from the Paddock - an Instagram channel hosted by Macca Douglas, a 62-year-old fourth-generation cattle farmer from Central Queensland.

Macca talks about mateship, hard yakka, bush wisdom, and community. He sounds like the bloke at the country pub who says one sentence and the whole bar goes quiet because he’s right. Think part bush poet, part no-nonsense uncle, part the neighbor who turns up with a ute full of hay when your fences go down.

The character has four content buckets:

• Mateship & Character - What it means to be a good bloke. Loyalty, showing up when it counts.

• Hard Yakka & Grit - The value of work, getting your hands dirty, lessons from the land.

• Bush Wisdom - Old sayings, lessons from nature, reading the weather and reading people.

• Community & Country - Looking after your neighbor, small-town spirit, giving a hand when someone’s doing it tough.

You can obviously swap this out for any character or niche. An accountant dropping tax tips. A VC sharing startup lessons. A fitness coach. A history professor. The pipeline doesn’t care about the persona - it just needs a well-defined character and a topic.

The Pipeline: 8 Steps from Topic to Finished Reel

Here’s what the workflow does end to end:

1. Form Input - You submit a topic and content bucket via a simple web form

2. Script Generation - Claude (via OpenRouter) writes a complete reel script with hook, body, close, and CTA

3. Image Prompt Generation - Gemini Flash creates a detailed image generation prompt, randomly selecting from 10 Australian rural visual styles

4. Character Image Generation - Gemini generates a photorealistic portrait of Macca using a reference photo and the prompt

5. Voice Generation - ElevenLabs converts the script into spoken audio with an Australian voice

6. CDN Upload - Both files get uploaded to FAL’s CDN so they’re accessible via public URLs

7. Talking Video Generation - FAL AI’s Creatify Aurora model combines the image and audio into a lip-synced talking-head video

8. Transcription - OpenAI Whisper transcribes the video for captions, then the pipeline compiles an output summary with the Instagram caption and hashtags

The whole thing runs in about 10-15 minutes. You submit the form and go put the kettle on.

What You Need Before You Start

Accounts and API Keys

You’ll need accounts (and API keys) from the following services:

OpenRouter (openrouter.ai) - This is the gateway to the LLMs. The workflow uses Claude Opus 4.6 for script writing and Gemini Flash for image prompt generation. You could swap these for other models, but these are what I’ve tested and they work well. Sign up, add credit, and grab your API key from the dashboard.

Google Gemini (ai.google.dev) - Used for generating the character image. The workflow calls the Gemini 2.5 Flash image generation endpoint directly. You’ll need a Gemini API key, which you can get from Google AI Studio.

ElevenLabs (elevenlabs.io) - Handles the voiceover. You’ll need both an API key and a Voice ID. ElevenLabs has a voice library where you can browse and select voices. Find one that fits your character, copy the Voice ID from the voice settings page, and you’re set. For Macca, I picked an Australian male voice - not too polished, a bit weathered.

FAL AI (fal.ai) - Two purposes here. First, their CDN hosts the image and audio files so the video generator can access them. Second, their Creatify Aurora model generates the actual talking-head video. You’ll need a FAL API key from your dashboard.

OpenAI (platform.openai.com) - Only used for Whisper transcription at the end. If you don’t need captions, you can skip this one entirely.

n8n Setup

You’ll need an n8n instance, either cloud-hosted or self-hosted. If you’re self-hosting, you’ll need to install the FAL AI community node - search for it in the node panel and click install.

Set up these environment variables in your n8n Settings (Settings > Environment Variables):

OPENAI_API_KEY        - Your OpenAI key (for Whisper)
OPENROUTER_API_KEY    - Your OpenRouter key
GEMINI_API_KEY        - Your Google Gemini key
ELEVENLABS_API_KEY    - Your ElevenLabs key
ELEVENLABS_VOICE_ID   - The voice ID from ElevenLabs
FAL_API_KEY           - Your FAL AI key

You’ll also need to set up a FAL AI credential in n8n (Settings > Credentials > Add New > search “fal.ai”) and link it to the Aurora node.

Detailed Walkthrough: Node by Node

Node 1: Receive Reel Topic Form

This is a simple n8n Form Trigger. It presents two fields:

• Reel Topic (text) - e.g. “Why the best blokes never have to tell you they’re tough”

• Content Bucket (dropdown) - One of the four buckets listed above

When you submit, it responds with: “Reel’s on the way, mate. Give it 10-15 minutes. Go stick the kettle on.”

The form has a webhook ID, so you can bookmark the URL and submit new topics anytime.

Node 2: Validate Topic Input

A simple IF node that checks the topic is at least 5 characters long. If it fails, it throws an error: “Topic too short, mate. Give us at least 5 characters to work with.”

Node 3: Build Script Generation Request

This is where the magic starts. A Code node constructs the full prompt for Claude, including:

• Macca’s complete persona and backstory (fourth-generation grazier, lost the property in the millennium drought, rebuilt from nothing)

• His voice DNA (warm, weathered, unhurried, dry as the Darling in a drought)

• Strict structural requirements (45-55 seconds max, 100-130 words, because the video generator caps at 60 seconds)

• A library of Aussie slang and expressions to draw from

• The exact JSON output format the script needs to follow

The prompt engineering here matters a lot. I spent time scraping and analyzing Yang Menus’ actual scripts with Claude to understand the hook placement, pacing, and tone. That analysis informed the prompting for Macca’s character.

The output structure includes the hook (with on-screen text), body sections, close, CTA, visual rationale, Instagram caption, and hashtags.

Node 4: Generate Reel Script via OpenRouter

An HTTP Request node that sends the prompt to OpenRouter’s API, targeting Claude Opus 4.6. It has a 120-second timeout and will retry up to 3 times with 3-second waits between attempts.

Node 5: Parse Script and Extract Data

A Code node that extracts the JSON from Claude’s response (handling markdown code blocks if present), then breaks it apart into individual fields: voiceover text, title, hook text, CTA text, caption, hashtags, and visual rationale. The voiceover text is assembled by concatenating the hook, all body sections, the close, and the CTA.

Node 6: Build Image Prompt with Random Style

This is one of my favorite nodes. It has 10 pre-built visual styles for Macca:

• Homestead Verandah (sunset, golden paddocks, kelpie asleep nearby)

• Stockyard Morning (dawn mist, red dust, eucalyptus trees)

• Country Pub (timber bar, tin ceiling, beer taps)

• Under the Gum Tree (massive river red gum, dry creek bed)

• Workshop Wisdom (tools on pegboard, ute through the roller door)

• Campfire Evening (billy on the fire, stars appearing)

• Paddock at Dawn (rolling green after rain, windmill turning)

• Shearing Shed (heritage timber, wool bales, dramatic light)

• Dam at Sunset (red earth bank, cattle drinking)

• Kitchen Table (scrubbed timber table, enamel mugs, family photos)

Each style includes specific attire, backdrop, lighting, and mood descriptions. The node randomly selects one each run, so you get visual variety across reels without having to think about it.

It then sends all of this to Gemini Flash via OpenRouter to generate a structured image generation prompt.

Node 7: Generate Image Prompt via OpenRouter

Another HTTP Request to OpenRouter, this time using Gemini Flash to create the detailed image prompt. The model returns structured JSON with subject details, attire, environment, technical specs, keywords, and negative prompts.

Node 8: Parse Prompt and Build Gemini Request

Takes Gemini Flash’s structured output and converts it into the format that Gemini’s image generation API expects. It assembles a detailed text prompt from all the structured fields and sets the aspect ratio to 9:16 (vertical, for Instagram Reels).

Node 9: Load Reference Image for Gemini

Downloads a reference photo from a URL and converts it to base64, then adds it to the Gemini request. This is how you maintain character consistency - Gemini uses this reference to ensure the generated image resembles your character. You’ll want to swap in your own reference image URL here.

Node 10: Generate Character Image via Gemini

Sends the complete request (text prompt + reference image) to Gemini’s image generation endpoint. It has a 120-second timeout and retries twice with 5-second waits. The model returns the generated image as base64 inline data.

Node 11: Extract Image from Gemini Response

Extracts the base64 image from Gemini’s response and stores it as n8n binary data. This is important - large base64 strings can cause JSON truncation issues in n8n, so the image goes into the binary channel while metadata stays in JSON.

Node 12: Generate Voiceover via ElevenLabs

Sends the voiceover text to ElevenLabs’ text-to-speech API. The workflow uses the eleven_multilingual_v2 model with these voice settings:

• Stability: 0.55

• Similarity Boost: 0.72

• Style: 0.35

• Speaker Boost: enabled

These settings give a natural, slightly varied delivery. Crank stability higher for more consistency, lower for more expressiveness. The response comes back as an audio/mpeg file.

Nodes 13-17: FAL CDN Upload (5 nodes)

This section was the trickiest part of the build. FAL’s Aurora model needs publicly accessible URLs for both the image and audio, which means uploading them to a CDN first. n8n’s binary data handling on cloud instances has some quirks, so I split this into 5 nodes:

1. Initiate FAL CDN Uploads - Requests presigned upload URLs from FAL for both the image and audio files

2. PUT Image to FAL CDN - Uploads the image binary to the presigned URL

3. Restore Audio Binary for Upload - Recovers the audio binary reference (n8n drops binary data after HTTP requests, so this pulls it back from an earlier node)

4. PUT Audio to FAL CDN - Uploads the audio binary to its presigned URL

5. Build FAL Aurora Input - Assembles the final payload with the CDN URLs and a cinematic prompt for Aurora

The cinematic prompt tells Aurora: “4K cinematic interview, medium close-up shot. Warm natural Australian sunlight. Weathered older man speaking with warmth, dry humour, and quiet authority. Outdoor rural feel. Professional quality, steady frame.”

Node 18: Generate Talking Video via FAL Aurora

This uses the FAL AI community node (not a standard HTTP request). It sends the image URL, audio URL, and prompt to the Creatify Aurora model. The node handles job submission, polling (every 5 seconds), and result retrieval automatically. Max wait time is 10 minutes.

Node 19: Download Generated Video from FAL

Downloads the finished video from FAL’s servers.

Node 20: Transcribe Video via OpenAI Whisper

Sends the video file to OpenAI’s Whisper API for transcription. It requests verbose JSON with word-level timestamps, which you can use for generating captions or subtitles.

Node 21: Pipeline Complete - Output Summary

Compiles everything into a final summary: status, video URL, image URL, audio URL, transcript with word-level timing, Instagram caption, hashtags, and metadata.

How to Import and Configure

1. Download the workflow JSON from the Skool classroom (or from the link in this post)

2. In n8n, go to Workflows > Import from File and select the JSON

3. Set up your environment variables (Settings > Environment Variables) with all 6 API keys listed above

4. Create a FAL AI credential (Settings > Credentials) and link it to the “Generate Talking Video via FAL Aurora” node

5. If self-hosting, install the FAL AI community node (search “fal.ai” in the node panel)

6. Replace the reference image URL in the “Load Reference Image for Gemini” node with your own character reference photo

7. Update the ElevenLabs voice ID in the voiceover node URL to match your chosen voice

8. Activate the workflow and visit the form URL to submit your first topic

Estimated Cost Per Reel

Here’s roughly what each reel costs to generate:

• Script generation (Claude Opus via OpenRouter): ~$0.03-0.08

• Image prompt (Gemini Flash via OpenRouter): ~$0.01

• Character image (Gemini): ~$0.01-0.03

• Voiceover (ElevenLabs): ~$0.05-0.15 depending on length

• CDN + Video generation (FAL Aurora): ~$0.10-0.30

• Transcription (Whisper): ~$0.01

Total: roughly $0.20-0.60 per reel.

Compare that to the cost of a camera setup, lighting, filming time, editing, and post-production. Even at the high end, you could produce 100 reels for under $60.

What’s Not Automated (Yet)

The workflow gets you to a finished video with a caption and hashtags, but it doesn’t post to Instagram automatically. That’s a deliberate choice for now - I want to review the output before it goes live. But you could extend the pipeline with an Instagram API integration or use a scheduling tool like Later or Buffer.

Captions and text overlays are also not baked into the video. Whisper gives you the word-level timestamps, so you have everything you need to add them in post, but the actual overlay rendering would need a separate step (FFmpeg or a service like Kapwing).

Adapting This for Your Own Character

The beauty of this setup is that the character is entirely defined in the prompts. To create your own AI influencer or avatar:

1. Define the persona in the script generation prompt - backstory, voice, speaking style, slang, references

2. Set up visual styles in the image prompt node - swap the 10 Australian settings for whatever fits your character

3. Choose a reference photo - this drives character consistency across all generated images

4. Pick a voice on ElevenLabs - browse their library or clone your own

5. Update the content buckets in the form dropdown

Everything else in the pipeline stays the same.

Macca Douglas!

Resources

• FAL AI: fal.ai - for video generation and CDN

• ElevenLabs: elevenlabs.io - for voice generation

• OpenRouter: openrouter.ai - for LLM access

• Yang Menus (case study): @yangmenus on Instagram

If you build something with this, I’d love to see it. Drop a comment or send me a message in the Skool community.

Get the Workflow JSON

The full n8n workflow JSON is available below the paywall. Import it directly into your n8n instance, plug in your API keys, and you’re ready to go.

One thing worth mentioning - on February 15th, the $59 subscription price for this newsletter is going away permanently. After that date, the only way to access these workflows and tutorials will be through the Zero to Builder course or by purchasing individual webinars separately. If you’ve been on the fence, this is your last window to lock in access to everything at that price.

Read more