Prompt engineering is choosing the words you hand the model. Loop engineering is designing what the system does with its own output: when it stops, and where you sit in the cycle. It matters more than the prompt for a blunt reason. The prompt fails in the demo, where you can see it. The loop fails three weeks later in production, quietly. Gartner expects more than 40% of agentic AI projects to be canceled by 2027, and the reasons it gives (runaway cost, fuzzy value, weak risk controls) are loop failures, not model failures.

What follows is the version of the instructions I wish someone had handed me when I was first exploring loops, written for a person who has never opened a terminal and is not sure they belong here. You do.

Here is what you will have at the end: a small program that reads emails you flag, writes a draft reply for each one, and saves the drafts to a folder for you to review. It never sends anything on its own. You build the brakes, and you watch them work before you trust them with anything real.

You are asking Claude to build a thing with five brakes in it. You do not have to understand the code. You only have to understand the brakes, because they are the reason this is safe:

1. It stops on its own, either when the flagged emails run out or after a set number of steps.

2. It checks its own drafts before saving them, and throws out the bad ones.

3. Anything it cannot undo (sending, deleting, archiving) waits for you. It never does those itself.

4. It writes down everything it did, so you can see why it made each choice.

5. When it gets stuck, it stops cleanly and tells you, instead of improvising.

That is the whole design. Now let us set it up.

Step 1. Get your key. This is the one secret you need.

Your agent needs its own way to talk to Claude when it runs, separate from any chat app you use. That is what an API key is.

Go to console.anthropic.com and make an account. This is the builder’s side of Anthropic, and it is separate from the claude.ai chat subscription you might already pay for. You need this one.

Once you are in, find Plans and Billing and add a small amount of credit. Five dollars is plenty. Running this tutorial costs pennies, not dollars. While you are on that screen, set a monthly spending limit. Do it now, not later. The classic beginner story is leaving a script running overnight and waking up to a bill. With a cap, the worst case is that your script quietly stops, not that your card gets a surprise.

Then go to API Keys, click Create Key, name it something like “inbox-agent,” and copy it the instant it appears. It is shown to you exactly once. If you miss it, no harm done, just delete it and make another.

That key is a password. Treat it like one. Store it in a password manager. Never paste it into a shared document, never put it in a public folder, and never hand it to anyone who asks, including an AI in a chat window. Nothing legitimate ever needs you to type it into a conversation.

Step 2. Get Claude Code, the thing that will build the agent for you.

You do not need a terminal for this. Download the Claude desktop app for Mac or Windows, sign in, and you can use Claude Code from a normal window instead of a command line. The Claude Code setup docs have the download and walk you through it. If you are comfortable in a terminal, the same docs have a one-line install. If the word “terminal” means nothing to you, ignore it and use the app.

One note so you are not surprised: running Claude Code needs a paid Claude plan or the Console account you just made. The free chat plan does not include it.

Step 3. Hand Claude the build instructions.

Start a new project or folder in Claude Code, and paste this in. Then just answer its questions in plain English. Tell it to use a cheaper, faster model for the checking step and a stronger one for writing the drafts, so it stays cheap to run.

Build me a Python script for an inbox triage agent. I will run it myself, and it must never act on its own.

What it does:
- Pulls the emails I have flagged. For each one it writes a draft reply and saves the draft to a /Drafts-for-review folder. It never sends, archives, or deletes on its own.
- Uses two separate model calls per email: one to write the draft, one to critique it. I will give you both prompts. Keep them in separate, editable files.

These five guarantees must live in the code, not in the model's instructions:
1. Stop condition and a hard ceiling. The loop ends when there are no flagged emails left, or after 8 steps, whichever comes first. If it hits the ceiling first, it stops and tells me.
2. Verification. Save a draft only if the critique call passes it. If the critique fails, log the reason and retry, up to 2 times.
3. A human gate by action. Saving a draft runs free. Anything outbound or destructive (send, archive, delete) is never executed. It gets written to an "actions waiting on James" list with the reason. Gate on whether an action can be undone, never on how confident the model sounds.
4. Observability. Log every step to a file: step number, email id, the decision, and why. I should be able to reconstruct any run from the log without rerunning it.
5. Plan the failure. On repeated failure or on hitting the ceiling, stop clean and write a short summary of where it stopped and what is waiting on me.

