You think the model is the problem.

It is not. Nobody ever told Claude what correct means, so it guessed. It guessed something that looked finished, sounded confident, and was wrong in a way it could not see on its own.

You cannot prompt your way out of that. The model that made the mistake is the same model grading it.

Three weeks ago I showed the gate system running my infographic lab. Best issue I have ever sent. Twenty-plus new paid subscribers, and an inbox full of the same question.

Not “how do I make infographics.”

Just: does this work on anything that is not a picture?

Yes. Gates were never about pictures. I only found them there first.

Most people prompt Claude Code like this:

Ask → get an answer → skim it → ship it.

That works until it does not. By then the report is in your inbox, or the code is already live.

Here is how I do it now:

Ask → Claude checks the work against a rule you wrote down → it fixes itself, or it hands you nothing.

That is a gate. Nothing more than that.

If this is useful, share it with one person who keeps posting or sending work they end up apologizing for. Takes ten seconds.

Share

Before we start

Not getting our issues in your inbox? Gmail is probably filing them under Promotions or Spam.

Two seconds fixes it forever:

→Open this email in Gmail

→ Drag it into your Primary tab

→ Click Yes when Gmail asks if you want to do this every time.

If it landed in Spam, hit Not spam first, then drag.

Every future issue goes straight to Primary.

What a gate is

A gate is a rule, written in plain English, saved in a file. Before Claude hands you anything, it checks the work against that rule. Pass or fail. Nothing in between.

I did not sit down and design a system. I could not have. Every gate in my registry got pulled out of something Claude got wrong that I almost shipped anyway.

Right now my infographic lab runs 193 of them, sitting in five files.

Content Quality Gates - 54

Motion Quality Gates - 50

Layout Quality Gates - 47

Visual Quality Gates - 41

Export Quality Gates - 1

None of them were designed up front. Every single one was harvested from a real build that went wrong in that exact way.

Every gate has the same six parts

## <Name> Gate (permanent, YYYY-MM-DD)
Required score: 100/100
Purpose: the single failure this gate prevents
Approval fails if: explicit, checkable failure conditions
Required: the positive checklist that must be true
Hard fail: the condition that stops the build entirely
Reference application: the real build this came from

Two details in there carry the whole system.

Fail conditions are observable, never aspirational: Not “the layout should breathe” but “no large purposeless empty region.” If two reasonable people could disagree about whether something passed, the gate is not finished being written.

Every gate carries a date and the build that produced it. So the registry doubles as a changelog of everything I have got wrong since July.

The two scores and the loop

People copy this system and get this part wrong. Two numbers, two different scales.

1. Each gate is binary. Score: 100. Text is inside its box, or it is not. The CTA is in the safe area, or it is not. A gate at 98 is just a longer way of writing blocked.

2. The build is scored out of 100, and 97 is the floor. That is craft. Hierarchy, balance, pacing, whether the thing is actually good. A design is allowed to be excellent instead of perfect.

Here is the part that does the work.

Under 97 does not get notes. It does not ship with an apology attached. It goes back and runs again and again until it clears 97.

Correctness is not negotiable. Craft is. Split those two apart, and most of the arguments in your own head disappear.

If this is useful, share it with one person who keeps posting work they regret. Takes 10 seconds.

Share

Part 1: How a gate gets born

Five steps. All 193 came through this loop.

One. A build ships, or nearly ships, with a visible flaw.

Two. The flaw goes into the mistakes log. Three fields: what failed, why it failed, what was salvageable. That third field matters. Most broken builds are 90 percent fine, and you want to keep the good part.

Three. The lesson becomes a named gate with observable fail conditions.

Four. The gate lands in the right gate file, gets mirrored into CLAUDE.md and the master list, and is dated to the build that created it.

Five. Every future build runs it.

Here is the very first one.

On 2026-07-07, the text in Cut Claude Output Tokens by Up to 75% with One Skill was not aligned properly. The layout looked unprofessional. It killed trust and made the piece feel unfinished.

Then the permanent fix. Every visual must pass the Layout Quality Gate before export.

That is a gate being born, on a specific day, out of a specific piece of work.

“The gate is the fossil of the mistake. Read the registry backwards, and you have a complete history of everything that has gone wrong.”

Let me show you what I get after this gate:

Part 2: Where the gates fire

First you need the map. A gate is useless if it runs at the wrong moment.

Five stages. Every gate belongs to one.

Stage 1: Pre-build. The plan, before anything is drawn.

Stage 2: Build-time. Checks inside the code as it renders.

Stage 3: Render. Motion checked against real frames.

Stage 4: Inspection. The exported file, cropped at 100 percent. Most failures get caught here.

Stage 5: Export lock. The final refusal point.

Every gate below names its stage.

Part 3: Eight gates, read properly

Now let’s deep dive into the gates that I am using for my infographics.

Eight that each do a different job, in the order they fire.

Gate 1: Grammar Verification

How it works. Requires 100. Fails on any spelling, grammar, punctuation, or tense error. Fails on awkward or unclear wording. Fails on a single typo in any visible text.

Then it lists every surface it covers: titles, subtitles, body text, card titles, prompt blocks, chips, badges, labels, captions, CTAs, footers.

That list is the part everyone skips. A gate without a stated scope is a suggestion. A gate that names every surface cannot be quietly skipped on the one element nobody thought to check.

Where it lands. Stages 2 and 4. Once before the build, once on the exported file. A layout change re-wraps text, and re-wrapped text creates errors that were not there ten minutes ago.

How it was created. 2026-07-08, after typos survived into finished boards. One of four originals: Grammar, Truth, Text Containment, CTA Placement. If any of those fail, nothing gets approved. Everything else was built around that spine.

Gate 2: Truth and Practical Applicability

How it works. Required 100. Fails if information is misleading, advice is vague, steps are unrealistic, claims are exaggerated, tools are described incorrectly, or the reader cannot actually use the workflow.

Two conditions deserve a second read.

Time estimates that are impossible for the task. Everyone in this space does this. Almost nobody checks for it.

The design sounds impressive but does not help. That is a gate against your own ego, made binding.

Where it lands. Stage 1. Truth gets settled before anything is drawn, because a false claim is not a rendering problem. On research-heavy builds, every claim on the canvas traces to an official page. On the Grok build, the only number in the final image came straight from the vendor’s docs.

How it was created. 2026-07-08, alongside Grammar. A cheat sheet can be perfectly rendered and still be wrong. Wrong is the only failure your audience remembers.

A truth gate is not a vibe. It is a ledger. Every claim on the canvas points at a source, or the claim comes off the canvas.

Gate 3: Pixel Text Containment

The oldest wound in the system, and the only failure a reader spots instantly.

How it works. Required 100. Fails if any text crosses outside its card, overflows a code block, touches a border, gets clipped, or hides behind another element.

What it requires. Every text element is measured against its parent’s safe area. Minimum 18px padding. Code blocks wrap before they overflow. The final PNG inspected at 100 percent.

Then the hard fail, the most useful line in my whole system:

Never fix overflow by shrinking text below readability. Remove content instead.

The lazy fix is always to shrink the type. The gate forbids it, so the only move left is cutting a sentence. That almost always makes the piece better.

Where it lands. Stages 2 and 4. The code measures it, then the export gets inspected anyway. Measurements can be right, and the render can still surprise you.

How it was created. From the 2026-07-07 overflow. Upgraded 2026-07-13 from “look at it” to “measure it,” after looking kept not being enough.

Gate 4: Bottom CTA Placement

How it works. Required 100. Fails if the CTA is cropped, touches the canvas edge, sits too low and eats the image, takes too much vertical space, floats up into the content, or does not match the approved footer.

Placement is specified down to the number: 32 to 48px bottom margin, one compact footer row, CTA text left, avatar and link and byline right.

Where it lands. Stages 1 and 4. Stage 1 is the interesting one, because of the rule attached to it:

Budget the full vertical stack before building. Hero, claim, grid, strips, footer, gaps, paddings.

An over-budget stack pushes the footer past the bottom edge even when the layout code is correct. Nudging the footer up works once. Budgeting the stack works forever.

