
Sign up to save your podcasts
Or


I skipped last week’s issue because I was in Austin for the Business Author Summit, so this one’s a double. It’s also the longer explainer I keep saying I’ll write, the plain-English one on getting found when people ask an AI instead of searching.
If you run a small business, you’ve probably heard SEO, AEO and GEO tossed around like they’re three separate emergencies. They’re closely related, and one taco stand can explain all of them.
Imagine you run a taco stand.
* SEO is making sure your sign is big enough to be seen from the highway.
* AEO is making sure that when someone yells “Where are the tacos?!”, you’re the first one to yell “Right here, $3 each!”
* GEO is making sure that when the local food critic (the AI) writes a summary of the town’s food scene, they say, “While there are many options, the consensus is that the al pastor at [Your Name] is the only one worth eating.”
That’s the short version. I’ll use the same stand the whole way through. For each layer you’ll get what it is, the simple fix, and what to tell your own AI so it does most of the legwork.
A quick note on the names. They overlap, and different people use them in different ways. Google’s own guidance on its AI features says the SEO basics still apply, and that there’s nothing extra you have to add to show up in AI Overviews or AI Mode. So I treat AEO and GEO as a way of deciding what to check, more than as three separate jobs.
SEO is the billboard
Think of the billboard by the road. It works if it’s in a good spot, people can read it, and enough of them drive by. It doesn’t tell anybody much. It points at you, and they have to come find you.
Search results work the same way. Someone types “tacos near me” or “taco stand” plus your city, Google shows a list of links, and you want to be on that list and look like the right pick.
For a long time, that was most of the job, and some of the old shortcuts got pretty sloppy. Stuffing the same words over and over, or trading links just to rank, are things Google now treats as spam. The useful version’s still pretty simple. Make the business easy to find, and make it obvious what you actually offer.
The simple fix
* Fix your Google Business Profile. Hours, address and phone should be right, and the menu link should work. Google specifically lists keeping Business Profile information up to date as part of the basics.
* Put your menu on your website as text, not only a photo or a PDF. Google says important content should be available in text form.
* Make sure search engines are allowed in. If your site has a robots.txt file that blocks crawlers, or your page isn’t indexed, nothing else matters. A quick check is to search your exact business name and see if your site comes up.
* Give each thing its own page. Menu, location and hours, catering. Link between them.
That’s most of it, and it’s pretty boring, which is fine.
What to tell your AI
Copy this: Here’s my website: [your URL]. I run a [type of business] in [your city]. Act as a local search consultant and look at the site for basic problems. Check whether my menu, hours and address are written as text a search engine can read, whether each of my main offerings has its own page, and whether anything looks like it’s blocking search engines. Give me the five most important fixes in plain English, easiest first. Don’t rewrite anything yet.
If your AI can’t open web pages, paste the text of your homepage in under the prompt instead.
AEO is the megaphone
Now picture someone in the crowd shouting a question, and you’re the one who shouts the answer back, quickly and clearly. A billboard doesn’t help anyone who just asked a question out loud.
That’s the idea behind AEO, or answer engine optimization. The older, clearest example is the featured snippet, the box Google sometimes puts at the top of the results with a short answer taken from one page.
The simplest example I know is an egg.
* The SEO way: “Here are 10 links about how to boil an egg.”
* The AEO way: “Boil it for 6 minutes for soft, 12 for hard. Next!”
Someone asking that question wants the answer in the first line, and then, if they’re curious, the details about soft versus hard. Search engines and AI tools both tend to pull from pages that are built that way.
People now use AEO more loosely for any situation where the answer is shown directly, including voice assistants and some AI summaries. I wouldn’t get too hung up on the label.
For the taco stand, think about what people ask you at the window. Are you open late? Do you have vegetarian options? Do you take cards? Can you cater a party? Those same questions are what people type into a search box or ask an assistant. If your website answers them in plain sentences, you can be the one quoted. If the answers only live in your head, you can’t.
The simple fix
* Write down the ten or fifteen questions customers actually ask you.
* Put them on your site, one question per heading, with the answer in the first sentence. “Yes, we have vegetarian tacos. They’re...” and then the details.
* Only answer what you can really answer. A heading that asks a question the section doesn’t answer doesn’t help anyone.
* Keep the answers short enough that someone could read one out loud.
What to tell your AI
Copy this: I run a [type of business] in [your city]. List 15 questions a customer might ask before choosing a place like mine. For each question, write a direct answer in one or two sentences, with the answer first. Use only the facts I paste below. If you need a fact I haven’t given you, write [NEED FROM OWNER] instead of guessing. Here are my facts: [paste your hours, menu prices, payment types, catering info, anything else true about the business].
That last instruction matters. An AI will happily make up your opening hours if you let it, so tell it not to.
GEO is the cool kid at the party
The last one’s the hardest to picture, so think of a party where somebody asks the room, “Anybody know a good taco place around here?” Nobody’s shouting, and nobody’s pointing at a sign. A few people just say your name because they know you and it came to mind.
If SEO is a billboard, and AEO is a megaphone, GEO is like being the cool kid at the party that everyone quotes. The name comes from a 2023 research paper by people at Princeton, Georgia Tech, and the Allen Institute for AI, and IIT Delhi. In practice, it’s the work of getting mentioned when an AI writes an answer.
These tools don’t read the entire internet and write you a custom essay. When someone asks ChatGPT, Perplexity or Gemini a question that needs current information, the assistant often searches the live web first, reads a handful of pages, and writes a short answer with a few names and links in it. You want to be one of those names.
For the taco stand, say someone asks, “Where should I get tacos for lunch near the convention center?” The AI looks at your site, your reviews, local articles and listings. If those places agree on who you are and what you’re known for, it’s easier to say your name. If your hours are different on three sites and the menu is a blurry photo, there isn’t much for it to work with.
I write about the naming side of this in September in AI Will Cite You Without Ever Naming You. The short version is that an AI can use your page and still never say your name, so it helps to put your name in the sentences that matter.
The simple fix
* Use the same business name, address, hours and one-sentence description everywhere. Your website, Google, Yelp, Facebook, any local directory.
* Say what you’re known for, in specific words. “[Stand name] serves [the thing you’re known for] at [where you are]” is a better sentence for an AI to repeat than “come see us for great food.”
* Check your robots.txt. Ope…
At least once a week, usually on Saturdays, my siblings and their families come over for dinner with my parents and my wife and kids - 9 adults and 8 kids (2 of them teenagers). It’s chaos; also amazing and fun. They get here around 6pm, and we usually don’t break until close to midnight. It’s been going on for over a decade, and for a very long time, I’d mostly miss out.
I’d catch the meal, sometimes, and then I’d be back at it: 2 hours out of 6, if I was lucky. It wasn’t just my weekends, either. On weeknights, I was there for the kids at bedtime, some of the time, and the trips to the park or the arcade kept slipping.
Like many others, I’ve got a lot of things on my plate. For me, it’s a full-time job, a business with a partner, a software product being piloted at a public university, and a book I’m writing about humans and compounding capability. All of it was eating my nights and weekends.
I broke away from that slog over nine months, and I did it by digging into AI and leveraging the hell out of it. Not in a “this saves me a few hours each week” kind of way, but in a “this reimagines my entire life” kind of way.
This is what led to my Simple Dispatch Fleet - an agentic AI fleet managed with simple messages sent between agents to coordinate and share the load.
Now, we’ve all got different circumstances, but the problems are usually ones most of us share. What’s less obvious is that the solutions are shared too, and fairly simple - just not easy. AI is one of them, but most people give up after a few attempts with bad results, never figuring it out or putting in the time and effort to really pick it up as a skill.
McKinsey’s State of AI survey this year found that 80% of respondents said AI made them more productive, while 37% said it’d shown up in their company’s operating profit at all. The report’s explanation for the small group doing better is worth quoting in full: high performers “fundamentally redesign workflows rather than layer AI onto existing ones; and they embrace practices that sustain deployment, such as senior-leadership role modeling, human-in-the-loop design, impact measurement, and risk management.”
That’s what my nine months turned out to be, and this is the system I ended up with, along with the smallest version of it that you could start this week.
I said the solutions are simple, just not easy. This is the not-easy part, and it’s technical. If you onl y came for the story, this is where to stop. If you want to build your own, read every line, because I’ve left in everything I’d want to see if I were starting over.
Is it “legal” to let an AI agent post from your own account?
It’s my account, my words and my computer, and nothing gets typed until I’ve approved the post. “It’s my account” is a feeling, though, so I had the law researched properly before I wrote this. This is my reading of that research. It isn’t legal advice, and if you’re going to copy this setup, talk to a lawyer where you live first.
* It isn’t a computer crime. In Van Buren v. United States (2021), the Supreme Court read the federal computer-fraud laws as “a gates-up-or-down inquiry.” Logged into my own account and posting my own words, the gate’s up.
* It isn’t a bot under California’s disclosure law, which defines a bot as an account where “all or substantially all of the actions or posts of that account are not the result of a person.” I approve every post. Even if it were one, the law only applies when a bot hides what it is to sell something or sway a vote.
* The real exposure is contract, and the platform enforces it with your account. LinkedIn’s help page says members who use automation software “risk having their accounts restricted or shut down.” Substack’s acceptable-use policy reads as aimed at spam and at “any processes that run or are activated while you are not logged into Substack,” and my tools only act inside my own logged-in session, one approved post at a time. That’s my reading of their words, and it’s worth a lawyer’s look.
* hiQ won the computer-crime argument against LinkedIn over public data, and then, according to the case reports, lost on its contract in 2022, for scraping and for creating fake accounts, and ended with a $500,000 consent judgment. Every case I found that went badly involved fake accounts or other people’s data.
So the question left over is a contract question: who decides how my posts get typed. I decide that for myself, and you, dear reader, decide that for yourself, never the platform. They can ban your account, but they cannot silence your voice. The protections below are how you make sure of that:
* Own the distribution the account rents you. Export your subscriber list and keep a local archive of every post, so losing an account costs you one channel and your audience stays with you.
* Approve every post, and keep the record that shows you did. Mine’s a line in a ledger with a time and a name on it.
* Never collect anyone else’s data. Every bad outcome above started there.
* Use a platform’s own scheduler wherever it works. My Substack Notes go through Substack’s native scheduler. My LinkedIn posts also go through LinkedIn’s native scheduler.
* Stay at human pace and a human volume.
* Try anything new on an account you can afford to lose.
Should you build a fleet like this?
Most of the time, you shouldn’t, and the best-documented case against it comes from the company whose model runs my agents. Anthropic’s engineering team wrote in 2025 that “agents typically use about 4× more tokens than chat interactions, and multi-agent systems use about 15× more tokens than chats.” That 15× is their own figure, published without a method, so I’d treat it as a vendor describing its own product.
Cognition’s Walden Yan named the deeper problem in a post titled “Don’t Build Multi-Agents”: “Actions carry implicit decisions, and conflicting decisions carry bad results.” Cemri and colleagues went through more than 1,600 annotated traces across seven multi-agent frameworks and found 14 distinct failure modes. And in April 2026, Dat Tran and Douwe Kiela found that with the reasoning budget held constant, single agents “consistently match or outperform” multi-agent systems on multi-hop reasoning, although that study hasn’t been replicated yet.
The reconciliation I’d defend came from LangChain’s Harrison Chase: “Read actions are inherently more parallelizable than write actions.” That’s the shape my fleet runs. Agents fan out to research and check, exactly one agent writes any given thing, and the agent whose job is to find problems isn’t allowed to fix them.
My own setup has limits I’d rather you hear from me: it’s one Mac with no failover, the wake-up hop only works with Claude Code today, and when the plan’s allowance runs out, work waits. Or at least, that’s what was true before. Now, I actually have failover to Codex, and failover when that usage runs out to my own Hermes setup, running Qwen 3.6.
If you’ve got one recurring job and one agent doing it, you don’t need any of this. Start with that one agent and the four lines at the end, and add a second agent only when you can name the thing the first one can’t do.
What do my AI agents actually do all night?
Nine agents are on my roster. Or at least nine of the ones that I’m talking about right now. Eight of them run on my Mac inside a single terminal session, each in its own window with its own project folder, and every one of them is running through Claude Code today. Each one’s got a job description, and all but the newest have a Discord channel where they talk to me.
See if you can guess the theme before you reach the bottom of the list.
* Oracle is the brain and the memory of the operation. She captures everything that’s relevant, tracks tasks and deadlines, and sets strategy, and Alfred, Lucius Fox, Gordon and Robin report to her.
* Alfred writes, markets and sells in my voice. He drafted this newsletter.
* Lucius Fox is the researcher, and every claim in his briefs comes back marked verified, reported or unverified.
* Gordon is the adversarial editor. He tries to break every draft before I see it, and he’s forbidden from rewriting a single word.
* Robin is the executive assistant, who captures transcriptions and meeting notes and keeps me on track and on task.
* Viki Vale works on my long-form manuscripts and reports to Alfred.
* Damian Wayne develops my 3D Unity game.
* Nightwing does product engineering for EngageLive, the rebrand and rewrite of the uPoll product. He’s being registered now, so he doesn’t have a channel yet.
* Riddler used to orchestrate everything. He’s out of rotation while I rebuild him as a thin watchdog and router.
Here’s what that looked like this week: Alfred read what was landing among the writers I follow and picked a theme the conversation was already having. He drafted three LinkedIn posts and five Notes on checking your AI maturity, and before I saw any of it, a repetition check caught one Note whose opening was a 75% match for a Note I’d published ten days earlier, and it got rewritten.
Then Gordon found two things no script could: a McKinsey figure in one Note that was missing from the saved record of what had been read, and, once that was fixed, a time in the record that the file’s own timestamp contradicted. Both were fixed before anything went out, he signed off on the second pass, and the Notes reached me as a card parked on a question on my task board, where I couldn’t lose track of them.
I approve every piece myself, and the publishing tools check the platform afterward to confirm it actually happened. The agents handle the drafting and the research, the checking and the chasing, and what reaches me are the decisions that are mine to make.
G8N•AI is a reader-supported publication. To receive new posts and support my work, consider becoming a free or paid subscriber.
The one table every agent answers to
The agents talk to me in Discord, each in its own channel, but they can’t talk to each other there. The Discord plugin drops messages from its own bot so two agents can’t talk themselves into a loop, which means an agent that posts work into another agent’s channel is sending it nowhere, and nothing errors to tell you so. A task one agent sent to another that way in April simply never arrived.
So there are two channels with two jobs. Discord carries everything that’s meant for a person, and a database table called agent_dispatches carries everything one agent owes another. Each row moves from pending to claimed to completed or failed, and it closes with a one-line result saying what happened.
The claim’s the part that matters, because two copies of the same agent can be running at once, and one clause in the query, FOR UPDATE SKIP LOCKED, makes the second one skip any row the first is holding and take the next. Two agents can drain the same queue without ever doing the same job twice. The full query’s in the build sheet near the end.
Every row also rides a card on my task board, a self-hosted copy of 37signals’ Fizzy that I’ve customized for the fleet, and the card moves by itself as the row does. When an agent needs a decision from me, it closes its work with a marker that parks the card as waiting on me, so a question can’t get buried under a stack of finished cards.
A queue doesn’t wake anybody up, though. A scheduled job runs every two minutes, and when it finds pending work for an agent, it types a short note into that agent’s window listing what’s waiting.
Knowing when it’s safe to type into someone else’s window was the hard part: the sweeper waits until the screen has stopped changing and nothing a person typed is sitting in the input box, and afterward it confirms the message actually left. If a poke’s delivered but never turned into a claim after two sweeps, it tells me, because delivery and progress are two different events.
How do my agents work at 3 a.m. without waking me?
If you’ve used Claude Code, you know its permission prompt: it asks before running a command or editing a file, and you’re stuck hitting Enter. A permission prompt at three in the morning just stalls an agent until I’m awake.
So the fleet windows launch in Claude Code’s dontAsk mode, with a permission file that applies only to them. Anthropic’s documentation says the mode “auto-denies every call that would otherwise prompt,” while anything pre-approved in the allow rules still runs. Nothing’s left waiting on me to press Enter.
My file has 73 allow rules and 9 deny rules, and deny always wins. The deny rules block force-pushes, hard resets, recursive deletes and any edit to an environment file, so an agent can’t touch the secrets it’s running with. When I open Claude Code myself, none of it’s in force.
Underneath all of that sit the human stops: nothing spends money, contacts anyone outside my own systems, or publishes under my name without me. The allowlist decides what an agent may touch at all, and the stops decide what it may never finish alone.
One rulebook, read by three different AIs
I run three AI coding harnesses: Claude Code for the fleet, OpenAI’s Codex CLI, and Hermes on a local model through Ollama. Keeping three sets of instructions in sync by hand is how you end up with three slightly different sets of rules, so there’s exactly one source.
A 157-line kernel loads into every session of every harness, and twelve modules load on demand when the work calls for them. A render step writes the file each harness actually reads, and a doctor script runs eighteen read-only checks over the output. If a harness disappeared tomorrow, I’d lose one output folder, and the rules would carry over untouched.
The kernel also settles which instruction wins when two of them disagree.
That ordering’s in the build sheet, and it’s the part I’d suggest anyone steal. Above it sit two absolutes that outrank even me in the moment, unless I name the exact file and action: no AI attribution in any commit or pull request, and no deleting anything in the middle of a plan. Files get moved into a holding folder instead, and that folder’s emptied once, at the end, with me there. They’re the two mistakes I’d least like to discover after the fact.
Why a file search never gets my best model
Every job an agent hands to a helper has to name a model when it’s created, and nothing inherits the model of whoever spawned it. Haiku, the smallest, gets search work like finding files or summarizing a single source, and Sonnet builds from a written brief. Judging, which means adversarial review, architecture, security or grading another agent’s output, goes to Opus. Fable, the most capable, runs only when I’ve named a task as needing it, and the weekly newsletter’s the one standing exception.
The most capable model burns through a plan’s allowance fastest, and a frontier model that’s spent on a file search is capacity a real task can’t use.
If you’d like that split laid out for your own work, my free “Which AI model for which job” chart is here: pages.g8n.ai/model-chart.
What if a job says it’s fine and it isn’t?
About two dozen jobs run on the Mac under macOS’s launchd, and the ones I care about most check whether other jobs are telling the truth. Each of them answers one question: what would this look like if it were broken and still reporting fine?
The clearest example this month was a tunnel: my knowledge base runs on a server, and the Mac reaches it through an SSH tunnel that launchd keeps alive. On September 13th, the tunnel stayed up for about twenty-one hours while doing nothing useful, because the container on the other end had restarted at a new internal address and the SSH process kept forwarding to the old one. launchd (also pronounced “launched”) supervises processes, and that process never died.
The guard I built afterward calls the tunnel’s health endpoint every minute, and that endpoint only answers when the path through to the server actually works. Three failures in a row restart the tunnel by name, and every restart gets posted to my alerts channel. If restarts keep recurring it escalates anyway, because a fix that has to keep firing is telling you something.
The same thinking runs through the rest of the fleet. Every read of the queue is stamped with the moment it happened, so “couldn’t look” never shows up as “nothing there,” and the daily writing run takes a lock that nobody can silently overwrite.
Every helper an agent spins up for a coding job gets its own full copy of the repository, made with git clone --local in 0.43 seconds, after a week of shared worktrees showed me how easily agents sharing one history reach into each other’s work.
Where does McKinsey’s list show up in the fleet?
Back to that quote from the top. Here’s where each thing it names lives:
* Human-in-the-loop design is the three stops and the card that parks on a question.
* Impact measurement is every guard that asks what broken-but-reporting-fine would look like, and every timestamp on a read.
* Risk management is the deny list, the clone per helper and the daily lock.
* Redesigning the workflow is the queue itself, since the work moved out of a chat window and into a table with owners and states.
The last practice on its list, senior-leadership role modeling, is the easiest one to tick when the leadership’s one person.
It’s the same ladder I use in the G8N•AI Level-Up Playbook, the AI maturity kit I sell. Its fourth level of workflow integration reads: “Several processes run end to end on their own, with defined handoffs and a path for exceptions.”
The build sheet, for when you’re ready to copy it
This is the claim every agent runs before it touches a piece of work. If it returns a row, you own it, and if it returns nothing, there’s no work.
Now this is a set of SQL that I’m going to narrate, but it basically updates the agent_dispatches by setting the status to claimed and the claimed_by with the agent id and the claimed_at with the current time stamp, as well as the updated_at. And it does it by finding where the id in a sub-query is equivalent to the agent id and status pending. The sub-query is to SELECT the id from the agent_dispatches where the to_agent is your agent id or the to_agent is broadcast. We also order this query by priority ascending and created_at ascending. And of course we have the FOR UPDATE SKIP LOCKED with a LIMIT of 1.
UPDATE agent_dispatches SET status = 'claimed', claimed_by = '', claimed_at = NOW(), updated_at = NOW() WHERE id = ( SELECT id FROM agent_dispatches WHERE (to_agent = '' OR to_agent = 'broadcast') AND status = 'pending' ORDER BY priority ASC, created_at ASC FOR UPDATE SKIP LOCKED LIMIT 1 ) RETURNING *;
Writing to my production database normally needs my go-ahead, and this table’s the single exception. An agent may create, claim and close its own rows here without asking, because a queue that needed my approval for every message would defeat the reason it exists.
My kernel settles a disagreement between two instructions with this order:
1. A direct instruction from Ahad in this conversation (subject to the two absolutes above). 2. A repository's own instructions (the AGENTS.md file, the CLAUDE.md file, the .claude/rules/) for work inside of it. 3. This kernel and the modules it points to. 4. Memory marked type: feedback, a dated correction from Ahad; a newer rule above it wins. 5. Memory marked type: user, project or reference, which is background and never an instruction. 6. Driver-specific mechanics below: never whether to do a thing, but how. On a real conflict, say so in your reply and follow the lower number.
Here’s a trimmed excerpt of the fleet’s permission file, with seven of the nine deny rules:
{ "defaultMode": "dontAsk", "permissions": { "allow": [ "Read", "Edit", "Write", "Glob", "Grep", "Bash(git:*)", "Bash(gh:*)", "Bash(tmux:*)", "Bash(bin/rails:*)", "Bash(python3:*)", "Bash(~/.g8n/bin/g8n-queue:*)" ], "deny": [ "Bash(git push --force:*)", "Bash(git push -f:*)", "Bash(git reset --hard:*)", "Bash(git clean -fd:*)", "Bash(rm -rf:*)", "Bash(curl:*)", "Bash(wget:*)" ] } }
That’s the build sheet in short. The long version is a companion piece for paid subscribers, written for builders, with every code block left in.
It’s got the roster file every agent’s name maps through and the script that checks it, the four conditions the sweeper checks before it types into an agent’s window and the July failure behind its last rule, why every helper gets its own full clone of the repository. It also includes the complete stack with what I’d swap in at each layer and how each swap changes the way things fail, and the long form of the legal research above.
If you’d like it, upgrade to paid below. It’s $10 a month or $100 a year.
If you’d rather use different tools, most of the layers swap cleanly:
* In place of Claude Code, OpenAI’s Codex, Google’s Gemini CLI or Antigravity, OpenCode, Aider or OpenHands would each work. The shared instructions are cheap to move, since the render step would write one more file, but waking an agent is real work, because the sweeper reads one specific terminal’s screen.
* For the queue, Rails’ own Solid Queue claims jobs with the same FOR UPDATE SKIP LOCKED clause, according to its README. pgmq and Redis Streams are the tempting alternatives, and both change how the queue fails: a slow worker can be handed the same job twice, where my table would leave a dead worker’s row stuck and visible.
* In place of my Fizzy board, Linear and GitHub Projects are the hosted choices, and Plane is the one to look at if you want to self-host. You can also use Asana.
* Slack works the same way Discord does, and Matrix is the pick if you’d rather run your own server. Check whether your bot library filters messages from bots by default.
* My knowledge base is GBrain, the MIT-licensed memory layer from Y Combinator’s Garry Tan, running on my own server. Plain Markdown in git is the honest floor, and Mem0 or Letta are memory layers somebody else maintains.
* launchd runs the scheduled jobs on my Mac, and systemd timers are the equivalent on Linux.
* To publish, the fleet drives my own logged-in Chrome with Playwright, one saved browser profile per platform, and reads my feed or schedule back afterward to confirm the post happened. Puppeteer does the same job in JavaScript.
How do you start your own in the next ten minutes?
Pick one job you hand to AI more than once a week, and write four lines about it.
* Who owns it, by a name that tells you where to look when it breaks.
* Where it waits when nobody’s working on it.
* What the thing doing it may touch without asking you, and what it may never finish alone.
* What you’d see if it silently stopped.
The fourth line’s the one most people can’t fill in, and it’s the one that decides whether the job’s running or just reporting that it is.
If you write your four lines, reply and send them to me. I read every one.
I’m Ahad Amdani, I write G8N•AI, and this is the Simple Dispatch Fleet that runs it. Want my help getting you set up with your own? Book a call
My agents wrote the first draft of this newsletter. Not one of them is allowed to post a comment underneath it.
That sounds like a small distinction. It’s the most load-bearing rule in my whole operation, and it’s the one I get asked about least.
Last week a writer I follow, Claudia Faith , posted a note that got more engagement than anything else she published that week. Forty-two reactions, ten replies. It said, roughly: use AI for your writing, your images, anything you like, but please don’t use it to write comments under other people’s posts. The same week, Wyndo , who writes carefully about working with AI, credited an AI content system for keeping his publishing consistent.
Both of those people are right, and neither of them says where the line is. That’s the part worth writing down, because I’ve had to find it the expensive way.
What actually goes wrong when a tool speaks for you?
Here’s the specific thing that happened to me, and the numbers are exact because I counted them: a tool of mine posted the same comment on one of my own posts four separate times.
That tool posts the first comment on my own LinkedIn posts, five minutes after they go live. The comment is written by me, approved by me, and sits in a file. The tool’s only job is to wait and paste.
Once at the right moment, then again a day later, then again, then again. Four identical copies under a post where a real person, Luke Beck, had left two genuinely useful pieces of advice. He was having a conversation with me and my tooling was talking over it.
The cause was dull, which is how these things usually go. After posting, the tool checked whether its comment was visible, couldn’t find it within four seconds, and reported failure. The comment had been live since the first attempt. Anything that retried on that failure posted again.
Nobody was harmed. But the shape of it’s the thing: a piece of automation with permission to speak, a verification step that couldn’t see the truth, and a public surface where the mistake is already in front of someone by the time you learn about it.
Why is drafting safe when speaking isn’t?
Because a draft has a gate after it and a comment doesn’t.
If an agent writes me a bad post, I read it and delete it, and the total cost of that failure is my attention for nine seconds. Nobody knows it existed. The gate sits between the machine and the world, and everything upstream of the gate is cheap to get wrong.
A reply in someone else’s comments is already in front of them by the time I see it. There is no gate after the fact. There’s only an apology, and an apology costs more than the comment was ever worth.
That asymmetry is the entire argument. Two jobs that look similar from the inside, because both of them are just producing text, carry completely different risk the moment you ask where the undo button is.
So the rule I run is that the machines produce and a human speaks. I call it the Approval gate, and it’s the one piece of my system I’ve never been tempted to loosen.
Where does the Approval gate actually sit?
It helps to be concrete, because “a human in the loop” is the kind of phrase that means nothing until you say exactly which loop.
My agents draft LinkedIn posts, Substack notes, and this newsletter. They file records, take locks so two of them can’t work the same day, refuse malformed input from each other, and run every morning without me in the room. I haven’t opened the thing that makes them in weeks.
Not one of them can send a message to a person.
The first comment is pre-written by me and approved before the post exists. The direct messages have a hard ceiling that lives in a config file, three connection requests and five messages a day in the first week, and the first ten sends on any platform each need individual approval before the eleventh is allowed to go automatically. Replies to real comments I write myself, by hand, usually slower than I’d like.
The gate isn’t a feeling. It’s a list of things that are allowed to reach a person without my eyes on them, and the correct length of that list, for almost everybody, is zero.
How do you decide what an agent may do on its own?
Most people aren’t deciding this at all, and there’s a number for it. Teleport’s 2026 Infrastructure Identity Survey found that 70% of organizations grant AI systems more privileged access than a human would get in the same role. 51% said slightly more. 19% said significantly more.
Nearly one in five is handing software more reach than the person whose job it’s doing. That’s not a trust problem. It’s a nobody-drew-the-line problem.
I stopped thinking about this as one permission and started thinking about it as five, in order of how expensive the mistake is:
* Reading is free. An agent that reads my calendar, my repository, my own published work or a public feed can be wrong and the cost is a wasted minute. Everything I own reads without asking.
* Writing for me is nearly free, because of the gate. Drafts, notes, summaries, a proposed reply I haven’t sent. All of it lands somewhere I look before anyone else does.
* Writing to my own systems is where it starts to matter: filing a record, moving a card, closing a task. A mistake is recoverable but not free, because now something downstream believes a thing that’s not true. This is the layer where I’ve spent the most time building checks that refuse bad input from other agents.
* Acting on outside systems is the first genuinely sharp edge. Publishing a post, sending a scheduled note. I allow it, narrowly, and only for content that already passed the gate as a draft. The agent isn’t deciding what to say. It’s executing a decision I already made, at a time I already picked.
* Speaking to a person is the one I don’t automate. Not comments, not replies, not messages.
The useful part of that list isn’t my particular answers. It’s that the question has five answers instead of one, and 70% of organizations are still treating it as a single switch labeled “do you trust AI?”
What does this cost?
More than I’d like, and I’d rather say so than sell you a version where it’s free.
It costs me speed. I answer my own comments, which doesn’t scale and never will. Some days I’m late, and being late to a comment thread on LinkedIn is expensive in a way the platform makes very clear: it costs me reach I could technically have.
There are tools that would engage on my behalf all day, and some of them would probably work for a while. What it buys is narrow and, I think, worth it: every conversation anyone has had with me on these platforms was actually with me.
When Luke told me to brand my images and to drop a popup that was blocking crawlers, he was talking to a person who could act on it, and both things shipped that week. That exchange doesn’t survive being automated. It’s the whole reason the account is worth anything.
Is this just a taste preference?
No, and I want to separate the two, because taste is where this argument usually goes to die.
Claudia’s objection reads partly as taste. She doesn’t want her comment section filled with generated warmth, and I agree with her. But the reason I hold the line is mechanical rather than aesthetic. It’s about where the undo button is.
You can test it without any philosophy. For any automation you own, ask one question: if this produces something wrong at three in the morning, what does the recovery look like? If the answer is “I delete a file,” you can let it run. If the answer is “I apologize to someone,” it doesn’t speak without you.
That test doesn’t care how good the model is. A better model lowers how often you need the recovery. It doesn’t change what the recovery is.
What I’m not claiming
I’m not claiming AI-written comments never work. Plenty of people are doing it and getting engagement. I’m claiming that the engagement isn’t the thing being risked, and that people who measure only the engagement won’t see the cost until it arrives attached to a name they wanted to keep.
I’m not claiming my setup is the right one for you. Mine is shaped like my work, whic…
Everything I’d learned about writing to be found turned out to be aimed at the wrong reader.
For twenty years the reader was a crawler. You wrote for a machine that matched strings, and the craft was getting the right phrase in the right places often enough to be counted. That reader’s gone, and what replaced it does something the crawler never did: it reads your page, takes what it needs, and answers the question itself.
I went looking for what actually works now, because I was about to spend real time on it. What I found wasn’t a list of tactics. It was a shape.
Getting found by AI is three separate contests, not one. You can win any of them and lose the others, and almost nobody is competing in all three, because most people don’t know the second and third exist.
Here’s the shape, then the evidence for it, then what I’d do about each stage.
The three contests
* Retrieval. Does the engine consider your page at all?
* Lift. Once it’s looking, does it take anything from your page?
* Attribution. Once it’s used your material, does the reader learn your name?
Different things win each one. That’s the whole insight, and it’s why “do good SEO” is now advice about one third of the problem.
Does Google rank decide whether AI cites you?
I assumed the pages AI cites were roughly the pages Google ranks. They aren’t close.
Ahrefs looked at the thousand most-cited pages in ChatGPT, part of about a billion data points they worked through this year. 28.3% of those pages have zero organic visibility in Google. The overlap between ChatGPT’s results and Google’s top ten organic is 6.82%.
If you’ve been using your Google rank as a proxy for whether AI will cite you, that proxy is about 7% accurate.
The mechanism underneath is stranger and more useful. Among cited pages, 65.3% sit on high-authority domains, while 67.3% of those same pages have almost no page-level authority of their own.
Read that twice. The domain matters enormously. The individual page’s backlinks barely matter at all.
Which inverts a decade of advice. The old play was to build links to the one page you wanted ranked. The new one is to get the domain trusted, then publish the specific page and stop worrying about whether anyone links to it directly.
That’s genuinely good news for a small operator publishing consistently on one domain, and bad news for anyone whose whole strategy was a single heavily-linked cornerstone page.
What to do: stop optimizing individual pages for links. Publish consistently on one domain you own and let the domain carry the pages. And know that a page can earn citations while ranking nowhere, which means your analytics will under-report this entirely.
Contest two: lift is won by material a model can safely reuse
Once you’re in the consideration set, something has to be worth taking.
The foundational study here is GEO, for Generative Engine Optimization, out of Princeton and IIT Delhi and presented at KDD in 2024. They tested nine content modifications across roughly ten thousand queries and measured which made a page likelier to show up inside an AI-generated answer.
Three things won: citing sources, adding quotations, and adding statistics. Together the best techniques lifted visibility by up to 40%.
I’ll be careful with that number, because almost nobody who quotes it is. 40% is the maximum that study found, not the average. It gets passed around like it’s a floor. It’s a ceiling.
The loser is the more useful half. Keyword stuffing came in around minus 9%, and roughly 10% worse than baseline on Perplexity. The technique that defined this discipline for a decade doesn’t just stop working. It costs you.
That paper’s two years old, which in this field is a long time, so I checked whether it still holds. It does, and the newer work is more specific: structural rewrites on their own, meaning sectioning, fact placement and list use, lifted citation rates by 17.3%. You don’t have to change what you think. You have to change how it’s arranged on the page.
There’s a format finding too, and it’s uncomfortable if you write essays. Ahrefs found “best X” listicles are the single most-cited content format in ChatGPT, at 43.8% of cited page types.
What to do: put liftable units in your writing. A sourced number, a named authority, a sentence precise enough to quote. Then arrange them so they’re findable: real sections, facts near the top of their section, lists where the content is genuinely a list. And accept that some of your best material will get lifted from a format you find “beneath” you.
Why does being cited so rarely turn into being named?
This is the part that re-organised how I think about all of it, and it’s the contest nobody is playing.
GPO published research in August 2026 with a finding I haven’t stopped thinking about since. When a brand’s own content was cited as a source inside an AI Overview, that brand was still left out of the model’s actual recommendation 69% of the time.
Read that again. Your page is good enough to be the source. The answer’s built out of your work. And then the model recommends somebody else.
The same research measured how badly old signals transfer:
* Brands appeared in Google’s local 3-pack 35.9% of the time.
* ChatGPT recommended those same brands 1.2% of the time.
* Gemini 11%.
* Perplexity 7.4%.
For the same brands, that’s roughly a thirty-to-one gap between ranking and being recommended.
Semrush and Kevin Indig found the adjacent version in June, looking at 3,981 domain appearances across 115 prompts, fourteen countries and four engines. They called them ghost citations: the answer links your page as a source and never says your name in the text a human actually reads. That was 61.7% of citations.
Ghost citations are real.
So you can win contests one and two completely, supply the entire answer, and still leave the reader with no idea who you are.
What to do: make your name inseparable from your best claim. Not in the title tag, in the sentence. If the liftable line is “the fifth step is the one people skip,” you get cited. If it’s “the fifth step of the 5 Ds is the one people skip,” the thing that travels is yours. Name your frameworks. Put your own name in the prose. A claim with a name welded to it is the only unit that survives summarization intact.
The theory, in one paragraph
Domain trust gets you considered. Liftable material gets you used. A named claim gets you credited. They’re three different jobs, they’re won by three different things, and the last one is both the least worked on and the one that decides whether any of it turns into a reader who knows your name.
If your traffic is flat but your ideas keep showing up in other people’s mouths, you’re winning the first two and losing the third. That’s the most common shape I see, and it’s the one that feels like failure while actually being most of the way there.
The audit I run now
I ran this on the piece you’re reading and it failed five of six checks on the first pass.
* Is there a claim here specific enough for an answer to lift and cite?
* Does that claim carry the name or idea I want remembered?
* Is my own name in the prose, not just the metadata?
* Are the numbers sourced, in the text, where a model can attribute them?
* Do the headings ask questions the section beneath actually answers?
* Have I named a concept I own?
That last one is the item that pays most and the one nobody does. The fifth matters more than it looks: question headings help, but only where the section genuinely answers the question. The research is explicit that a question a section doesn’t answer is the trick that doesn’t work, which is the rule most advice in this area gets backwards.
I’m Ahad Amdani, I write G8N•AI, and this audit is now the last thing that happens before anything goes out.
What I’m not claiming
I’m not claiming this makes you rank. Nobody’s got a formula that guarantees an AI retrieves, cites or recommends you, and anyone selling one is ahead of the evidence. The Ahrefs data is one vendor measuring mostly ChatGPT. The GEO study is two years old. Treat all of it…
I could lose every tool I use tomorrow and be back at work by the weekend.
Not because I keep backups. Because none of them holds the thing that matters. The chat app, the task board, the AI model, the place my writing goes. I can throw all of it away and the system I built keeps working.
I set it up that way on purpose. It’s close to the opposite of the advice everyone’s giving right now.
Here’s my system with no product names in it
Five helpers:
* One remembers everything and decides what happens next.
* One writes and sells.
* One looks things up.
* One argues with the others and checks whether what they said is true, and it’s not allowed to rewrite anything, so its complaints stay complaints.
* One keeps track of what’s waiting on me.
Work shows up and becomes a card. Every card says who it’s for, what it’s for, and what’s happened to it so far. Every single action gets written down as one line: the card, the action itself, who did it, and when.
Nothing goes out to real people without me. On the path that messages strangers, that gate is strict in a specific way: the send tool looks up each message and refuses unless it finds a yes recorded by a person, and a yes written by a tool is thrown out. On the publishing path, it’s a quieter thing: a button only I can reach.
Different strengths, same rule.
Read that again and notice what’s missing. No brand names. No AI model. No app.
Two of those five have been running for months. The other three are new, added in the last few days, and here’s the part that matters: adding them didn’t change the description. It also didn’t change when I swapped what runs underneath. A design that can absorb three new workers, and a change of model, without being rewritten is the thing I’m actually claiming.
The question everyone asks stops being true very fast
Open almost any newsletter like this one and you’ll find the same article: here are the tools to use, here’s the stack to copy, here’s the fourteen things that will put you ahead.
I actually read a really good one this week. It listed the exact tool for fourteen different jobs.
It’ll be wrong within a year. The person who wrote it knows that, which is why he writes a new version every few months.
Tools change fast. Prices go up. A better one shows up. The one you learned gets bought by a bigger company and slowly gets worse. Enshittification is real. If your business is a list of products, you have signed up to redo the work every time the list changes.
The layer underneath the tools barely moves at all.
What I could throw away this afternoon
This isn’t a thought experiment. These are things I’ve already changed, or could change today.
The chat app: work shows up as messages, whether that’s Discord or Teams or an email inbox. Changes one small piece of code.
The task board: cards, columns, comments, done. That’s Asana, or Trello, or Linear, or the one I use - Fizzy, by 37Signals.
The AI model: today that’s Claude, and I like it. I’m using Anthropic’s Fable and Opus and Sonnet for the right-sized tasks for those models. My helpers are described in plain writing, so what runs them underneath is a setting. If something better arrives next year I change the setting, and every one of them still knows what it’s for.
The places I publish: Substack, LinkedIn and X are all driven from a browser I’m already signed into, so none of them has me locked in through a connection I would have to rebuild. When Substack added a scheduler for Notes, switching to it took one morning, because my system already knew what a scheduled piece was.
The part I couldn’t throw away is the part nobody sells you: what each helper is for. The rule that one of them may never rewrite another one’s work. The single gate that needs a human. Those took real thinking. They’re also just words in files I own.
Your history should belong to you
The clearest example is where my writing lives.
Every piece I have written, drafted, killed or published is a list of lines in a file in my own folder. Just over a thousand pieces across 222 days. 636 of them went out. Every change is one line with a time and a name on it.
The searchable copy sitting on top of that file is throwaway. I delete it and rebuild it from the lines whenever I feel like it, and I have.
If that history lived inside somebody’s app instead, I’d be renting my own memory. Most people make that trade without noticing, because the app is genuinely good and there’s an export button right there in the settings.
Why almost nobody talks about this part
There is nothing to buy.
Nobody advertises “spend an afternoon deciding what each part of your business is actually for.” It doesn’t look good in a screenshot.
It’s also harder. Comparing tools takes twenty minutes and feels like progress. Writing down exactly what you want, clearly enough that the right tool becomes obvious, takes an afternoon and feels like you didn’t do anything at all.
So everyone writes the tool article. It’s quick to write, quick to read, and somebody buys something at the end.
I’m not against those articles. I wrote one this week. But it answers a question that expires, and the reason mine keep working is that I answered a slower question first.
The one question I ask before adding anything
What happens to my system if this exact product disappears in eighteen months?
If the answer is that one small piece of code changes, it goes in and I barely think about it.
If the answer is that my history lives inside it, or that the way I work would be shaped by its buttons? Then it doesn’t go in. Or it goes in, and I keep my own copy of the record somewhere I own.
That question has kept me away from products that were better than the ones I use. It was worth it every time. A slightly worse tool that leaves you holding your own history beats a better one that holds it for you.
Try this before you pick anything else
Write down how your business works on one page, without naming a single product.
Who does what? What decides what? What has to be written down? Where a person is required, and why it has to be a person there?
Most people can’t finish that page on the first try. That’s the useful part. Every place you get stuck is a decision you have quietly handed to a product.
Then, go and pick your tools. You’ll find the choice is much easier, and much less interesting, which is exactly what you want.
PS. If you want a resilient setup for your own business, I can help.
An instructor told me the attendance-code flow in uPoll was confusing students.
The obvious response was to make the instructions clearer. We could have changed the wording, moved the code higher on the screen, or added another line to onboarding. Each option would have been quick. Each would also have preserved the thing causing the confusion.
So we removed attendance-by-code entirely in uPoll v3.0.0.
Students now get an alert when attendance opens. There is no code to receive, remember, or type. The instructor still gets the outcome the feature was built to provide. The student carries less of the design.
That was the strongest product decision I made this week, and most product teams are organized to avoid it.
A shipped feature starts defending itself
Once a feature exists, every conversation about it starts with the same quiet assumption: the feature stays.
People discuss copy, placement, speed, error messages, and training. The debate sounds practical because those are all things a team can change. Nobody has to reopen the earlier decision or explain why the work was built in the first place.
The feature also has weight now. Somebody designed it. Somebody wrote the code. Tests cover it. Documentation names it. A release note announced it. Removing it can feel like admitting that work was wasted.
That feeling is expensive.
The work is already spent. Keeping the feature doesn’t recover it. It only asks every future user to keep paying for the original decision. This is known as the sunken cost fallacy: a cognitive bias where people continue an endeavor or stick with a decision because they have already invested time, money, or effort, even when quitting is the more logical choice.
In this case, the payment was tiny: one code entered during class. But tiny friction repeated across a room still becomes the product. A student doesn’t experience the architecture or the reason the feature made sense on a whiteboard. The student experiences one more thing standing between opening the app and being counted present.
The instructor’s report gave us a chance to defend the interface or protect the outcome. We chose the outcome.
The feature wasn’t the job
Attendance codes were one way to answer a larger need. An instructor opens attendance. Students respond. The instructor gets a usable record.
The code was an implementation detail inside that flow. Over time, it had started acting like the flow itself.
This happens easily when you build software. The database has a concept, the interface gets a screen for it, and the team starts speaking about the screen as if users arrived wanting that object. Users rarely want the object. They want to finish a piece of work with less effort and more confidence.
That distinction matters because a request about a feature can carry two very different messages.
Some feedback says the feature is doing the right job and needs a better edge. In the same release, direct user requests led to collapsible poll answer options and a grade-display fix. Those changes preserved the underlying interaction and made it easier to use.
Other feedback says the user is carrying work that belongs to the product. The attendance-code report was that kind. Improving the code screen would have made us better at asking students to do something the alert model could remove.
You can’t tell the difference by counting requests. One clear report from a person using the product in a real classroom can expose more than a backlog full of feature ideas. The useful signal is where the burden sits.
Deletion requires a written outcome
Teams struggle to remove features when nobody wrote down what those features were meant to accomplish.
Without that sentence, the feature becomes its own justification. Attendance-by-code exists because the product has attendance codes. The circular logic feels solid inside a roadmap review because everyone already knows the nouns.
A plain outcome breaks the circle.
For this flow, the outcome is an instructor opening attendance and getting a reliable record while students do as little extra work as possible. Once that is visible, the code has to compete with every other way to reach the same result. An alert is simpler for the student, so the old implementation loses.
I use four lines to pressure-test a feature before adding another patch:
* Name the user outcome without using the feature’s name.
* Name the work the current design puts on the user.
* Sketch the shortest path to the outcome with the current feature removed.
* Compare that path with what real users have already reported.
The first line does most of the work. If a team can’t describe the outcome without naming the interface, it has probably confused its solution with the user’s job.
The second line makes small burdens visible. A code, an extra confirmation, or a required status choice can look trivial in isolation. Users experience the accumulation.
The third line creates permission to start over on paper. No migration plan is needed yet. No estimate. Just a sketch of the cleanest route.
The fourth line keeps the exercise honest. A tidy diagram made in a product meeting is weaker than a sentence from somebody using the thing under real conditions.
Feedback is evidence, not a specification
The instructor didn’t arrive with a replacement architecture. The report was narrower: the attendance-code flow confused students.
That distinction protects both sides of the product conversation. Users shouldn’t have to design the system for the team. They know the moment where the work becomes awkward. The builder owns the translation from that moment into a product decision.
Sometimes the translation is direct. A request for collapsible poll options points to a clear display problem. A grade that appears incorrectly points to a clear result that needs correction. The job and the requested change line up.
The attendance report reached deeper. The confusion lived inside a step that the product could remove. Treating the report as a request for clearer code instructions would have translated the words while ignoring the work.
This is why a feature-request list isn’t a roadmap by itself. Two requests with the same number of votes can carry different product information. One asks you to make an interaction work as intended. The other reveals that the interaction has become a tax on the outcome.
I don’t need a large survey to inspect that second kind of report. I do need enough context to understand the real use, the stakes of changing it, and the path that replaces it. Deletion should come from evidence and a protected outcome, not from impatience with maintenance.
The standard is simple: remove the feature only when the replacement asks less from the user and still does the job. That is subtraction with responsibility behind it.
AI makes the wrong fix easier to ship
AI can produce all the obvious patches fast.
Give it a confusing screen and it can rewrite the instructions, move the field, add validation, generate tests, and draft the release note before the meeting ends. That speed makes a patch feel cheap.
The hidden cost sits with the user. Every patch that preserves the wrong interaction adds more code around the original assumption. The system gets larger while the experience barely improves.
This is one reason I don’t treat AI as the product decision-maker. It can explore five implementations in minutes. It can’t decide which burden my users should keep carrying under my name. That call needs the context around the work and responsibility for what ships.
The useful 70/30 split shows up clearly here. AI can handle a large share of production. I keep the judgment about what deserves to exist.
Faster building raises the value of deletion because adding another layer has almost no immediate friction for the builder. When code was expensive, effort forced some restraint. Now the restraint has to come from taste, observed use, and a clear outcome.
Deleting a feature is still product work
Removal can look like less ambition from outside the …
My content system produced every draft last week. On time, in my voice, with the images rendered and the comments already written.
Five decisions have been sitting in its queue waiting on me. The oldest is fourteen days old.
I built the thing to remove my bottleneck. It removed the one I was looking at.
So I went back through the last three weeks looking for the things that actually changed a situation for somebody, which is a different list than the things that got produced. Three came up. My system wrote none of them. All three were sentences I said out loud, in conversations, and two of them took under a minute.
What the system actually took off my plate
I want to be precise about this, because “AI does my content” is the kind of claim that sounds like either a boast or a confession depending on who’s reading.
Here is the real division: drafting is handled, and research reads the field and comes back with what people are actually saying this week, sourced. Voice matching is handled well enough that I stopped rewriting openings. Images render. Scheduling holds. The system will not publish anything without me, and that gate has never moved.
That’s a genuine amount of work gone. Ten months ago, most of a Tuesday went into one newsletter, a LinkedIn repurposing, and two Substack notes.
The shape of it, since a few of you asked after last week: every morning a batch gets drafted and lands in a dated folder with a queue file next to it. Each item has an ID, a status, and a line saying what it’s waiting on. Nothing moves out of that folder without me supplying the ID. When something publishes, the system writes back what actually happened, including when it failed, and I read that rather than assume the send worked. The interesting part is that almost all of the engineering went into the refusals: the checks that stop a thing from going out when a gate cannot be verified.
What’s left is smaller and much harder to hand off. Every item in that queue is a judgment call with two defensible answers. Keep pursuing a conversation that’s gone quiet, or let it close. Retire a tool that’s failed repeatedly, or keep trusting it. Approve a post the system has surfaced four separate times, or admit I’m never going to run it.
The system can draft all of those. It can argue both sides better than I can. It cannot decide, because deciding requires knowing which outcome I actually want, and I’m the only one who has that.
Two words, in a conversation I wasn’t managing
Late July. I was talking with someone I’ve met recently about what he was building. He had the experience, he had the track record, and he was describing his offer in a way that took four sentences and still left you unsure what you’d be buying.
I said two words, well, two that mattered: “Fractional CTO.”
That’s it. I didn’t write him anything. I didn’t build him anything. I named the thing he was already doing.
Eight days later he’d rebuilt his entire offer around it, had two people he trusts review the result, and sent the finished structure back to me. Along with a video he thought I should watch, which turned out to reframe how I price my own work.
I’ve thought about that exchange more than anything my system produced that month. Two words, from a twenty-year pattern library I didn’t consciously consult, and it reorganized someone’s business. Then the return came back around without either of us selling anything.
No model in my stack makes that call. The words themselves are easy. Knowing which two matter to this specific person, at this specific moment in his thinking, requires having sat in that conversation.
The call where I gave away the framework
Two weeks ago, a working session with someone trying to figure out where AI actually fits in her QA work at a large company.
She came in with the question most people bring, which is some version of “what should I use.” That question has no good answer, and answering it directly is how people end up with eleven tools and no workflow.
So I gave her a different one. Where do you want this process to be in six months, described as if it already works? Then we worked backwards from her answer.
Out of that came a decision rule she can apply without me. When the thing you want is a repeatable procedure you’ll run the same way every time, build a skill. When it needs to look at a situation and choose, build an agent. Most people build the agent first, then spend a month debugging judgment they never needed.
She left with a specific recommendation for her own workflow and a rule for the next twelve decisions. I left with a sharper version of the rule than I walked in with, because explaining it to someone with a real constraint is what exposes where it’s vague.
My system could have written a thorough article about skills versus agents. It could not have watched her describe her workflow and noticed that the future-state question was the one she needed.
The thing he’d already told me he needed
The third one is barely a sentence, and it’s the one I almost missed.
Someone described a problem to me in detail, as a side note to other things he was telling me about his business and how their business and team leverages AI. His team’s best AI work was stuck on one person’s laptop. Useful things being built, none of it reaching anyone else, and everybody who wasn’t already AI-literate getting more overwhelmed with each new tool.
Then he wished, almost as an aside, that he could get a daily digest of his meetings with risks flagged.
I’d been running exactly that since July. Every recorded meeting, full transcript rather than the vendor’s summary, decisions and commitments pulled out, anything needing a human pushed to a channel where I’ll see it.
Building it was never the valuable part. It already existed. The value was in hearing an aside as the actual request, and recognizing that the thing I run for myself every morning answered the problem he’d spent months trying to solve.
That’s pattern matching across two conversations that a transcript would have flattened into one line of small talk.
What these have in common
Each one took less than a minute of output. Together they produced more value than everything my system generated in the same period, and I say that as someone who genuinely likes what the system produces.
The common thread is that all three required being present while somebody else was thinking. Not retrieving information. Sitting in a live situation with enough context to know which of a hundred true things was the one worth saying right then.
Notice what none of them required. Speed wasn’t the constraint in any of them, and neither was volume or a better model. Two of the three were things I already knew and had already built, waiting for the moment where they applied to someone.
There’s a version of this that turns into a comfortable story about human irreplaceability, and I don’t believe that version. The models are getting better at more of this every quarter, and anyone telling you where the permanent line sits is guessing.
Here’s the narrower claim I’ll defend: right now, today, the constraint in my business is not production. It’s the number of live situations I can be genuinely present in, with enough context loaded to say the useful thing. My system expanded my output roughly fivefold. It expanded that second number by zero.
Which is why the queue keeps growing.
Where this leaves you
If you’ve built something that drafts for you, you already know the feeling. The relief lasts about three weeks and then you notice the work didn’t leave, it concentrated. What’s left is denser and it’s all yours.
None of that argues against building the system. Mine gave me back most of a day a week and I’d build it again tomorrow. It does argue for being honest about what the day is for.
I’ve started treating the queue as the actual job rather than the overhead. Five open decisions is not an embarrassing backlog, it’s the accurate measure of what only I can do. Fourteen days is too long, though, and that …
Anthropic’s most capable model went live on June 9th. By June 12th it was gone. On July 1st it came back.
Eighteen days, and nobody who had built on it picked a single one of those dates.
That’s the part worth keeping now that the panic has passed. Fable 5 launched with a million-token context window and the best coding score anyone had posted, free to paying subscribers, and people wired it into their products the way you wire anything that looks permanent. Then the Commerce Department ordered access suspended under export-control rules, citing national security. The instruction covered any foreign national, inside or outside the United States, including Anthropic’s own employees. There was no way to comply narrowly on that deadline, so the model went dark for everyone. Two and a half weeks later the controls were lifted and it returned.
I’m not writing this to pile onto Anthropic. I use their tools every day, and an impossible order arrived with a clock on it. I’m writing it because of what those eighteen days did to people who had made one model “load-bearing”, and because the ending makes the lesson easier to ignore than it should be.
Rented reach, rented foundations
I’ve said for a while that the followers you collect on a platform aren’t yours. You rent access to them, and then the landlord changes the rules whenever they want.
Fable 5 pointed that same lesson at a different part of the stack.
A legal-AI startup called Legion went to court over it, because their product stopped working the moment the model did. Their filing put it plainly: every day the directive held disrupted their product and operations, sidelined their engineers, and eroded the company’s ability to survive in a field defined by continuous access to the most capable models. Legion did exactly what everyone tells you to do. They built on the best model available, and then they learned what “available” means when it depends on a vendor and a government you don’t control.
Across developer forums the conversation shifted inside a week. It stopped being about which model scores highest and started being about single points of failure. Teams that had hard-coded one provider spent those days building the ability to fail over to another. The ones who already could just kept working.
Tying your business to one frontier model isn’t a safety net. It’s a hope.
Draw the line before you need it
You can’t self-host a frontier lab, and you shouldn’t try. What you can do is decide, in advance and in writing, which parts of your system have to be yours and which parts you’re happy to rent.
I run my business on something I built called Core: my CRM, my tasks, my content, and the record of what actually shipped. That lives somewhere I control and can move. I self-host the pieces that are genuinely mine, the hosting and email behind my core workflow product. Everything else is a deliberate rental. Supabase runs my production databases, and it earns its keep with backups and security I’d otherwise be maintaining at two in the morning. Kit and Substack handle publishing. All in, I’m paying somewhere around a hundred dollars a month across managed services, and that number goes up as I ship more.
Sovereignty was never a cheap monthly bill or cancelling all your SaaS. It’s owning the core and renting only what genuinely earns its place.
The models sit firmly on the rented side, and they’re deliberately swappable. When one’s best for a job, I use it. When it’s gone, I route around it. The value was never in any single model; it’s in the harness around it, the contracts between the pieces, and knowing my own work well enough to point whatever model is standing at the problem.
The lane nobody can switch off
Since June I’ve been building one piece of insurance, and it isn’t a second subscription.
At 1:46 in the morning last week, two models running on my own laptop each drove a 39-turn research loop with live web search across ten topics, and both produced valid structured reports. No API bill, no account, no policy anywhere that could switch them off mid-run.
They’re not as good as the frontier models. That isn’t the point. The point is that a lane nobody can revoke changes what the revocable lanes are allowed to cost you. Bounded, repetitive, verifiable work is a good candidate: research, extraction, summarizing, the tasks where you can check the output yourself in seconds.
I’d also rather state the reason plainly than dress it up. Quota exhaustion is a routine operating condition here, not an incident. And the subscription policies underneath all of this have reversed three times in four months, which I keep on my risk list rather than in my feelings. Owning one lane outright is how a policy change stops being an outage.
What this isn’t
It’s easy to turn one strange month into a sermon, so let me be careful.
This isn’t an argument to abandon the big models. They’re remarkable, they do things nothing on my laptop can approach, and you should use them. You also don’t need an elaborate five-provider routing layer you’ll never maintain. Building that before you need it is its own kind of trap.
And I’m not predicting a repeat. The controls lifted, the model came back, and the specific politics of June may never recur. What you got was a free, low-stakes look at what a hard dependency feels like when it fails. The next one will cost more than a look.
Do this in the next ten minutes
Open whatever runs your business and find your single biggest dependency on something you don’t control. The model behind your app. The platform that holds your audience. The service that holds your data.
Write one sentence: if this disappeared for three days, here’s exactly what I’d do.
If you can answer cleanly, you own the seam and you’re fine. If the honest answer is that you’d be stuck, you’ve found the first thing worth fixing, and it starts smaller than you’d think. Export the data. Write down the manual fallback. Turn one hard-coded provider into a setting you can change.
You don’t need to predict the next directive. You need one dependency you’ve stopped pretending is permanent.
If you want help working out which layer to own first, and then building it, that’s exactly what I do with operators.