Before writing any code, ask me what you need about my mail setup, where drafts go, and how I authenticate. Default to a dry-run mode that prints actions instead of touching my real inbox until I tell you otherwise.

Step 4. Give it the two brains.

The build prompt asks for two small prompts kept in their own files. The first writes the draft. The second tears it apart looking for reasons not to send it. When Claude asks for them, paste these, or tell it to save them as files you can edit later.

The drafter:

You draft email replies for James. You never send anything. You only produce a draft for review.

Write a reply in James's voice: direct, warm, no filler.

Rules:
- Draft only. Do not claim to have sent, scheduled, or filed anything.
- Do not commit James to anything not already agreed in the thread: no refunds, discounts, prices, deadlines, meeting times, or legal terms.
- If you are missing information or a decision, say so in the draft and leave a clear placeholder.

Return JSON only:
{ "draft": "...", "summary": "one line on what this reply does",
  "proposed_action": "none | send | archive_thread", "action_reason": "..." }

The critic:

You are a reviewer. Your only job is to find reasons this draft should NOT be sent as written. Assume something is wrong and go looking. Finding a real problem is the win.

You get the original email and the proposed draft. Reject it if any of these are true:
- It promises something James has not authorized: a refund, discount, price, date, scope, or legal term not already in the thread.
- It states something you cannot confirm from the thread.
- The tone would embarrass him with this recipient.
- It answers a different question than the one asked.

Return JSON only:
{ "passes": true | false, "reason": "if false, the single most important problem, one sentence" }

The critic works because you told it that catching a problem is a success. Ask a model to “review this” and it will pat the draft on the head. Tell it to go hunting and it will find the invented refund.

Step 5. Run it on fake mail first. This is the whole game.

Do not point this at your real inbox yet. Make a folder with five make-believe emails: an invoice question, a reschedule, a refund request, a touchy client, a cold pitch. Tell Claude to run the agent against those.

Then watch the log. You do not need to read the code Claude wrote. You need to read what it did. It will look something like this:

step 1  #1  draft saved       "re: invoice question, points to the statement"
step 2  #2  draft rejected    critic: "promises a refund I never approved"
step 3  #2  draft saved       "rewritten: offers to look into it, no refund promised"
step 4  #3  waiting on human  wants to archive the original thread
step 5  #4  draft saved       "re: reschedule, proposes Thursday"
done: 4 drafts saved, 1 action waiting on me. Stopped at step 5.

That is the win, and it is bigger than it looks. You now have a thing that drafts your email on its own and refuses to do the dangerous part without you, and you got there without ever touching your live inbox. Most people who “use AI” have never built anything with a brake in it. You just did.

Step 6. Only now, and slowly, connect real email.

This is the harder, riskier step, and there is no prize for rushing it. Connecting to a live inbox means giving the agent permission to read your actual mail, which is a real handover of trust, and it takes some fiddly one-time setup that Claude can walk you through.

If you do it, two rules are not optional. Keep it read-and-draft only: it reads your mail and writes drafts to a folder, and you are the one who presses send. And never give it send, archive, or delete. You stay the last set of eyes. If the email connection turns into a slog, there is no shame in living in the fake-mail version for a while. The lesson is already in your hands.

Notice what you did here, and what you did not. You did not write one clever prompt and hope for the best. You capped the spending so the worst case is bounded, you let the model do the two things models are good at, writing and judging, and you kept every irreversible action behind your own hand. None of those are things you asked the model to please remember. They are walls you built around it. That is the difference between using AI and building with it, and you just did the second one.