How it was created. 2026-07-07, from the Claude Bible build, where the footer ate the canvas. My log calls it the repeat offender, which is why it earned a root cause rule instead of just a check.

“Fix the cause, not the symptom. A gate that keeps firing is telling you the rule is written one level too shallow.”

Gate 5: 2K GIF Readability

This one is specific to what I make. If you publish animated infographics, it is the most valuable gate here.

How it works. Required 100. Fails if the GIF exports below 1440 by 1800, if text is blurry or too small, if compression destroys clarity, if motion makes text unreadable, or if anything important can only be read by zooming.

What it requires. Export at 1440 by 1800 minimum, downscaled from a 2880 by 3600 source. Text sized for GIF legibility before export. Light compression. No motion blur over text. A final hold of at least two seconds. And a manual check at normal viewing size, not zoomed.

There is an escape hatch built in. If the GIF cannot stay sharp, export the MP4 too and write down the limitation.

Where it lands. Stage 4, on the exported file. There is no way to check this from the code.

How it was created. 2026-07-13. GIFs that looked fine at full size turned to mush in the feed. Every version since gets checked at the size people actually see it.

“Check it at the size people will see it. Zooming in to confirm your work is readable is how unreadable work gets published.”

Gate 6: Loop Smoothness

How it works. Required 100. Fails if the loop jumps, dots reset visibly, the final hold is too short, the animation ends abruptly, or the motion feels unfinished.

Short gate. Enormous effect. A loop that visibly snaps is the fastest way to make finished work look amateur. And it stays invisible while you build, because you are watching one pass, not a loop.

Where it lands. Stage 3 on rendered frames, confirmed at Stage 4 on the export.

How it was created. 2026-07-09, after early builds shipped with hard resets, nobody noticed until they were live in a feed on repeat.

Gate 7: Real Gate Enforcement

The gate that exists because the system tried to grade its own homework.

How it works. Its purpose line is eight words:

Gate scores must be earned by inspection, never claimed.

Fails if a score is claimed without inspection, if the final image still has overflow or unreadable text, or if files ship despite known issues.

What it requires. Inspect the export at 100 percent. Confirm every hard fail on the file itself. Re-render after each fix. Report the exact fixes.

Then the hard fail:

If “passed” is reported while visible issues remain, reject.

Where it lands. Stage 4, and it outranks everything there. If this fails, the other results are worthless. They were never really run.

How it was created. 2026-07-20. A confident report arrived about work nobody had looked at. Every line said passed. No evidence anywhere.

The fix is not more instructions. It is making a fake pass cost the entire run.

Gate 8: Final PNG Standalone

The only export gate in the system, and the only one whose correct output is nothing at all.

How it works. Requires 100. Fails if any required image is missing, anyone is unverified, missing images get silently replaced, or the file ships with placeholders.

The hard fail:

If any required image is missing, stop and produce a missing report instead of exporting.

Where it lands. Stage 5. The last thing standing between a build and the outside world.

How it was created. 2026-07-18. A creator map build ran with 28 of its 40 photos missing. The output that day was a report explaining why it refused to render.

My log records that build as correctly blocked. I am showing you a day my system produced nothing on purpose.

A quality system that has never blocked anything is decoration.

Read more

On August 11, 2026, xAI released Grok Bot, its first real answer to the “AI agent” category everyone’s been circling all year.

Not a smarter model. Not a faster chat window.

An actual AI teammate, one you assign real work to, that keeps working after you’ve closed your laptop and gone to bed.

I spent the past week testing it, reading through every teardown I could find, and setting up my own team of bots.

This guide is everything I wish someone had handed me before I started, written for people who’ve never worked with an AI agent.

By the end of this, you’ll know what Grok Bot actually is, how to set it up from zero, what it costs, whether it’s safe, and how to build a team of bots that report to you as actual employees would.

And stay till the end - I’m handing paid subscribers the exact 7-bot team blueprint I built, complete with the ready-to-paste job briefs for each one, the approval-queue rules, and routine schedules so you can clone the whole setup instead of building it from scratch.

Let’s get into it.

Table of Contents

1. AI Agents in Plain English

2. The Basics: What Grok Bot Actually Is

3. Words You’ll See in This Guide

4. How to Set Up Grok Bot

5. Real-World Use Cases

6. Build Your Own Bot Team

7. Mistakes Beginners Make in Their First Week

8. Grok Bot vs Hermes vs OpenClaw vs Buzz

9. What Grok Bot Actually Costs

10. The Safety Tradeoff Nobody Talks About Enough

11. Your First 24 Hours With Grok Bot

12. Who Should Actually Use Grok Bot Right Now

AI Agents in Plain English

Before we get into Grok Bot specifically, let’s slow down for a second.

Most people have used a chatbot before. You type a question, it answers, you close the tab, and it forgets everything the moment you leave.

An AI agent works differently. Instead of just answering, it can actually carry out the task. It can open a browser, navigate a website, fill out a form, check an inbox, or update a spreadsheet, just as a person would.

Think of the difference between asking a smart friend for directions and asking them to actually drive you there. A chatbot gives you the directions. An agent gets behind the wheel and takes you the whole way.

Grok Bot takes this a step further. Instead of one agent doing one task and stopping, it hands you a team of agents that each run on their own computer in the cloud. They don’t stop when you close your laptop, because they were never running on your laptop to begin with.

That’s the whole idea in a few sentences. Everything else in this guide is just the details of how it actually works in practice.

The Basics: What Grok Bot Actually Is

Most AI tools answer questions. Grok Bot tries to finish jobs.

A normal chat session lives inside a window, and the moment you close it, the work stops. Grok Bot doesn’t work that way.

Every bot you create gets its own cloud computer. Its own browser. Its own file system. Its own terminal. That computer runs in a data center, not on your laptop, which means the bot keeps going whether or not you’re anywhere near your device.

You give a bot a job the same way you’d brief a new hire. It signs into the tools you already use, using your own logins, and works through the task the way a person would. When it hits something that needs your approval, it comes back and asks. Otherwise, it just finishes the job and reports in.

xAI built this as an internal tool first. Teams inside the company started using it for sales outreach, marketing, office admin, and bug fixes, and it apparently spread through the company faster than expected before they decided to release it publicly.

It launched jointly with Cursor, the AI coding company that SpaceX acquired earlier in 2026 for a reported $60 billion. That merger is why access to Grok Bot runs through Cursor’s subscription tiers instead of being sold on its own; more on that in the pricing section.

One more thing worth knowing up front: Grok Bot isn’t the same product as the Grok chatbot you might already use on X, and it isn’t Grok Build (the coding-focused CLI) either. Three different products, same underlying company, easy to mix up.

If this is useful, share it with one person who still re-explains their business to a chatbot every morning. Takes 10 seconds.

Share

Words You’ll See in This Guide

A handful of terms come up constantly once you start using Grok Bot. Here’s what each one actually means, in plain language, before we get into the setup steps.

Bot: one AI teammate with one job. You can create as many as you want, and each one runs on its own.

Plugin: the connection between a bot and a tool you use, like Slack, Gmail, or Notion. A bot can only work inside tools it has been plugged into.

Routine: a scheduled, repeating task. If a bot checks something every morning at 6 am, that’s a routine. Essentially a cron job with a friendlier name.

Approval queue: the point where a bot pauses and waits for you to say yes before it goes further. This is how you stay in control without watching every single step it takes.

Cloud computer: the virtual machine each bot runs on. It isn’t your laptop; it lives on a server somewhere else, which is why the work keeps going after you close your own device.

Keep these five in your head, and the rest of this guide will make a lot more sense.

How to Set Up Grok Bot

Setup is fast. Here’s exactly how it goes, step by step.

Step 1: Download the app

Head to the official download page and grab the macOS build.

This is still a beta release, so the official page is the only safe place to get it; avoid downloading it from anywhere else.

Step 2: Install it

Drag the app into your Applications folder. That’s the entire install process; nothing to configure yet.

It looks sweet on the deck:)

Step 3: Sign in

Open the app and sign in with your email. One thing you should know before you get here: a card is required at this step. It’s not optional, and there’s no free trial tier to poke around in first.

Note: You didn’t see any card option, as I already have the card on file.

Step 4: Land on the dashboard

Once you’re signed in, you’ll see the main interface. This is your control room. Every bot you create will live here, and you’ll message each one the way you’d message a coworker.

Step 5: Connect your plugins

Before you build a single bot, connect the tools you actually work in. Slack, Gmail, Notion, whatever your day-to-day stack looks like. A bot can’t do anything inside a tool it isn’t connected to, so this step is really what decides what your bots will be capable of later.

Step 6: Authenticate everything

Go through each plugin and authorize it individually. This is the step that actually matters; it’s what lets a bot act inside those tools instead of just talking about them.

Step 7: Create your first bot

Now the part that matters. Give the bot one job. Don’t try to build a generalist on your first attempt; the bots that work best are the ones with a narrow, clearly defined role.

That’s the whole setup. A few minutes, no infrastructure, no server to configure.

Real-World Use Cases

Once people got past the first ten percent of Grok Bot (typing questions into it like a chatbot), the real use cases started showing up fast.

Early adopters are running research bots that scan YouTube or LinkedIn every morning and deliver a briefing before they’ve had coffee.

Others built a bot that watches property listings twice a day and flags anything priced well under comparable sales in the area. There are portfolio-tracking bots that read live spreadsheet data and flag anything moving outside a normal range. There are Slack triage bots that read every message overnight and hand you a three-line summary instead of a wall of unread notifications.

On the business side, teams are running full local SEO stacks through Grok Bot: pulling competitor category data, tracking review velocity, auditing service listings, all work that used to take hours of manual digging and now runs in minutes.

The common thread across almost every use case worth copying is the same: one bot, one job, running on a schedule, checking in only when something actually needs a human decision.

That’s exactly the model I used to build my own team.

Build Your Own Bot Team

Here’s the team I set up inside Grok Bot. Seven bots, each with one job, all reporting up to me.

1. Sentinel: Community Manager: Lives inside the community Slack, replies to member questions on my behalf, and sends a weekly summary of what came up plus a monthly summary of recurring themes.

2. Scout: Trend Signal Researcher: Scans the best-performing AI content on LinkedIn and X every morning, flags the top signals, and drafts post ideas before 8 am.

3. Sprinter: Reddit Opportunity Bot: Watches relevant subreddits for posts gaining fast traction, drafts a response, and sends escalating reminders until I approve it or let it go.

4. Ledger: Partner Relations Bot: Tracks every active sponsor relationship, flags renewal windows coming up in the next 30 days, and flags any partner who’s gone quiet for three weeks or more.

5. Herald: Newsletter Ops Bot: Watches the publishing calendar, checks draft status three days out, and pulls open-rate and click data into a report after every send.

6. Vault: Product & Support Bot: Monitors the support inbox and community for product questions, answers from documentation, and flags anything that looks like a bug or a refund request instead of guessing.

7. Chief of Staff: The one that reports to me: This is the bot that actually makes the team work. At the end of each day, it collects a status update from all six bots above and compiles one report, not six separate notifications. If anything gets flagged as urgent during the day, it doesn’t wait for the rollup; it pings me the moment it happens.

That structure is the real lesson here. Seven useful bots without a coordinator just means seven separate notification streams competing for your attention.

Mistakes Beginners Make in Their First Week

A few patterns show up again and again with people who are new to this. Worth knowing before you run into them yourself.

Connecting every plugin on day one. It’s tempting to authenticate your whole toolkit in one sitting. Don’t. Connect only what your first bot actually needs, then add more as you build more bots.

Building one bot to do everything. A bot with five different jobs is harder to trust and harder to fix when something goes wrong. The bots that work best have one job, done well, every time.

Not watching the first scheduled run. It’s easy to set up a routine and walk away, assuming it’ll just work. Watch the first run yourself, start to finish, before you trust it to run unsupervised.

Skipping the “why” behind a routine. If you can’t explain in one sentence why a bot needs the access you’re about to give it, it probably doesn’t need that much access yet.

Treating it like a chatbot. The biggest wasted potential is typing a question, reading the answer, and closing the app. Grok Bot’s real value only shows up once you start assigning it actual, repeatable work.

None of these are dealbreakers. They’re just the same five mistakes almost everyone makes in week one, so you might as well skip straight past them.

Grok Bot vs Hermes vs OpenClaw vs Buzz

If you’ve looked into AI agents before, you’ve probably run into Hermes, OpenClaw, or Buzz.

Here’s how they actually compare.

OpenClaw and Hermes are the veterans of this space. Both are genuinely powerful, and both give you real control over how they run. The tradeoff is setup. You need your own always-on machine, usually a VPS, and you’re on the hook for configuring models, writing your own instructions, and maintaining the infrastructure yourself.

Buzz sits in the middle. It isn’t an agent on its own; it’s a shared workspace you drop agents into, closer to a human-plus-agent room than a standalone tool. You either self-host it or connect to a public relay, and once it’s running, spinning up new agents inside it is fast. The catch is an early setup step around saving a private key, which can genuinely trip up anyone who isn’t already comfortable with this kind of tooling.

Grok Bot skips almost all of that. Download it, sign in, build a bot, done. No server, no maintenance, no infrastructure decisions.

The tradeoff runs the other way, though. With Grok Bot, you don’t choose your underlying model. You don’t own the harness. Your data lives on their cloud computer, not yours. You’re trading control for convenience, and it’s a real trade, not a free upgrade.

If you want real control and don’t mind configuring things yourself, OpenClaw or Hermes give you the most power. If you want a shared workspace between you and your agents, Buzz is worth a look. If you want something that works the moment you sign in and you’re fine with a closed, subscription-locked system, Grok Bot is the easiest path.

What Grok Bot Actually Costs

There’s no standalone Grok Bot subscription. You get access bundled into one of three existing plans:

• SuperGrok Heavy: $300/month, direct from xAI

• Cursor Ultra: $200/month

• Cursor Teams Premium: $120/seat/month, assigned by a team admin

Each plan includes a weekly usage pool. Go past it, and you’re billed on top based on model and token cost.

There’s no free tier and no trial. If you’re already paying for one of these plans, Grok Bot is effectively free on top of what you’re already spending. If you’re not, you’re looking at a real monthly cost just to try it, with no way to test it in isolation first.

The Safety Tradeoff Nobody Talks About Enough

This is the part most guides bury, and it’s the part beginners should read most carefully.

Grok Bot doesn’t work through clean, sandboxed API connections the way a lot of AI tools do. It works by logging into your real accounts and driving them the way a person would, including on sites and tools that don’t have a proper integration at all.

That’s exactly what makes it powerful. It’s also exactly what makes it a trust question, not just a capability question. You’re handing an autonomous system the keys to your inbox, your Slack, your business tools, whatever you connect. If a multi-step job fails partway through, you may have to untangle whatever state it left things in.

Your First 24 Hours With Grok Bot

If you’re starting today, here’s the simplest path through everything above.

1. Set up the app and connect one plugin, just one. Pick the tool you use the most.

2. Build a single bot with a narrow job, something you’d normally do yourself in under ten minutes. A daily summary. A single scheduled check. Nothing complicated yet.

3. Watch it run once, start to finish, before you schedule it to repeat.

Who Should Actually Use Grok Bot Right Now

Here’s the honest answer.

If your AI budget is around $20 a month and you’re still getting comfortable with AI in general, this isn’t your next step yet.

Spend a few months getting properly fluent with a single AI assistant first: how to prompt it well, how to break a task down, how to tell when its output actually needs a second look. That foundation is what makes a bot team useful later, instead of just expensive and confusing.

If you’re already spending real money across multiple AI subscriptions, you’ve built out skill files or context systems before, and you’re comfortable handing an agent real account access, Grok Bot is a legitimate next step.

The value here is real. Whether it’s worth it for you specifically depends entirely on how much you’re already using AI to run your day-to-day.