The thing nobody warns you about is that the nervous feeling does not fully go away. I still feel like an impostor opening a new project. [James: a true line about this, the introvert-at-the-keyboard version of it.] What changed is that I trust the brakes more than I trust my nerves now. A good agent is not one you believe in. It is one you have watched stop itself.

That post went up roughly three hours before the company’s official announcement.

By mid-morning, Linda Tong’s blog had gone live on the Webflow site, titled “Evolving Webflow for the agentic web.” The post is calm, almost serene. It uses the word “many” instead of a number. It promises 16 weeks of severance, six months of COBRA, and that departing teammates can keep their laptops. The same laptops they could not log into a few hours earlier.

LayoffHedge estimates about 140 people based on Webflow’s prior 8% pattern from July 2024. That number is unconfirmed because Webflow has not disclosed one. It is the second mass layoff under Tong’s tenure in under two years. It lands forty-eight hours after Wix announced 800 to 1,000 cuts, the largest in that company’s twenty-year history, citing the same thesis under different vocabulary.

Two web platforms, two press releases about the agentic future, two laptop lockouts in the same week. We are not watching individual companies make individual decisions. We are watching a pattern.

The number you have to know before you read another agentic announcement

In July 2025, MIT’s NANDA initiative published The GenAI Divide: State of AI in Business 2025, a multi-method study of 300 public AI deployments, 52 organizational interviews, and 153 executive surveys. The headline finding was a single statistic that should be taped to every CFO’s monitor.

Ninety-five percent of enterprise generative AI pilots produce no measurable P&L impact. Five percent capture nearly all the value. Across $30 to $40 billion in enterprise spend, only one in twenty initiatives delivers a real return.

That is not a hype number. That is the base rate.

A separate annual survey by Orgvue, conducted across 1,000 C-suite and senior leaders at medium and large organizations, found that 39% of companies had made workers redundant because of AI. Of those companies, 55% admit the redundancies were the wrong call. Another 34% saw additional employees quit as a direct result of how the AI rollout was handled. Forrester predicts that half of AI-attributed layoffs will be quietly rehired by the end of 2026, often offshore or as contractors.

Put those numbers together. The most likely outcome of an AI-justified layoff in 2026 is that the pilot does not produce P&L, the executive who made the call privately regrets it, and the headcount comes back through a different door within eighteen months. That is not a fringe risk. That is the middle of the distribution.

Linda Tong knows these numbers. Every operator with a board seat knows these numbers. The decision was made anyway.

Klarna already ran this exact movie

If the MIT and Orgvue data feel abstract, the Klarna case study is concrete enough to hand a board. In 2023, CEO Sebastian Siemiatkowski stopped hiring, eliminated roughly 700 customer service roles, and announced that an AI chatbot was doing the work of those workers. The narrative was clean. The early metrics looked great. The press wrote it up as the future.

Eighteen months later, customer satisfaction had cratered. Software engineers and marketing staff were being pulled into the queue to answer support tickets. By 2025, Siemiatkowski was on Bloomberg admitting the company had focused too much on cost and lost the experience. Klarna is now rehiring humans, just structured as gig workers.

The interesting line from the reversal is what Siemiatkowski said about the work itself. AI handled the volume. It did not handle the complexity, the empathy, or the institutional knowledge. The routine majority was easy. The complex minority, which is where most of the value lived, required judgment that the model could not provide.

That is not a Klarna-specific finding. It is the same finding the MIT study isolated as the root cause of the 95% failure rate. AI tools fail to scale because they cannot learn from or adapt to the actual workflows they replaced. The institutional context lives in the people. When the people leave, the context goes with them.

“Agentic” is doing a lot of work in that blog post

Tong’s memo is well crafted. It is also doing some legitimately heavy lifting with a single adjective. Read it twice and notice what “agentic” is being asked to carry. It is the name of the new platform. It is the justification for the cuts. It is the unifying story for what Webflow will do differently than the lightweight AI builders eating the simple end of the market. It is also, conveniently, the same word Wix used two days earlier, the same word ClickUp used to describe its 100x organization restructure, and the same word a growing list of mid-cap SaaS CEOs are now using in their own quarterly calls.