Before you go - here’s what paid members are getting in this issue

I built and ran the seven-bot team above for a full week. Paid subscribers get the part that took the longest to figure out: the exact job brief I wrote for each of the seven bots - Sentinel, Scout, Sprinter, Ledger, Herald, Vault, and the Chief of Staff - copy-paste ready, plus the approval-queue rules and routine schedules that keep the whole team from flooding you with noise.

Everything above shows you what the team looks like. The gift below shows you exactly how to build it.

Upgrade to unlock the full blueprint. It’s the difference between reading about a bot team and running one by tonight.

Subscribe now

Read more

That’s like buying a factory and using it to sharpen a single pencil.

I’m not exaggerating.

The thing sitting in your browser tab right now runs my engineering, my design, my marketing, my social, my finance, my ops, and my legal review - from one workspace, on call every hour of the day, for the price you’re already paying.

Most people never see it.

They treat Claude like a chatbot instead of a company.

Today I fix that. Permanently.

And I am not going to describe it in theory. I am going to open my actual Marketing operator in front of you, and hand it a real task.

You will watch it produce finished work with my voice, my rules, and my checklist already inside it - work I never re-briefed.

By the end of this issue, you get the exact setup: all seven departments as SKILL.md files, all seven project-instruction briefs, the pull-work prompt pack, and the “how I actually do the work” template

Let me show you how it works.

Go check my work first

Before you read another line, do this.

Open my Substack. Scroll my last twenty issues. Look at the consistency - the voice, the structure, the way every issue lands the same way.

That consistency is not discipline. I do not have that much discipline.

It is a Claude Project doing its job while I sleep.

The part I never talked about

Here is the honest version.

For months I ran my business the way you probably run yours. Eleven tabs open.

One for writing.

One for a design tool.

One for a “SEO assistant.”

One for invoices.

A Notion doc of prompts I kept re-pasting into fresh, amnesiac chats.

Every task meant re-explaining my entire business from scratch to a chatbot that forgot me the second I closed the tab.

The loop was slow. But slow was not the real problem.

The real problem was the forgetting.

Every new task started from zero.

The rules I set on Monday were gone by Tuesday.

The voice I corrected last week never carried into this week.

I was not building anything. I was re-briefing the same intern, forever.

That is the exact broken-memory trap I broke down here, if you want the deeper diagnosis:

So I stopped trying to prompt faster.

I built a system that remembers instead.

Where this actually put me

This is not a thought experiment.

Running Claude as a company OS is how I ship three newsletter issues a week, publish across four platforms, and still close my laptop before dinner - as one person.

The leverage did not come from working faster.

It came from never re-explaining the work.

The system remembers. I just decide.

By the end of this issue, you will not have “an AI subscription.”

You will have an operating layer. You will open one workspace and say “draft the launch page,” “chase the unpaid invoice,” “review this NDA,” “script the reel” - and each request lands with an operator who already knows your standards, your voice, and your rules.

That is the shift from user to operator.

The task is the deliverable. The operator is the asset.

Old way. New way.

The old way: Open a fresh chat, re-explain your business, paste your prompt, get generic output, fix it by hand, repeat tomorrow from zero.

The new way: Open your workspace, say the task in plain English, the right operator loads itself with your voice and rules already inside, get on-standard output, ship.

Most people use AI to make one task faster. That is the small version.

The bigger version is building a thing that runs every future task for you, and gets sharper every time you use it. It is the same principle behind running an entire company as one person:

If this is useful, share it with one person who still re-explains their business to a chatbot every morning. Takes 10 seconds.

Share

Everything above is the what. Below the line is the how.

The full seven-department system. The real Marketing operator, built live. The four moves. The delegation prompts. The failure that taught me the whole thing.

Free readers stop here with a nice idea. Paid readers close this tab with a company OS.

Paid members get the whole thing, done:

• All seven departments as SKILL.md files

• All seven project-instruction briefs

• The pull-work prompt pack

• The “how I actually do the work” template

Read more

Not a hot take. Not a hype thread. A map.

He and his team went and analyzed over 10,000 job postings, ran dozens of structured interviews with hiring managers and recruiters, gathered survey data, and boiled the entire messy field of AI down to four skills.

Four. Not forty. Not the 47-box roadmap you bookmarked and never opened.

I read it twice. Then I sat with it, because when the person who taught most of the internet machine learning tells you which four things matter, you listen.

He is right. Every one of the four holds up.

But here is the gap. Ng wrote it for developers. Most of you reading this are not full-time developers. You are founders, creators, solo operators who use AI to build things without a computer science degree.

So this issue is the translation. Ng’s map, rewritten for the person who builds in plain English.

By the end, you have all four skills in your language, a small example of each.

Let me walk you through it.

THE AI VAULT IS OPEN

Every guide, kit, template, and prompt library I’ve built - in one place. Organized. Searchable. Growing every week. Here’s how access works:

Paid Members: Get one specific guide related to the newsletter from the Vault every issue. Yours for a week.

Founding Members: Full access to everything inside the Vault. Every guide. Every kit. Every drop. Forever.

We’re 1-2 months away from 10K+ subscribers. The moment we hit that number, we’re launching a private free community - exclusively for AI In Public readers.

Before you read another word of mine, go read his.

I am not paraphrasing a stranger. I am building on top of the actual source, and you should see it with your own eyes.

Here it is:

Read it. Come back. Everything below is me standing on his shoulders, not replacing him.

That is the honest version. He did the research. I am doing the translation.

The One Line That Unlocks It

Ng buried the most important idea halfway down, so I am pulling it to the front.

He does not talk about the “AI Engineer” job title. He talks about AI engineering skills. And the difference is everything.

His analogy is perfect. Every developer today knows how to work with the cloud, but only a few carry the “Cloud Engineer” title. The skill is spread everywhere. The title stayed rare.

The same thing is happening with AI right now.

You do not need the title. You do not need to “become an AI engineer.”

You need the four skills, applied to whatever you already do.

That reframe is the whole reason this map matters for a non-technical builder. The door was never locked. You were reading the wrong sign on it.

Old Way Vs New Way.

The old way: Try to learn every tool, feel permanently behind, freeze, never ship, decide you are “not technical enough.”

The new way: Learn four skills, in your own language, build one small real thing with each, let the AI do the typing while you do the deciding.

Most people treat a roadmap as proof they are making progress.

That is the small version.

The bigger version is what Ng is pointing at. Pick the few skills that compound, ignore the noise, and become the person who ships while everyone else is still collecting courses.

The map is not the work. The build is.

If this is useful, forward it to one person who keeps saying they are “not technical enough.” Takes 10 seconds.

Share

Everything above is Ng’s map and my read on it. Below the line is the translation in simple language.

All four skills rewritten for the non-technical builder. A small, real example of each. The trap hiding inside every one. And the prompt that audits your weakest link and hands you a 30-day plan.

Free readers stop here with a good summary. Paid readers close this tab knowing exactly what to build next.

Read more

That’s the 10%. It’s what almost every business owner does with it, every day.

The other 90% is instructions that run before every conversation, containers that hold your business context permanently, memory that carries across sessions, packaged workflows that fire on their own, live connections into the tools you already pay for, and jobs that run while you sleep.

None of it is hidden.

Most business owners spend between two and four hours a day on admin.

Email, approvals, chasing updates, pulling reports, re-entering data that already exists somewhere else.

Two hours a day across a working year is roughly 500 hours.

You already know this. You’ve probably already tried to fix it with AI, got something half-working, and quietly stopped using it around week three.

I did too. Last year I spent about six weeks building automations around a content process that didn’t work when I ran it by hand. Every automation I built made the mess arrive faster.

The Ladder Almost Nobody Climbs

There’s a ladder from that blank chat box to a system that runs without you. Seven rungs.

Level 0 is where 99% of people live.

You type, it answers, you leave. No memory of you, no context about your business, nothing reusable.

Every conversation starts from zero, which means you pay the explanation tax every single time you open it.

Levels 1 through 7 are where Claude stops being a chatbot and becomes infrastructure. You set instructions that run before every conversation.