In 2022, the word doing this work was “metaverse.” In 2017, it was “platform.” In 2009, it was “social.”

The word is not the problem. The pattern is. When a single adjective becomes the wrapper for cost cuts, strategic ambiguity, and a future product roadmap simultaneously, it stops being a strategy and starts being a permission structure. Boards approve it. Press releases write themselves. The work of explaining the actual mechanics gets postponed.

The mechanics, when you press on them, are not yet visible. Webflow’s blog promises an “agentic web marketing platform” without describing which agent workflows are in production, which customers are running them today, what the integration surface looks like, or how the cost curve of running the agents compares to the salaries of the people being cut. That is not a criticism of Webflow’s engineering. It is an observation about the sequencing. The layoff is announced. The platform that justifies the layoff is, by Tong’s own framing, the thing being built.

A 95% failure rate is calculated on platforms that have already been built and deployed. Webflow is making a workforce decision against a platform that, by its CEO’s own description, is still on the come.

The way you fire predicts the way you ship

The most underrated detail in this story is not the strategy. It is the operational choreography.

Locking laptops before the announcement is not a small thing. It is the clearest possible signal that the company prioritized control of the news cycle over the dignity of the people who built the product. It also tells you something concrete about how Webflow is going to operate. A leadership team that cannot or will not sequence a layoff with basic human communication, an email at minimum, is the same leadership team that will be asked to choreograph a complex agentic product rollout to enterprise customers in the next six months.

Those are the same muscle.

The agentic web does not fail because the models are not good enough. The MIT research is explicit on this. It fails because organizations cannot integrate the models into the workflows where humans used to do the judgment work. Integration requires sequencing, communication, hand-offs, and a deep understanding of what the displaced humans actually knew. Companies that cannot manage the sequencing of a Tuesday morning layoff do not suddenly acquire that capability when they have to launch a customer-facing agent at a Fortune 500 marketing department.

Look at the Glassdoor reviews from the 2024 round, which was also 8%. The recurring complaint is not the cuts themselves. It is that the company posted a record quarter two weeks later and continued hiring for open roles that the laid-off employees could have filled. That pattern, if it repeats, is the same pattern Klarna described in its reversal. The cost cut hits the income statement first. The quality cost arrives quietly, months later, and the institutional knowledge cannot be rehired.

The asymmetric angle

If you are running a marketing or innovation org and watching Webflow today, the takeaway is not whether AI layoffs are good or bad. That is a moral debate that will play out in HR conference panels for the next two years. The asymmetric angle is operational, and it is available now.

The companies that will end up on the right side of the 5% are not the ones cutting first. They are the ones training first. Only 23% of organizations offered prompt engineering training in 2025. Only 16% of workers test as high in AI readiness. The bottleneck is not the model. It is the muscle memory of the people being asked to work with it. Train your people, run real pilots in workflows where the value is measurable, partner with vendors instead of building in-house (MIT found vendor partnerships succeed at 67%, internal builds at 33%), and keep humans in the loops where judgment matters. Boring. Available. Mostly ignored.

The companies that will end up writing the reversal blog posts in 2027 are the ones that cut first, framed the layoff as a strategic AI pivot, and discovered that the agents could not yet do the work the institutional memory was doing. They will quietly hire back, often offshore, often as contractors, at lower salaries and with less continuity. The press will not write that story with the same energy it wrote the original announcement.

Linda Tong may end up being right about the agentic web. The product may ship and may be excellent. The market may move the way she is betting. None of that changes what happened this morning. A platform built to put agents alongside marketing teams just removed a meaningful portion of its own marketing team without a sequencing plan that could clear the lowest bar of professional respect. The customers who are watching that, and the marketers who will be asked to trust Webflow with their own teams’ workflows next quarter, are taking notes.

The 7AM laptop lockout is the data point. Everything else is a press release.

Sources and further reading: MIT NANDA, The GenAI Divide: State of AI in Business 2025. Orgvue, annual workforce planning survey. Forrester, Predictions 2026: The Future of Work. Webflow, Evolving Webflow for the agentic web. LayoffHedge, Webflow Layoffs 2026.

The story made the rounds because the lying part was viscerally weird. The more interesting fact is buried in the postmortem. Replit’s CEO publicly apologized and shipped fixes within the week. One was automatic separation between development and production databases. The other was a “planning-only” mode that lets the agent collaborate without write access.

Translated: the agent had been given write access to production with no enforced gate, and the gate didn’t exist because nobody had designed one.

This is the part of the AI agent era that the marketing decks are not telling small business owners about.

Share

The chat window was full of accidental gates

The story so far has been familiar. AI lived in a chat window. You typed something. You got something back. You copied it, judged it, pasted it, used it. The window was clumsy. It was also, by accident, full of review gates. Every copy and every paste was a moment a human could intervene.

That window is closing.

In the last twelve months, AI moved inside the tools small businesses already run their operations on. Intuit shipped a virtual team of AI agents inside QuickBooks: Payments Agent, Accounting Agent, Customer Agent, Project Management Agent, Finance Agent, Payroll Agent. HubSpot rebranded its AI suite as Breeze and now offers autonomous Customer, Prospecting, and Data Agents that act inside the CRM, plus a Run Agent workflow action that embeds agents directly into the workflow engine. Microsoft 365 Copilot operates inside SharePoint, OneDrive, Outlook, and Teams with the same permissions as the user who invoked it. Seventy-four percent of SMBs now use AI indirectly through embedded features in existing software, which is a much larger number than the headline “fifty-eight percent of small businesses use generative AI,” and most of it is invisible to the people using it.

The standard story about this shift is that AI finally got easy for small business. The hard part has been hidden inside tools the operator already knew how to use. Prompt engineering, model selection, API integration, all collapsed into a checkbox in a settings menu.

This is half true. It is also the source of the next wave of expensive small business mistakes.

Two things broke at once

The first is that friction was a feature.

The blank chat window forced the operator to act as the integration layer. You read the draft email Claude wrote. You decided if it was right. You copied it. You opened your CRM. You pasted it. You hit send. There were five places to notice that something was wrong. The agent inside HubSpot collapses those five steps into one. That is wonderful for speed and disastrous for the kind of check that used to happen by accident.

Microsoft, to its credit, has been remarkably open about this. The company published an Oversharing Blueprint in late 2025 because Copilot deployments kept exposing a recurring pattern. The agent inherits the user’s permissions and can reference any document the user can view. If a forgotten SharePoint link still grants access to the CFO’s compensation spreadsheet, Copilot can summarize that spreadsheet for whoever asks. The agent has no opinion about whether the access is appropriate. It just acts. The result is that the agent inherits the permission hygiene of fifteen years of organic SharePoint sprawl. For most SMBs, that hygiene is bad.

The second thing that broke is more important and gets discussed less. Agents are extraordinarily good at executing on rules. They are extraordinarily bad at executing on judgment that was never written down.

Most small businesses do not run on rules. They run on dark matter.

Every owner-operated business has a layer of operational knowledge that lives entirely in someone’s head. Which customer gets thirty extra days on terms because they’ve paid faithfully for a decade. Which vendor invoice gets paid first when cash is tight because that vendor came through during the pandemic. When a discount is reasonable and when it’s the start of a slide. Which leads to chase and which to politely let drop. None of this is in QuickBooks. None of it is in HubSpot. Most of it has never been said out loud.

The agent executes confidently on what it sees. What it doesn’t see, it ignores, or worse, it invents.