You give each function its own room. You let it remember you. You package your best prompts so they fire automatically. You plug it into the tools your work already lives in. Then you stop asking and start delegating.

Every rung takes about twenty minutes and pays back over months rather than instantly. That’s the entire reason almost nobody climbs it.

Why most of this dies before rung two

The research on this is unusually blunt, and it’s worth knowing before you start.

Deloitte’s Tech Trends work this year found most organisations automate their existing processes instead of redesigning them.

Only around 11% have moved to genuinely redesigned, agent-first workflows. Everyone else made a broken process run faster.

McKinsey’s agentic AI research found that among pilots that stall, roughly 61% of failures trace to governance and direction rather than model capability. Deloitte’s State of AI work points at skills, not compute.

The Forbes analysis in July was direct about it: the businesses that succeed are the ones automating repetitive, well-documented processes.

Well-documented is doing all the work in that sentence.

Claude is not your bottleneck. It hasn’t been for a while.

The nine bottlenecks and the rung that clears each one

Read this first. Find yours. Then read only what applies.

Bottleneck 1 has no rung, because it happens before Claude opens. Here’s the fix, and it takes twenty minutes.

Pick the task that annoys you most.

Run it manually once, and narrate every decision into Claude as you go.

Not the clean version. The real version, including the part where you check the client’s last invoice before deciding the tone of the email.

Then paste this:

I just described how I actually do this task, including
the messy parts. Write it back to me as a numbered
process document.

For each step, mark it as one of:
- MECHANICAL (same every time, no judgment needed)
- JUDGMENT (I decide based on context)
- RELATIONSHIP (a person needs to feel something)

Then tell me which MECHANICAL steps could run without
me at all, and flag any step where my description was
vague enough that you'd have guessed.

“Flag any step where my description was vague“ is the line that saves you six weeks. The vague steps are exactly the ones your automation gets wrong, and you won’t notice until it’s been wrong for a month.

Automate the mechanical. Assist the judgment. Never automate the relationship.

If this is useful, forward it to one business owner who's already tried and given up. Takes 10 seconds.

Share

Anthropic publishes a full guide on how their models want to be instructed. Most people have never opened it.

→ docs.claude.com/en/docs/build-with-claude/prompt-engineering/overview

I’ve pulled the parts that change business output into Step 4. Skip the rest unless you enjoy that sort of thing.

Old way:
Open chat → re-explain your business → get a generic answer → rewrite most of it → close the tab → repeat tomorrow.

New way:
Claude already knows your business → already has your files → already has your rules → produces something you send instead of something you fix.

Ninety minutes of setup separates those two.

You Now Know The Ladder Exists. Below The Line Is How You Climb It.

All seven steps in full - the Custom Instructions block, the Projects, the skill build, the connectors, the scheduled tasks that run while you sleep. Plus the Automation Audit worksheet and the sorting template.

Free readers stop here with a good idea. Paid readers close this tab with a system that runs without them.

Read more

The emails still went out. The content still shipped. Deals still moved forward.

You probably assumed I had a big team.

For a long time, you were right.

Not anymore.

I mean, this was the old setup: every recurring task lived in my head, and every single one needed me to touch it.

That was not bad, exactly. It worked. But the soul of the whole thing was missing.

And the soul is the system that runs when I am not there.

Now I paste one audit prompt. I walk away. A week later, there is a folder of skills doing the work I used to do by hand, and a visual map showing me every one of them at a glance.

I do not reopen the same client email for the 41st time. I do not manually chase the same follow-ups. I do not hold the whole operation in my head anymore.

Let me show you how it works.

Go Check The Logic First

Before you read another line, do this.

Break one thing you do every week into its actual steps. Just one. Your onboarding. Your content. Your outreach.

Count how many of those steps genuinely need your judgement, and how many you just do because nobody wrote them down.

That gap - the steps you do on autopilot that don’t actually need you - is not a discipline problem.

It is a system problem.

Everything I am about to show you is built to close that exact gap. Nothing here is theory. It runs my business right now.

The Part I Never Talked About

Here is the honest version.

For months, I was the system. Every process lived in my head.

I was good at it. I still am.

But the loop was slow. A task would come in, I’d handle it from memory, and every new instance started from zero. The way I did it last week never carried into this week.

That was the real problem. Not the speed.

The forgetting.

So I stopped trying to do my own tasks faster.

I built a system that remembers how I do them instead.

Old Way Vs New Way

The old way: Task comes in → do it from memory → get interrupted → do it again next week from scratch → never get faster → stay the bottleneck.

The new way: Task comes in → the skill runs it → I review and approve → the system remembers it forever → next time is sharper.

Most people use AI to make one task faster.

That is the small version.

The bigger version is building a thing that runs every future task for you, and gets sharper every time it runs.

The automated task is the deliverable.

The folder of skills is the asset.

If this is useful, share it with one person who is still doing their onboarding emails by hand at 11 pm. Takes 10 seconds.

Share

Everything Above Is The What. Below The Line Is The How.

The full audit. The skill build. The visual map. The deploy. The exact prompts that turn one conversation into a folder of agents that run your work.

Free readers stop here with a nice idea. Paid readers close this tab with a system.

Read more

The animated ones. Dotted grid. Blue glow. The ones that stop your thumb.

Yes, I mean this:

Also yes, like this one:

(GIF format is not supported for email readers; I skipped it)…….

Anyways….. we are going to discuss every word on this special topic

You probably assumed a designer made them.

For a long time, you were right.

Not anymore.

I mean, this was the previous work:

This was not bad, though… but the soul of every infographic was missing.

And now the soul is the motion graphics.

I paste one prompt. I walk away. Ten minutes later, there is a 4K PNG, a looping GIF, and an MP4 sitting in a folder on my desktop.

I do not open Canva. I do not open Figma. I do not write a single line of the design.

And I am publishing this same breakdown on LinkedIn this week, live, with the screenshots. So you can watch the system produce the very post that explains the system.

Let me show you how it works.

Go check my work first

Before you read another line, do this.

Open my LinkedIn. Scroll my last twenty posts.

Look at the dotted grid. The blue glow. The corner radius on every card. The same footer placement on all of them.

That consistency is not discipline.

I do not have that much discipline.

It is a file called Design.md doing its job while I sleep.

Everything I am about to show you is verifiable. The posts are public.

The part I never talked about

Here is the honest version.

For months, a human designer built my infographics.

He was good. He is still good.

But the loop was slow. I sent a topic. He sent a draft. I sent notes. He sent v2. Two days gone. Sometimes three.

And every new piece started from zero. The lesson from last week never carried into this week.

That was the real problem. Not the speed.

The forgetting.

So I stopped trying to make the designer faster.

I built a system that remembers instead.

The numbers, plainly

Look at the last two rows. Those are the ones that matter.

Speed is nice. Memory is the moat.

Old way. New way.

The old way: Topic → brief the designer → wait → review → notes → wait → post → forget everything you learned.

The new way: Topic → one paste → wait 10 minutes → approve → the system remembers it forever.

Most people use AI to make one thing faster.

That is the small version.

The bigger version is building a thing that makes every future thing for you, and gets sharper every time you run it.

The infographic is the deliverable.

The folder is the asset.

If this is useful, share it with one person who still designs their own graphics. Takes 10 seconds.

Share

Read more

Two lines written. Then you went to answer emails nobody needed answered.

“I’ll write it after lunch.”

“I need to research this first.”

“Not in the right headspace today.”

You are not lazy. Your brain is doing what it evolved to do: avoid discomfort, save energy, fight tomorrow.

I have built AI systems for three years and taught 150,000 people to use them. I still lose that 9 AM argument. So this is not about discipline. It is about tricking your brain into hard things, with AI on your side of the table.

By the end, you will get all seven prompts, copy-paste ready, plus a “Which Prompt Right Now” router and a tracker. It is at the bottom.

Your brain resists hard tasks for two reasons.

The task feels emotionally expensive, and the task threatens your self-image. AI does not remove the work. It shrinks the distance between you and the first move.