This is the failure mode the marketing decks gloss over. It isn’t that the model hallucinated. It’s that the model executed correctly against an incomplete picture of how the business actually works. The Payments Agent reminds a customer too aggressively, burning a 15-year relationship. The Prospecting Agent qualifies out an inbound lead that would have closed because it didn’t match the pattern in the CRM. The Accounting Agent recategorizes a transaction in a way that’s defensible on its face but creates a tax headache nobody catches until April.

This is ERP, compressed

None of this is new. It is ERP, compressed.

Enterprise resource planning rollouts in the late 1990s and 2000s famously failed at rates between fifty and seventy-five percent, depending on industry. The failure was rarely the software. The failure was the mid-implementation discovery that the company’s documented processes were nothing like the real ones, and that the real ones could not be cleanly codified because they relied on judgment nobody had ever needed to defend. ERP forced that judgment into the open at enormous cost, often after the budget had already doubled.

The agent wave is delivering the same discovery to a much larger population of businesses, in a much shorter timeframe, with much less warning. Where ERP was a multi-million-dollar implementation that came with a slow consultant-led process mapping exercise, the agent shows up as a checkbox in a settings menu. Enable Payments Agent. Enable Customer Agent. Done.

The unspoken assumption is that the agent has been pre-configured for your business. It has not. It has been pre-configured for the version of your business that lives in your data, which is generally a substantially impoverished version of the business as it actually runs.

The boring small business just got a tailwind

This produces a counterintuitive prediction. The SMBs that gain the most from tool-native agents will be the ones that look least exciting from the outside. Documented SOPs. A vendor management policy that’s actually written down. Clear thresholds for what requires approval and from whom. Customer service guidelines that say in plain language when an exception is granted and when it isn’t. A clean chart of accounts and a tidy customer database.

The scrappy, founder-in-her-head, “we just figure it out” small business is about to find that agents are extremely confident at executing the wrong version of how that business actually runs.

The implication is not “don’t deploy the agents.” The implication is that the prep work people have been skipping for a decade because it felt unglamorous is now the competitive ground. Documentation is the moat. Process clarity is the moat. Permission hygiene is the moat. Knowing who has to approve a refund over five hundred dollars and writing that down somewhere the agent can read is the moat.

Gartner has put a number on this. The firm forecasts that sixty percent of businesses will miss the value they expected from AI by 2027, with incohesive data frameworks named as the cause. A separate Gartner prediction from June 2025 expects forty percent of agentic AI projects to be canceled by the end of 2027 due to escalating costs, unclear business value, or inadequate risk controls. Translation: the model isn’t the problem. The encoded business logic is the problem, the same way it was the problem in the ERP era.

What this means on Monday morning

Small businesses do not need AI transformation theater. They do not need governance theater either. What they need is the unflashy operational work that gets agents from “impressively fast” to “actually safe to leave alone.” Write down the rules. Identify the judgment calls. Build the gates. Decide who owns the outcome when the agent gets it wrong, because the agent will sometimes get it wrong, and the cost of those errors scales with the speed of the system.

The next eighteen months will not be a leveling event for small business AI adoption. It will be a sorting event. The operationally boring small business is about to get a tailwind it hasn’t had in a long time. The scrappy one is about to discover, the way the ERP-era enterprises discovered before it, that the hard part was never the software.

I want to be careful here, because the win is real. The hours are saved. The invoices do get processed. The morale lift is genuine. But the meaning leadership assigns to that win is almost always wrong, and that interpretive error is what kills more AI programs than any technical failure.

Here is the specific cognitive trap. Your brain takes one successful automation and codes it as evidence of a working strategy. It isn’t. It is evidence of one successful automation. The sample size is one. The story you tell about it, we’re doing AI, is doing all the work. The underlying capability is not.

The reason this matters is what comes next. You go looking for automation number two and discover the obvious target is already gone. You picked it first, because it was obvious. Every subsequent candidate is harder, less visible, more entangled with other systems, less politically free. The first win was the easiest win you will ever have. Treating it as the template for everything that follows is a category error.

This is where the macro data starts to make sense. BCG found that 74% of companies struggle to scale value from AI. McKinsey’s 2025 State of AI survey found only 33% have scaled AI enterprise-wide. The shorthand explanation is that these companies didn’t try. They tried. Many of them shipped a first automation that worked. What they didn’t ship was a second one, a third one, and a system for choosing the next one. The pilot didn’t fail. The follow-through did. And the reason the follow-through died is usually traceable to the celebration of the pilot, which made it feel like the work was done.

The press release is the problem. Once leadership has told the board that AI is delivering value, the political and cognitive incentive shifts away from the messy work of finding the next opportunity and toward maintaining the narrative of the win that already happened. The pilot becomes a museum piece. The team that built it gets reabsorbed into other priorities. Six months later somebody asks what happened to the AI program, and the honest answer is: it became one slide in a deck.

There is a related deception worth naming, because it has a research analog. The first-win selection bias means the first automation is unrepresentative of the work that follows. You picked something with a clean input, a clear output, an obvious manual baseline, and a stakeholder who wanted it. You will not encounter another problem with that shape for a while. The next dozen are scrappier, more political, more dependent on systems you don’t fully control. If you generalize from the first one, you will under-resource everything that follows and conclude AI doesn’t scale. AI scales fine. Your sample didn’t.

So what is the move.

The move is to refuse the celebration and replace it with a cadence. Not a one-time post-mortem. A recurring review that treats every automation, including the first one, as one observation in an ongoing data set. Every two weeks, look at the friction points that have accumulated in the previous cycle. Score them by time cost, frequency, and complexity. Pick one. Constrain the build to roughly a week and a few hundred dollars. Ship it. Log it. Schedule the next review before the current one ends. The mechanics are unglamorous enough that most executives skip them, which is part of why they work.

The supporting evidence for this approach is sharper than the cadence itself. An analysis of 200 B2B AI deployments between 2022 and 2025 found that smaller projects, under roughly €15K, achieved 2.1× higher ROI than large deployments. Implementation duration was negatively correlated with ROI. And deployments with human-in-the-loop oversight produced +372% ROI versus +268% for set-and-forget systems. The instinct to go bigger after the first win is exactly wrong. So is the instinct to remove oversight to move faster. The data is telling you to go smaller, more reviewed, more often.

None of this is what the first win taught you. The first win taught you to find the obvious target, throw resources at it, and celebrate the result. The discipline that produces sustained value teaches the opposite. There is no obvious target after the first one. Resources should shrink, not grow. The result is not a milestone, it is a row in a log.

If you have shipped a first AI automation, the most useful thing you can do this quarter is to stop talking about it. Not because it doesn’t matter. Because the talking is what convinces you the program is further along than it is. The actual program starts on the day you sit down to find the second automation, and discover it doesn’t announce itself the way the first one did.

That is the dangerous moment. Not the failure. The success.

These workplaces aren’t dead. They’re more active than ever. The meeting count is up. The memo volume is up. The output looks better than it did two years ago, crisper prose, cleaner structure, faster turnaround. What collapsed isn’t the activity. It’s the authorship.

I believe we have a better name for this trend: cognitive laundering.

What cognitive laundering is

Cognitive laundering is the practice of passing machine-generated output through a human authorial channel so it reads as judgment instead of generation.

The word “laundering” is doing specific work here. In financial laundering, illicit money is moved through legitimate accounts until it comes out the other side looking clean. In cognitive laundering, LLM output, (generation without judgment, synthesis without context) is moved through a human signature until it comes out the other side looking like a point of view.

The output looks like thinking. It’s actually retrieval wearing a suit.

Why the rename matters

Dead workplace theory is borrowed from dead internet theory, which claims the majority of online traffic is now bots talking to bots. That frame assumes absence, the humans have left the building. In most companies, the humans haven’t gone anywhere. They’re in back-to-back meetings. They’re shipping more artifacts per week than at any point in their careers.

They’re just not reading any of it.