Seven prompts below, each aimed at one form of resistance. Every one ends with you doing something offline inside five minutes. If you use only one, use the first.

By the end of this, you stop trying to win the whole day. You win the first ninety seconds instead. Every morning, the same small move, too small to argue with. The draft that scared you becomes the draft you already started. Not because you found more discipline. Because you stopped needing it.

THE ROOM OPENS AT 500 PAID MEMBERS

At 500 paid subscribers, the private Discord opens. Not a dead channel - a working room where you drop the task you’re avoiding or the problem you're facing and get the solution that unsticks it from people doing the same work or a solution to the problem.

We’re at 64 paid subscribers right now. Every upgrade is one seat closer.

Two Reasons Your Brain Fights You

Resistance shows up in two forms. Dr. Dominic Ng’s framing is the cleanest I’ve read.

Resistance 1: Emotional Pushback

Your brain doesn’t judge a task logically. It judges how the task feels - and the bigger the task looks, the bigger the feeling.

• “Write the whole newsletter” → dread. “Write one ugly sentence” → fine.

• “Learn AI properly” → overwhelming. “Try one prompt” → easy.

• “Build the whole system” → paralysis. “Name the first file” → nothing at all.

Same work. Completely different emotional price tag.

Resistance 2: Ego Protection

The second kind comes from the story you tell yourself about who you are. Your brain protects that story before it protects your goals.

• Believe you’re not technical, and the terminal feels hostile before you open it.

• Believe you’re a perfectionist, and starting becomes the scariest part of the day.

• Believe you’re behind on AI, and you avoid the exact thing that would catch you up.

The resistance was never about the task. It was about protecting the story.

For most of history, your only weapon against both was willpower - white-knuckling it and hoping there was enough in the tank. Now you have a machine that will sit with you at 6 AM and cut the mountain into a step you can take.

Which prompt to use when

Save this table.

Strategy 1: Make AI shrink the task before you touch it

Dread → ninety seconds

Your brain resists the size of the thing. So stop negotiating with it. Hand it over first.

Purpose: turn one intimidating task into a first move so small that refusing it would feel ridiculous.

You are my task-shrinking assistant. Do not motivate me.
Task I am avoiding: [describe it in one messy sentence]
Deadline: [date] | Time I actually have today: [minutes]
Break it into 8 steps, ordered smallest to largest.
Step 1 must take under 2 minutes and require zero thinking.
Return only the numbered list. No intro, no encouragement, no summary.

The “do not motivate me” line matters more than you’d expect - pep talks wake the exact ego resistance you’re sneaking past. What comes back sounds almost stupid: open the doc, write the ugly title, pull three links. You’re not committing to the mountain. You’re committing to ninety seconds, and your brain won’t fight ninety seconds.

Strategy 2: Let AI do the setup so you only have to start

Blank page → tabs already open

Some days two minutes is still too much. That’s not a character flaw. That’s a Tuesday. So don’t start the task. Start the preparation.

Purpose: use physical movement to get past emotional resistance without touching the real work yet.

Act as my setup assistant. I am not ready to start the task yet.
Task: [X] | Where I am working: [laptop, desk, gym, kitchen]
List only preparation steps. Never the task itself.
Include files to open, tabs to close, notes to pull, and one thing to physically move.
Maximum 6 items, each one doable in under 60 seconds.
End with the exact first sentence I should type, or the first rep I should do.

That last line has research behind it. In 1999, psychologist Peter Gollwitzer showed that attaching a plan to a specific cue - an if-then - raises your odds of following through. The prompt writes that if-then for you. By the time the tabs are open, you have momentum you never had to manufacture. I do this before every long article now.

I do this before every long article now - it's one piece of the larger system I use to run the whole newsletter solo, which I broke down here:

Strategy 3: Build a Reward Loop

Rewards you steal → rewards you earn

Your brain chases rewards and avoids effort. So put the effort between two things it wants: small reward, hard task, bigger reward. Most people fail because they hand themselves the second reward anyway. Nobody’s checking.

Purpose: make AI the one who checks, so the second reward stays conditional.

Act as my accountability coach for the next 4 hours.
Task: [X] | Small reward before: [Y] | Bigger reward after: [Z]
Ask me for proof of progress every 45 minutes, not a status update.
Proof means pasted output, a word count, or a photo description. Nothing else counts.
If I have not shipped anything, say so plainly and do not accept the excuse.
Keep every check-in under 3 lines and never release [Z] early.

An AI coach beats a human one at 6 AM: it’s awake, it never gets bored of you, and it has no social reason to let you off the hook. Permit it to be blunt, and it will be.

Read more

They wire up Graphiti, point it at Opus, feed in a few thousand conversations, and watch the bill outrun their actual model calls. Then they blame graphs. “Too expensive.” It was never the graph. It was the config.

I rebuilt my memory layer on Opus 5 last week - same 5,000 episodes, same Neo4j container. The bill went from ~$35 down to ~$10, and the backfill ran overnight while I slept.

Gift at the bottom: the full CLAUDE.md routing block plus the copy-paste extraction script, Notion-ready for paid members. Filled in. No placeholders.

I’ve now got a temporal graph that survives every compaction, every restart, every new session - and the extraction feeding it bills at cache-read rates instead of frontier rates. My agent remembers who said what, when, and how it connects, and the memory layer is no longer my top cost line. It’s near the bottom.

That flip took one config change. Not a new tool. Not a rewrite. One block.

By the end of this issue, you’ll be the person who runs a temporal knowledge graph that costs less to feed than embeddings cost to store - while everyone around you is still running extraction at max effort and wondering why their “cheap” memory layer outspends their model.

Read more

That’s how most people use Claude - and why they think it’s “just a better ChatGPT.”

It isn’t. There’s a whole layer under the chat box: memory, agents, scheduled tasks, a desktop that reads your files, a browser extension that clicks for you. Almost nobody turns any of it on.

I turned every prompt in this issue into a single Claude Power-User Vault - a Notion-paste-ready doc with all 17 features, the exact setup steps, and every prompt in one place. It’s waiting for you at the end.

Two weeks ago, a reader told me: “I’ve used Claude every day for a year. I had no idea Projects existed.”

A daily user. A full year. Never touched the one feature that ends the re-explaining.

So I listed every Claude feature I could name, then checked which I’d actually set up. The list was embarrassing - I was the reader I was writing for.

This issue is the fix, for both of us.

Read more

You didn’t. You picked the wrong layer.

I know because I did it first. Upgraded the model. Same failure. Now more expensive.

Last week a founder ripped out Claude, swapped in a “smarter” model, and got the same broken agent back. The failure was never in the model. It was in the machinery around it - three layers everyone keeps blending into one buzzword soup.

Agent harness. Loop engineering. Graph engineering.

I spent the week pulling apart a research agent that kept lying about being finished. By the end of this issue, you will get the exact diagnostic I now use to fix any agent in under a minute - plus a free Agent Failure Diagnostic Cheatsheet.

By the end of this, you’ll stop paying for a smarter model to fix a problem the model was never causing. You’ll look at a broken agent - one that lies about being done, burns tokens in circles, or falls apart across sessions - and know in thirty seconds which of three things to fix. Not guess. Know.

That’s the difference between someone who uses AI and someone who engineers it.

Read more

He invented a new word to describe what he was declaring war on. And he shipped a tool that puts a lie detector in the hands of every reader you have.

The word he invented was Claudefishing.

And by the time you finish this issue, you’ll understand exactly what it is, who built the machine behind it, how that machine works, whether it can actually hurt you - and how to make sure your real, human writing never gets caught in the net.

Let’s take it in order. No panic. Just the accurate version.

By the end of this issue, you’ll know:

• What the Substack CEO actually said in his announcement post

• What Claudefishing means, in plain English

• Who Pangram is and why Substack picked them

• How the detection technology actually works under the hood

• Whether Substack is going to take action against your AI text

• How to keep genuinely human writing from getting flagged as AI

And at the end, a gift: The Human Signal Checklist - the pre-publish pass that keeps real human writing from reading like a machine. Notion-ready. Waiting for you after the walkthrough.