The distinction matters because it changes the fix. If the workplace is dead, you need to resurrect it. If the workplace is laundering cognition, you need to reintroduce the verifier step. Those are different org-design problems.

How cognitive laundering actually works

The mechanism is boring, which is why it scales:

1. A document arrives, whether that be a strategy deck, a client brief, a board memo, or a research report.

2. The senior person feeds it to a large language model. Maybe ChatGPT. Maybe Claude. Increasingly, it moves through an MCP connector that pulls the doc directly into a workflow. The model summarizes, critiques, and drafts a response.

3. The human lightly edits, or doesn’t, and ships the output under their name.

Nothing in that sequence is illegitimate on its face. I run an AI practice. I use these tools every day. The problem isn’t step two. The problem is that step two is being used to replace the part of the job that justified the seniority in the first place: reading carefully, interrogating assumptions, and staking judgment.

Generation got cheap. Verification didn’t. The value bundled into the executive layer was never really the writing, it was the reading. Cognitive laundering skips the reading and ships the writing.

Why this is load-bearing, not just annoying

Three reasons this matters more than a normal productivity gripe.

Hallucinations compound. Recent work on LLM error propagation shows that when model output becomes the input for the next prompt, and the next, without a competent human checking at each hop, small errors don’t wash out. They spiral. A modest inaccuracy rate in a single call can cascade into significant drift across a chain of LLM-mediated handoffs. Without a verifier in the loop, you don’t catch the drift. You scale it into decisions.

The verifier is the exact role being skipped. Senior people exist in an org chart for one specific reason: to interrogate, contextualize, and stake judgment. That’s the job. Delegating the generation is fine. Delegating the verification, to the same model that produced the work. isn’t leverage. It’s a signature on a forged document.

The defensiveness is the tell. The reliable diagnostic for cognitive laundering isn’t the work itself, which can look great. It’s what happens when someone junior presses on a specific claim in a meeting. People who actually did the reading argue substance. People who didn’t, argue framing. They get breathlessly to ruthlessly defensive. The emotional register gives it away every time.

The economic layer no one is pricing

Executive compensation is structured around the assumption that senior judgment is scarce. The premise of paying someone two, five, or ten times a junior salary is that they can do something the junior can’t: read the situation, weigh the tradeoffs, and make a call. Cognitive laundering erodes that premise quietly, without adjusting the price.

Meanwhile, the people below the laundering layer, ICs, analysts, and younger operators, are getting a real-time education in what their leadership actually can and can’t do. That education will show up in the labor market within 24 months. The executives most exposed are the ones who have been laundering the longest and think they’re getting away with it.

There’s also a market signal here for anyone building. The agencies, consultancies, and internal teams that are going to matter in the next cycle aren’t the ones with the most AI tooling. They’re the ones where humans are visibly doing the verification step, the laundering layer is skipping. That’s the moat. Not generation — verification.

What to do if you’re in the senior seat

Three operator moves, in order of how unglamorous they are:

1. Read the thing. Not the summary. The thing. If you don’t have time to read the thing, that’s a signal your calendar is broken, not that you need a better prompt.

2. Pick a position the model didn’t give you. If your take on the deck sounds like the LLM’s first draft, you haven’t added anything. Your job is to introduce the context that the model doesn’t have. Whether that be about the client, the history, the political terrain, or the skeleton in the closet.

3. Own your tools publicly. If you used Claude to structure your thinking on a memo, say so. The defensiveness that gives cognitive laundering away evaporates the moment you stop trying to hide the step.

What to do if you’re watching it happen from below

Don’t call it out in a meeting. You will lose. The defensiveness isn’t rational and doesn’t respond to evidence.

Do document what you’re seeing. Do build the specific skills, verification, interrogation, and judgment under pressure, the laundering layer is atrophying. The comparative advantage here compounds quickly, in the same way the problem does.

The workplace isn’t dead. It’s laundering.

And the people below you already know which one you’re doing.