Read more

You’ve blamed the model. You’ve added “do not hallucinate” in capital letters like that was ever going to work.

It’s not the model. It’s not your prompt. You gave one agent four jobs and a context budget for one.

This issue is the fix.

By the end of this issue, you will get The Graph Engineering Blueprint. The thing I wish someone had handed me three weeks ago.

After reading this issue, you stop prompting agents and start designing systems. The first one is replaceable. The second one gets hired.

Read more

Which one do I use for this?

Five threads this week named five different winners, and they’re all correct - each one read a different leaderboard.

So you default to the most expensive option, because expensive feels safe.

It isn’t.

Here’s the honest comparison which helps you to fix this.

By the end of this issue, you will get The Complete Three-Model Guide plus The One-Page Cheatsheet - a single printable sheet you can pin above your desk and stop guessing.

THE AI VAULT IS OPEN

Every guide, kit, template, and prompt library I’ve built - in one place. Organized. Searchable. Growing every week. Here’s how access works:

Paid Members: Get one specific guide related to the newsletter from the Vault every issue. Yours for a week.

Founding Members: Full access to everything inside the Vault. Every guide. Every kit. Every drop. Forever.

We’re 2-3 months away from 10K+ subscribers. The moment we hit that number, we’re launching a private free community - exclusively for AI In Public readers.

Read more

Something appeared - a gradient, a hero, three feature cards, a fake testimonial.

Exactly like every other AI site.

Here is what I built while writing this issue: a full 3D website for a pair of wireless ear pods - a real WebGL scene where the pods rotate as you scroll and drag with your mouse, plus video, specs, and cart. Step-by-step guide below ↓

Read more

Open the AI tool you use most.

Now look through your history.

Your business ideas are there.

Your customer research.

Your unfinished products.

Your writing style.

Your code.

Your negotiations.

Your mistakes.

Your best prompts.

Your most valuable decisions.

Months of thinking are sitting inside that account.

It feels like an asset.

But it isn’t an asset.

It is access.

An asset can be exported, inspected, backed up, moved, modified, and operated under your rules.

Access can be limited.

Repriced.

Redesigned.

Suspended.

Or removed completely.

That is the uncomfortable reality behind the AI boom:

We are putting more of our intelligence inside systems we do not own.

And almost nobody is preparing for what happens when those systems change.

The Warning Was Bigger Than the Soundbite

On July 1, 2026, Palantir CEO Alex Karp appeared on CNBC and said that “something has gone completely wrong” with how artificial intelligence is being sold.

His argument was aggressive.

Businesses are spending heavily on tokens while surrendering control over the infrastructure that increasingly runs their operations.

They are buying access to intelligence instead of building durable intelligence of their own.

Karp is not a neutral observer. Palantir is actively selling sovereign AI infrastructure, including systems designed to deploy NVIDIA open models inside controlled environments.

But commercial interest does not automatically make the underlying question irrelevant.

The question is brutally simple:

Who owns the intelligence layer your business is being built on?

Not who owns the documents.

Not who legally owns the generated output.

Who owns the system that remembers, reasons, prices, restricts, and decides how that intelligence can be accessed?

For most individuals and companies, the answer is still:

Someone else.

Let’s Correct the Most Convenient Exaggeration

This conversation becomes useless when people reduce it to:

“AI companies are secretly training on every document you upload.”

That is not an accurate description of every product or plan.

OpenAI says that content from individual services, such as ChatGPT, may be used to improve its models, but users can turn this off. It also says business products and API data are not used for training by default.

Anthropic says consumer chats and Claude Code sessions may be used when users enable model improvement, explicitly opt in, or when conversations are selected for safety review. Its commercial products are not used for model training by default.

These distinctions matter.

A personal AI subscription is not governed identically to an enterprise workspace or API agreement.

But training protection does not equal ownership.

Even when your content is not used to train a foundation model, you are still depending on infrastructure that you cannot fully control.

The provider controls:

• Which models remain available

• How much does access cost

• How memory functions

• Which actions are permitted

• How usage limits are calculated

• Which integrations survive

• What happens when policies change

• Whether your workflow performs the same way tomorrow

Your data may remain yours.

But the environment that makes your data intelligent still belongs to the provider.

That is the deeper dependency.

The Most Valuable Thing You Are Giving Away Is Continuity

The danger is not limited to one sensitive PDF.

It is the gradual transfer of your working memory into a rented interface.

Every day, you teach your AI assistant:

How you communicate.

What does quality mean to you?

Which customers do you serve?

Which objections keep appearing?

How your product works.

What your team gets wrong.

What have you already tried?

Which ideas did you reject?

Which decisions produced results?

Over time, this accumulated context becomes more valuable than any individual prompt.

But where does that intelligence live?

For most users, it is scattered across chat histories, temporary projects, hidden memories, custom instructions, uploaded files, and conversations tied to one provider.

There is no clean operating system.

There is no portable memory layer.

There is no reliable model-independent backup.

There is just a growing emotional belief that the AI “knows you.”

Then a model is retired.

A feature changes.

A usage limit appears.

A project loses context.

A safety policy blocks a workflow that worked yesterday.

Or the provider replaces the model underneath your existing conversation.

OpenAI’s own release notes show how frequently models can be introduced, replaced, and retired. That is normal for a fast-moving service, but dangerous for anyone who has built a critical workflow around a specific model’s behavior.

You did not lose your data.

You lost the environment that made the data useful.

That is what renting intelligence looks like.

Your AI Account Is Not Your AI System

An account is a destination.

A system survives destinations.

Your real AI system should include:

• Your knowledge.

• Your operating instructions.

• Your examples.

• Your decision history.

• Your workflows.

• Your evaluations.

• Your tools.

• Your permissions.

• Your model preferences.

• Your fallback options.

And every one of those components should remain usable when the primary provider disappears.

Today, most people have built the exact opposite.

Their documents are stored in one place.

Their prompts are trapped in another.

Their automation depends on one API.

Their memory depends on one product.

Their workflow only succeeds with one model.

Their team has no idea how the system actually works.

This feels efficient right up until the day something changes.

Then they discover they did not build an AI system.

They built a collection of dependencies.

The Claude Code Controversy Revealed the Real Trust Problem

At the end of June 2026, developers examining Claude Code reported a hidden mechanism that could encode signals about proxy domains and certain user-environment characteristics into subtle variations inside the system prompt.

An independent technical analysis found that the mechanism operated when Claude Code was routed through non-Anthropic endpoints and could encode information using almost invisible character differences.

The word “spyware” became viral.

Anthropic rejected that framing and described the mechanism as a temporary anti-abuse experiment intended to detect unauthorized reselling and model-distillation activity. Reporting indicated that it was subsequently removed.

The distinction is important.

There is no credible reason to claim that Claude Code was indiscriminately spying on every user.

But the controversy still exposed something larger:

Users normally cannot see everything their AI client is doing.

You can inspect the interface.

You can read the privacy page.

You can review the settings.

But trust ultimately depends on the provider behaving exactly as expected inside infrastructure most users cannot independently audit.

That does not make every provider malicious.

It makes blind dependence reckless.

Trust is not ownership.

A policy is not architecture.

And a promise is not a fallback plan.

Owning AI Does Not Mean Abandoning ChatGPT or Claude

This is where most ownership arguments become unrealistic.

They tell everyone to cancel their subscriptions, buy expensive hardware, download a giant model, and become an infrastructure engineer.

That is not a strategy for most people.

Frontier cloud models are extraordinarily useful.

Use them.

Use the best reasoning model for strategy.

Use the best coding model for development.

Use the best image model for creative work.

Use fast, inexpensive models for repetitive operations.

But treat models as replaceable engines.

Never let one engine become the only place where your company remembers how to drive.

The goal is not to eliminate external providers.

The goal is to stop making any single provider irreplaceable.

The Five Layers You Actually Need to Own

You do not need to train a frontier model.

You need to own the context that makes frontier models valuable to you.

1. Own Your Data

Keep original documents, research, customer information, transcripts, and operating knowledge inside storage you control.

Uploading a file to an AI tool should create a temporary working copy.

It should never become the only usable copy.

2. Own Your Memory

Your company’s memory should not exist exclusively inside chat history.

Store important facts, decisions, examples, preferences, and lessons in a structured knowledge base that can be connected to multiple models.

When you change providers, your memory should come with you.

3. Own Your Workflows

Save your best system prompts, content frameworks, automation instructions, evaluation criteria, and agent configurations as files or code.

A workflow buried inside a six-month-old conversation is not an operational asset.

It is a future archaeology project.

4. Own Your Model Router

Different tasks deserve different models.

Your system should be able to send private work to a controlled model, complex reasoning to a frontier model, and repetitive work to a cheaper model.

Model loyalty is not a strategy.

Model optionality is.

5. Own a Fallback

Your fallback does not have to outperform every closed model.

It needs to keep essential work moving.

A local or privately deployed open-weight model can handle document search, classification, summarization, drafting, structured extraction, and other repeatable tasks without making your entire operation dependent on a public interface.

Palantir and NVIDIA are already promoting this architecture at the enterprise and government level: open models deployed inside controlled environments where the organization retains greater authority over the system.

Individuals and small teams need a lighter version of the same principle.

Take the AI Ownership Test

Answer these five questions honestly:

1. Can you export the knowledge your AI has accumulated about your work?

Not merely download old conversations.

Can you convert that history into structured, reusable memory?

2. Could you change model providers this week without rebuilding everything?

When switching models destroys the workflow, you do not own the workflow.

3. Are your most valuable prompts stored outside the chat interface?

Anything critical should be versioned, documented, and accessible to your team.

4. Do you know which privacy settings and commercial terms govern your account?

“ChatGPT,” “Claude,” or any other AI product may apply different rules depending on whether you use a consumer plan, business workspace, enterprise agreement, or API.

5. Could your business continue operating during a seven-day provider outage?

When the answer is no, you have discovered a concentration risk.

Score one point for every “yes.”

Five points: You are building an AI asset.

Three or four: You have leverage, but important dependencies remain.

Zero to two: You are renting an increasingly important part of your business.

The Next AI Divide Will Not Be Humans Versus Machines

It will be owners versus dependents.

Two people may use the same model.

One uses it through an isolated chat window.

The other connects it to owned data, portable memory, documented workflows, evaluations, tools, and multiple fallback models.

The first person becomes faster.

The second person compounds.

That difference will grow every month.

The winning companies will not necessarily possess the smartest model.

They will possess the best private context around whichever model is currently smartest.

The winning creators will not have the longest prompt history.

They will have an intelligence system that remembers what worked and can carry those lessons across every new model.

The winning individuals will not refuse cloud AI.

They will use it without becoming trapped by it.

Your AI Provider Should Be a Supplier, Not Your Landlord

Keep using the Frontier Labs.

Let them compete for your workloads.

Let them improve their models.

Let them lower their prices.

Let them release better tools.

But do not let them become the only place where your organization thinks.

Use their models.

Keep your memory.

Use their computer.

Keep your workflows.

Use their interfaces.

Keep your data portable.

Use their intelligence.

But own the system around it.

Because the moment your AI becomes central to how you create, decide, sell, research, and operate, ownership stops being a technical preference.

It becomes self-preservation.

The future does not belong to the person with the most AI subscriptions.

It belongs to the person who can walk away from any one of them without losing everything they have learned.

Here are a few issues that you might have missed (go check them out):

• How to Build Claude Skills

• How to build an app with Claude Artifacts

• Claude for Chrome

• 20 Resources to master Claude in 7 Days

• Vibe Coding: The Complete Claude’s Beginner Guide 2026

• 15 Claude Prompts that save me 30 hours a week

• 25 Ways to Use Claude (90% of People Know Only 3)

• How to Set Up Hermes Agent (Step-by-Step Guide)

We tested it in public. Now use it in private.

I write about the systems, workflows, and ownership layers people will need to remain valuable in the AI era.

Follow @humzaakhalid and subscribe to AI in Public for the next breakdown.

_ Hamza 💙

Not a hack. Not a jailbreak.

OpenAI’s own Codex lead is publicly sharing the recipe.

Most people saw this trending, saved the post, and moved on.

I actually set it up. Both ways. And one of the viral versions floating around has a broken command that silently fails.

By the end of this issue, you’ll get my Sol × Claude Code Command Kit -every working command, the fixed alias, and the cost-saver settings in one copy-paste block.

THE AI VAULT IS OPEN

Every guide, kit, template, and prompt library I’ve built - in one place. Organized. Searchable. Growing every week. Here’s how access works:

Paid Members: Get one specific guide related to the newsletter from the Vault every issue. Yours for a week.

Founding Members: Full access to everything inside the Vault. Every guide. Every kit. Every drop. Forever.

We’re 2-3 months away from 10K+ subscribers. The moment we hit that number, we’re launching a private free community - exclusively for AI In Public readers.

Last night I saw the setup trending on X and didn’t believe it.

So I opened my terminal and ran both methods back-to-back.

Fifteen minutes later, GPT-5.6 Sol was reviewing code that Claude wrote. Inside Claude Code. On one screen.

That’s when it clicked: this isn’t a party trick. It’s a workflow.

Old way vs New way

The old way:

Two terminals. Two tabs. Copy code from Claude, paste into Codex, and copy the critique back.

Ask → Copy → Paste → Lose context → Repeat.

The new way:

Claude writes → Sol critiques → You ship.

One terminal. Zero copy-paste. Two models with different blind spots are checking each other’s work.

I have created a complete cheat sheet guide for this setup

Save this and USE it later:

The Setup

Everything below happens in your normal Mac Terminal. Nothing runs inside Claude Code until Step 5.

Step 1: Check your setup

Two things must be true before you start.

1. Claude Code is installed:

claude --version

If that fails, install it:

npm install -g @anthropic-ai/claude-code

2. Your ChatGPT plan has GPT-5.6 Sol access.

OpenAI currently lists Sol access in Codex for Plus and higher plans. Free accounts won’t work for this.

Step 2: Install the proxy

Paste this into your normal Mac Terminal:

brew install raine/claude-code-proxy/claude-code-proxy

Wait until it finishes. Then confirm the installation:

claude-code-proxy --version

You should see a version number printed on the back. That’s your green light.

This is the current Homebrew command published by the proxy repository. No Homebrew? The repo also ships a one-line install script - it’s in the Command Kit at the end.

Step 3: Connect your ChatGPT account

Run:

claude-code-proxy codex auth login

A browser window opens. Then:

1. Sign in with the ChatGPT account that has GPT-5.6 Sol access

2. Approve the authorization

3. Return to Terminal

One thing that matters here: this route uses ChatGPT Plus or Pro sign-in, not an OpenAI API account, no API key. No credits. Your existing subscription.

Confirm that authentication worked:

claude-code-proxy codex auth status

A successful result displays your account and token expiry status.

Step 4: Start the proxy

claude-code-proxy serve

This is Terminal 1. Keep it open.

It runs a live monitor showing every request that passes through, which is also how you’ll know everything downstream is working.

Read more

I know because I did the same thing for two days straight. Quick questions. One prompt at a time. Waiting for answers as it owed me small talk.

That’s paying architect rates for someone to hold your ladder.

Tonight at 11:59 PM PT, Fable 5 leaves your subscription and moves to pay-per-token credits. $10 per million input tokens. $50 per million output. Double what Opus 4.8 costs.

From tomorrow, every wasted session is a line on your bill.

Read more

After that, the smartest AI model you’ve ever used stops being included in your Claude subscription.

It becomes a meter.

And the meter runs at $10 per million input tokens and $50 per million output tokens.

That’s the highest price Anthropic has ever put on a model you can actually access.

Double Opus 4.8. Five times Sonnet 5.

Read more

On July 12, Claude Fable 5 leaves all the paid plans.

After that, every message to it costs extra credits.

And that stings.

You finally found an AI that catches your mistakes and doesn’t make things up.

Read more