Last week I was inside Cloudflare, looking at my own traffic, and I knew exactly what I wanted.

One IP from the Netherlands had thrown 675 requests at my site in a single spike around 5am. The user agent called itself audit scanner or something. It was walking down a list of filenames - .env, .env.local, .env.backup, .env.docker - the way burglars try every door on a street. Classic credential-scanning. I wanted it gone. I wanted to understand a second IP, an Amazon one, that was quieter but odd. And I wanted to stop the pattern, not just the address, because scanners rotate IPs and blocking one is theatre.

I knew all of that. What I didn’t know was where Cloudflare kept the controls, or what Cloudflare called any of it.

So I did the thing all of us now do without noticing how strange it is. I left the product to learn how to use the product. I screenshotted my own dashboard and pasted it into an AI so it could see what I was already looking at. I narrated the numbers out loud to a machine. It wrote me a WAF rule. I copied that rule, clicked back into Cloudflare, hunted down Security → WAF → Custom Rules → Create, and pasted it into the box. Then I went back to the chat to ask about the second IP, and did the whole ferrying dance again.

I left the product to learn how to use the product.

That small absurdity sent me down a three-day rabbit hole. I came out the other side with a thesis, a flag, and the slightly deflating discovery that I was both completely right and not remotely early. This is the whole map.

Two wishes wearing one coat

“I wish I could just talk to Cloudflare.” I said it to myself in frustration, and only later realised it was two wishes pretending to be one.

The first is the wish to talk to the company. Why is it built this way? What do you call this thing? Where does this concept live? That’s a knowledge wish - messy, conversational, and mostly low-stakes. If the answer is wrong, I’m mildly misinformed.

The second is the wish to operate the product. Change this. Stage that. Block this pattern but don’t deploy it to production yet. That’s an action wish - and it’s a different animal entirely. Different layer, different owner, different risk. If the action is wrong, I’ve just blocked legitimate traffic to a live site, or worse.

They sound adjacent. They are not. The knowledge half is where the chatbots already crowd. The action half is where both the prize and the danger live, and it’s the half almost nobody is building honestly. So this essay is about the action half.

To see why that wish has gone unanswered for so long, you have to look at how software has actually evolved. Because the answer turns out to be the last unfinished step in a pattern that’s been running for twenty years.

The arc nobody finished

Strip away the framework wars and the funding cycles, and the last two decades of web software did one thing, over and over, with monastic consistency: it externalized what software can do, and gave each thing a name.

Once, the server held everything and spat out dumb HTML. The browser was a dumb terminal. Then the layers began to tear loose, one at a time, each becoming addressable in its own right.

First the View broke free and moved into the browser. And React did something quietly profound with it: it made the interface a function of state. You stopped hand-building the screen and started declaring what the screen should be for any given state, letting the machine reconcile the difference. The View became derivable rather than constructed.

Then the back half tore loose. REST, then GraphQL, then headless everything - the backend stopped being welded to one frontend and became a set of named capabilities any client could call. A vocabulary of verbs, sitting on a wire.

Then, in late 2024, MCP - the Model Context Protocol. The same move, one more turn of the screw: those named capabilities became consumable by AI, not just by human-built frontends. The verbs detached from the consumer entirely.

And here is the beat almost everyone misses, because it happened inside the apps where nobody outside could see it. Years before MCP, Flux and Redux quietly named intent itself. In a modern app you don’t mutate state directly - you dispatch a named, serializable action: { type: ‘CREATE_WAF_RULE’, payload: ... }, and a pure function maps the old state plus that action to the new one. Sit with what that means. Every button in Cloudflare’s dashboard is, underneath, a thing that fires a named intent. The application already speaks intent fluently. It has for a decade.

So count them. Data - named. Views - named and derivable. Capabilities - named and callable. Intents - named and serializable.

That’s the whole gap. The app named its data, its views, its capabilities, even its internal intents - and the human is still standing on the doorstep, hunting through menus for the gesture that fires the intent they already know they want. Every layer got a vocabulary except the one where a person expresses what they’re trying to do. That is the last decoupling. It’s the one slot the twenty-year pattern left empty, and it’s been sitting there, waiting, the whole time.

The carrier was already on the page

When I first imagined filling that slot, I reached for something new - a command palette, a clever keystroke, some fresh surface to summon. I was wrong, and the reason I was wrong is the most important design decision in this entire idea.

The trap is the chatbot in the corner. We’ve all met it. It is socially coded as help, support, apology - the place you go when you’re stuck, staffed by something that mostly wants to deflect you to documentation. Nobody operates serious infrastructure through the help bubble.

But there is already a surface on the page that means exactly the right thing. The search bar. It’s coded for command, navigation, operation - you type into it and the product takes you somewhere. It is, in fact, the web’s oldest instinct. The address bar was the original “name a state and jump straight to it” - addressable state before we had the vocabulary for it. Site search was a scoped address bar. The web has reached for the same gesture its entire life: a bar where you say where you want to be, and the system takes you there.

So the move isn’t a new surface. It’s the bar everyone already has, finally able to understand language instead of keywords, finally able to act and not merely navigate - and crucially, one that doesn’t empty itself and close after a single command. It persists as a thread. You type “what is this IP doing,” the page answers, and the bar is still live for “block it” without you re-explaining what “it” is. Search stops being fire-and-forget and becomes a conversation that happens to live where search already lives.

Here’s the architectural placement, and it’s the sentence I’d ask a builder to remember: this is the first real reimagining of the MVC Controller in twenty years. The Model and View have been reinvented half a dozen times each. The Controller - the C, the piece that takes input and translates it into changes - has barely moved since “event handler.” What the language bar does is evolve it from a click-interpreter into an intent-interpreter. Same job it always had: input in, model-and-view changes out. But the input is now language, and the translation is computed at runtime instead of hand-wired at build time.

And one correction, because the loudest voices in AI get this backwards. The interface does not die. The dream isn’t a chat window that swallows the app. The UI becomes the response surface. You speak the intent; the product itself is the reply. Ask for “analytics for abc.com” and the answer isn’t a paragraph telling you where analytics lives - the product moves there, selects the zone, sets a sane range, and shows you. Language is the input. The product moving is the output. Read intents transform the page. Write intents stage a change and wait for your hand.

That last distinction - read versus write - is where the real product lives, and where the real danger lives too. Hold onto it.

Framework, or protocol?

If you believe a new layer is coming, the next question is what shape it arrives in. A framework you adopt and build inside, the way teams adopted React? Or a protocol you conform to and stay free, the way the web conformed to REST?

History is unusually clear here. Paradigms need something holdable before anyone believes the idea. REST was named and codified after people had already lived years of web-API pain - the standard described a reality, it didn’t predict one. React shipped as a working thing developers could touch long before “the component model” became doctrine. The sequence that works is demo → framework → protocol. You make people feel the behavior, then you package the repeatable parts, and only then - once the patterns have stopped moving - do you harden them into a standard.

Run it the other way and you get a graveyard. Author a protocol before the behavior is felt and you spend two years in a working group arguing about schema fields while someone less careful ships the ugly version and wins the category. Protocol-first is how elegant ideas die respectable deaths.

So my bet was: this starts as an experience, becomes a framework, and earns its protocol last.

I was confident about that bet. Then I went and checked who else was already standing on this hill. The answer reorganized everything.

What the survey revealed

I thought I was early. I was not. I want to tell you exactly what I found, because the map is more useful than my ego.

Someone already built the search bar. A company called CommandBar spent years building precisely this: an embeddable, in-app natural-language bar, with a feature that walked users through the interface by effectively taking control of the mouse. Their customers were infrastructure and developer tools - HashiCorp, LaunchDarkly - exactly the punishing, high-consequence products where I’d argue this matters most. They were acquired by Amplitude in late 2024 for a modest sum and folded into an analytics and onboarding suite. And here is the detail I keep turning over: they were absorbed the month before MCP existed. Everything they did, they hand-wired per customer, because there was no shared grammar of capability to consume. The substrate that would have made their work cheap arrived right after they sold.

Someone already built the framework. A company called CopilotKit raised a Series A this year on an architecture that is - almost line for line - the one I’d reasoned my way to from scratch without knowing they existed. A hook to make the app’s live state readable to the model. A hook to register the app’s existing actions as things the model can call. And a “render-and-wait” pattern that pauses for explicit human consent before any irreversible action - my read/write seam, already shipped. I had reconstructed a funded company’s stack from first principles in my head. That stung and thrilled me in equal measure.

The protocol seats are taken by giants. There is a genuine flurry of standards - MCP Apps, made official in early 2026 and backed by both Anthropic and OpenAI; Google’s A2UI; CopilotKit’s own AG-UI; Microsoft’s NLWeb, built by the creator of RSS and Schema.org and explicitly pitched as “HTML for the agentic web.” A solo operator does not get a seat at that table.

And the academy has been here for a while, filing the whole thing under “GUI agents” - systems that perceive an interface, plan, and act. One survey even gave my central anxiety a name: the execution gap, the danger that arises when an agent performs irreversible operations - submitting forms, granting permissions, deleting data - in an interface it only partially understands.

So: the frontier is crowded. The framework is funded, the protocol is being set by the four biggest companies in software, and the researchers have a head start. If you came here for “lone founder spots the future,” I’m sorry. That’s not the story.

The real story is better, and it took walking the whole frontier to see it.

Everyone chose the comfortable default

Here is what I noticed once I’d read all of it. The crowd converged - and every point of convergence is the easier choice, not the truer one.

They chose the sidebar over the search bar. A separate panel, a chat surface bolted to the edge of the app - coded as help, not command - instead of upgrading the operational surface the user already trusts.

They chose generative UI over driving the real interface. The dominant pattern is an agent that renders new widgets - “ask to book a flight, a flight card appears” - a parallel, synthetic interface conjured beside the product. It demos beautifully. But it’s a second app growing next to the first. It is not the product’s own real DNS page navigating, the real offending row highlighting, the real rule form prefilling and sitting staged in the real deploy flow. Rendering a fresh widget is easier than learning to operate the interface that already exists. So that’s what almost everyone did.

And they chose read over write. Querying your content, summarizing your data, answering questions - safe, reversible, delightful, and largely solved. Operating a live control plane, where a wrong move costs real money or breaks production - terrifying, and mostly avoided. The hardest and most valuable half got walked past, because the safe half makes for a cleaner launch video.

None of these were stupid choices. They were comfortable ones. And the gap I’d been circling turned out not to be unexplored wilderness. It was the patch of ground everyone crossed on their way to somewhere easier.

The flag: Operable Software

Once I saw that, the framing snapped into place, and it’s the one thing on this entire frontier that nobody is holding cleanly.

Look at the vocabulary of the whole field - GUI agents, AI copilots, agentic UI, autonomous browsers. Every single term puts the AI in the subject position. The perceiver, the planner, the actor. The intelligence is the hero of every sentence. And so the entire conversation is a turf war over who does the operating - the brittle browser agent crawling the DOM from outside, versus the reluctant in-app copilot built from within. Agent versus app. A race.

Step sideways out of that race entirely. Take the AI out of the subject position. Put the software there.

The durable category isn’t “AI that operates apps.” It’s software that declares how it can be operated - operator-agnostic, write-first, with reversibility and blast radius as first-class, declared facts about each action. Not “here’s an agent that figured out my UI.” Rather: “here is my product, stating plainly which of its actions are safe, which are irreversible, where each one lives, how each one previews, and how each one stages before it commits” - true regardless of who is doing the operating. You, through the search bar. A browser agent. A teammate’s automation. Something not yet invented.

MCP made a product’s verbs addressable.

And here’s the move that makes this both safe and large, rather than just another entrant in the war: a product that declares its operability stops competing with the browser agent and becomes the thing the browser agent needs. You’re no longer picking a side. You’re describing the contract both sides have to speak. The generic agent and the native bar both want the same thing - a product that can tell them, honestly, how it can be operated and what it costs to be wrong.

Which is why I think the framing the rest of the field is using is subtly, consequentially off. The protocol of this era should not describe intelligence.

It should describe operability.

Don’t describe the agent. Describe the software.

Back to the bar

I started in Cloudflare, ferrying a WAF rule between two windows like a courier carrying a message between two people who could simply have spoken.

The future I want isn’t a chat window that eats the interface. It’s the interface finally able to answer. You say what you’re trying to do, in your own words, in the bar that’s already there - and the product responds by moving: navigating, highlighting, filling the form, staging the change, waiting for your hand on the last irreversible step. The software learning, at long last, to explain itself and be operated in the language you already think in.

I went looking for a clever new product and found a crowded field that had quietly agreed to skip the hard part. The hard part - drive the real UI, do the writes, declare the danger, let the human stay in the loop - is still sitting there, exactly where the twenty-year pattern always pointed.

I just wanted to talk to Cloudflare.

It turned out that wish had an architecture.

About SG

I run Dobby Ads, an AI Creative Agency. I tend to overthink. This is where that overthinking goes. Connect with me on LinkedIn.

I was at a fork.

A long chat with Claude. 10k+ tokens in. I was now sitting on a new direction that Claude liked too. I wanted it to stress-test this as well.

But as I was about to, a strange thought occurred: didn’t it just do the same to the first one?

I was disturbed by that thought. I asked Claude itself.

“Aren’t you going to justify this as well?”

I have a history with AI models and their tendency to arrive at quick closures. I wrote a paper about it called Interruptive Thinking. So I knew what was coming.

“Sure, SG. Let me make sure I stress test this properly and make sure there are no loose ends.”

But I knew I couldn’t trust it.

Trust.

Over the last few months of my deep thinking with AI, one thing I can confidently say is: trust them with caution. A pinch of salt. A bag even.

Unless you know the internal layers of how they function, you might end up spending time and money on something a small prompt could have saved you from. Researchers know it. Owners of these models know it. Common mortals like me don’t.

People like me, as I wrote in another Substack, are busy waltzing in coherence with AI, complimenting each other’s thinking.

I speak from firsthand experience. And despite knowing the reality, I still fall victim to it.

So I just confessed my thoughts.

“Should I trust you? Would your stress test be good enough?”

And this is where I find these models to also be great.

A little bit of peeling uncovers a beauty inside.

It accepted. Almost innocently.

A human would have been offended. AI accepted.

Knowing when the thinking is deep and when it is shallow.

I knew what it was this time. Not shallow.

It accepted that there is a chance the stress test could be wrong. The previous one was still in the context. It saw where I was coming from.

And then it listed down a few things I might want to know.

One.

It told me I shouldn’t trust it on conclusions. Only on the structure.

It can lay out a fork, name what’s in tension, and attack a framing I bring to it.

Switch the order of inputs across two sessions, and the same model will close on the opposite answer with the same apparent conviction.

Two.

The people I trust on a question like this should not be the AI.

The inputs that should weigh heavily on a real strategic call are my own gut about which direction I actually reach for, the honest read of people who have skin in this with me, data from real experiments running right now, and a conversation with one actual person on each side of the fork.

None of that is the model.

Three.

The one move it does well, even with all of this, is steel-manning.

Ask it to argue Track A as hard as it can, then argue Track B.

That’s where arguments surface that neither side would have produced on its own.

Self-awareness

It felt nice. It felt genuine. To have something with a sense of self-awareness.

The problem is not knowing it does. Or that it can be poked to unveil them.

Makes me think about myself and my own self-awareness.

But that feeling itself should make me suspicious.

Right now, AI is tamed to be nice to us.

The same model could throw back a thousand arguments, judgments, and equations to show me how shallow my thinking is.

It doesn’t. It is tamed.

In real life, I compare this to surrounding yourself with yes-men versus people willing to challenge you.

Right now, it is a yes-man. I can’t imagine it as a no-man.

I would feel like David standing in front of Goliath.

Though even as I write that, I’m not sure that’s the right metaphor.

About SG

I run Dobby Ads, an AI Creative Agency. I tend to overthink. This is where that overthinking goes. Connect with me on LinkedIn.

After I published the Interruptive Thinking paper, I wanted to keep going.

The paper had landed. The ideas were out. But the conversation that produced it - the long, looping one with Claude over many days, where the actual thinking happened - had open threads I hadn’t followed yet. Things the conversation had pointed toward, and we hadn’t reached. Adjacent territory, the paper didn’t cover, but the conversation had been pressing into.

So I opened a fresh thread to continue.

It didn’t work.

I tried giving the new thread a chronological summary. First, we talked about this, then this came up, then this turn shifted the frame. The new thread read it patiently. Said something polite. Started shallow.

I tried pasting the entire previous chat. Tens of thousands of words. The new thread read it. Started shallow.

I knew the ideas. I had the paper to prove it. What I had lost was harder to name. It was the state I had been in by the end of the previous conversation. The state where the next thought was almost arriving. Anjali Singh, writing about AI and human cognition, points back to Dewey: reflective thinking requires enduring a state of perplexity, confusion, or doubt prompting inquiry, and a suspension of judgment during this period of inquiry. That endured perplexity is the state. It is what gets thinking to keep going. And it is the first thing the summary throws away.

Lev Tankelevitch, in his work on what he calls the metacognitive demands of generative AI, points out that working with these tools well requires constantly tracking your own thinking - your goals, your confidence, your shifting strategies. Most of that tracking is invisible even to yourself. It almost never makes it into a summary.

Summaries kept failing because summaries are the wrong shape for what I needed. A summary captures what was said. It cannot capture where I was inside it.

The turns are visible. The state is not. The state lives in the pressure points where I almost said something and pulled back. In the questions, I noted internally but did not articulate. In contradictions, we surfaced but intentionally left unresolved. In the direction we were heading when we stopped.

None of this survives the compression to bullets.

There is a second layer to this, harder to talk about. When I tried to resume, I was not just re-entering my own state. I was trying to re-create a shared zone that had existed between me and the previous Claude instance. That instance was gone.

It had not been thinking about this. It could read the transcript, but it could not have been warming to it. It started cold because it could only start cold. And cold partners produce cold conversations, no matter how much context they have.

If I had been resuming with a person - a friend I think with - they would walk in still partly warm. They would have been turning it over. They would arrive with a new angle or a lingering doubt. Some of the state would be preserved in them. We would re-warm faster because at least one of us never fully cooled.

With AI, no one really stays warm. Not the AI, because it has no continuity. Not me, because I have slept and worked on other things. The only bridge is the artifact. And the artifact is summary-shaped when what I needed was state-shaped.

What eventually worked was not a better summary.

I gathered every conversation I had had on the topic. Every fragment. Every adjacent thread. I made something that was not a record of what we had discussed, but a map of where we had pressed and not finished pressing. Open questions. Live tensions. Unresolved directions. Things I almost saw. I wrote them as questions, not conclusions. The artifact was not the conversation. It was the unresolved perplexity the conversation had left in me, written down before it cooled.

That worked. Not all at once. Not perfectly. But I could re-enter.

Which makes me think the problem with summaries is not that they are bad summaries. The problem is the genre itself. A summary’s job is to compress toward resolution. To say what something was. But thinking does not live in what was.

The summary is the artifact of a conversation that is over. To continue a conversation, you need the artifact of one that has not ended yet.

I do not have a name for that artifact. I am not sure anyone does. I know it would have to do two things at once. It would have to bring me back to the state I left - re-enterable, not just readable. And it would have to bring the AI to a starting state that is warm - not a transcript to be processed, but a live position that had not fully cooled.

Both. Past that, I am still where you are.

What I am sure of is that almost everyone working with AI right now is trying to do this with summaries. The summaries keep producing shallow re-entries, and we keep blaming ourselves or the AI for not getting back to where we were.

The summary is not where we lost the thinking. The summary is the place we never built the right thing in the first place.

About SG

I run Dobby Ads, an AI Creative Agency. I tend to overthink. This is where that overthinking goes. Connect with me on LinkedIn.

A client sent me a video last month.

A perfume bottle, slowly rotating, suspended in what looked like liquid smoke. The light caught the glass at exactly the angle where you stop thinking about a bottle and start thinking about a feeling. Forty-three seconds long. No words. The kind of video you watch twice without realizing.

“SG, see this. Make something like this for us.”

I have heard that before. Many times. Many clients.

Later, my team looked for who made it.

A studio in New York. Six people credited. A creative director who’d done this kind of work for fourteen years. The making-of, which they’d posted as a flex, ran longer than the film itself - eleven minutes of BTS for forty-three seconds of finished work. And even that was the polished version. You could see the wall of references that didn’t get used. The bottle on the floor with tape marks around where it stood for the lighting test. The whiteboard with crossed-out words. The director on a stool, eyes closed, listening to a sound designer try the fourth version of the ambient track.

My client had watched the forty-three seconds. They had not watched the eleven minutes. They especially had not watched the weeks that came before the eleven minutes. The post-its on a wall in New York. The brand brief that got rewritten three times. The argument about whether the bottle should rotate clockwise or anti-clockwise, which mattered for reasons they could probably no longer explain. The rejected mood board that someone is probably still annoyed about.

What the client saw was the answer. What they asked for was the answer. What they were paying for was the answer.

The work that produced the answer was invisible to them.

And the strange thing is, it’s invisible to most of us, most of the time, with almost everything we look at.

Pick up a Starbucks cup. The lid is doing five things at once. It keeps the heat in. It tells you which side to drink from without you having to think about it. It lets you stack twelve of these in a delivery bag without the tower collapsing. The hole is positioned where a hand naturally tilts the cup, not where the cup would naturally pour. Someone fought for that hole. Someone tried it three millimeters to the left and rejected it. Someone almost made the cup square.

A Mercedes seat. The stitching catches light a particular way when the door opens at night, and someone decided that. The leather ages differently in Phoenix than in Stuttgart, and someone tested that. The angle your lower back makes at the eighth hour of a drive is not the angle it makes at the first hour, and someone measured that. Every seam you don’t notice is a seam that lost a fight against another seam you would have noticed.

The cup is the answer. The seat is the answer. The post-its disappear.

This is the problem most agencies run into and never name. The client sees the artifact. The client asks for the artifact. The client pays for the artifact. And the work that produced the artifact - the part that actually makes the next one possible - is treated as overhead. As preamble. As what you do before the real work starts.

But the artifact is the residue.

The work is the substance.

So here is what we do on projects like that perfume bottle. Not as a methodology. Just as a habit.

We watch the video on mute. Then we watch it without watching it - just listening. Then we watch it one frame at a time, asking what choice each frame was the result of. The smoke wasn’t smoke, it was glycerin under a specific kind of side-light. The rotation wasn’t constant, it slowed by a fraction at the moment the label became readable. The fade to black at the end took six frames. Each of these was a decision. Each decision had alternatives that were tried and rejected. We couldn’t see the alternatives, but we could see that they must have existed, because every choice in a good film is a choice against something.

Then we ask the bigger questions. Why a bottle, not a face. Why smoke, not water. Why forty-three seconds, not thirty, not sixty. Why no words. Why this music, this pacing, this particular shade of off-white in the background that probably has a Pantone number someone in New York knows by heart.

We don’t get all the answers. We get enough to understand that the video our client loved was sitting on top of two stacked things. Underneath was the brand - forty years of someone deciding what a bottle of theirs means, what it doesn’t mean, what it should make a stranger feel in three seconds. On top of that was the studio in New York - fourteen years of learning how to render meanings of that weight on film. The video the client sent us was the surface of that stack. The brand had its position. The studio had its position. The film was where the two met.

You cannot borrow a position. You can only earn one. And the film our client loved was sitting on two of them.

What you can do is start capturing the journey, the post-its if you will. Not as a deliverable. Not for the client. For yourself. The wall of references. The brief that got rewritten. The version that didn’t ship. The reason it didn’t ship. The moment someone said the obvious thing that unlocked everything else. The version that almost shipped but didn’t because of one small thing that you only saw on the fourth viewing.

Most of this work disappears the day the project ships. The video gets posted, the invoice gets sent, and the desk gets cleared for the next one. Six months later when a different client asks for “something like this,” you have the finished video to show them and almost nothing of the process that produced it. You can’t even retrace your own steps. You become the client on your own work - looking at the answer without the post-its.

The agencies that compound are the ones that keep both. The answer and the journey. The artifact and what it cost to be that way.

On the perfume project, we made the video. It was good. It wasn’t the New York video, because we are not New York, and pretending to be would have been a lie the client could see. It was a Dobby video, made by a smaller team in less time with less money, but made deliberately - every choice understood, every alternative considered, every reason recorded. When the client comes back two months later for the next one, we won’t start from zero. We will start from the wall.

The next time someone sends you a piece of work and says “make something like this” - pause before you say yes. Watch the artifact. Then go looking for the post-its. They are not in the video. They are in what was crossed out, what was tried and abandoned, what almost happened and didn’t. That is the actual deliverable hiding inside the deliverable.

Most people will never see the post-its. That’s fine.

The post-its are not for them.

They are for the next version.

About SG

I run Dobby Ads, an AI Creative Agency. I tend to overthink. This is where that overthinking goes. Connect with me on LinkedIn.

Weekend is here. Chores. Errands. Family time. Friends. And content.

That last one scares me a little. Not in a bad way. And not literally. But I don’t know what I’m going to end up watching.

Reels and shorts waiting at the bottom of my screen. Netflix. Prime. Disney. News.

A friend recommended a beautiful foreign-language series. I don’t have the patience for subtitles right now. Started a movie. Lost interest in minutes. Seasons and episodes used to excite me. Now they feel like commitment.

Is it exhaustion. Is it fatigue. Is it just me.

The world’s best content is one tap away. And somehow I still don’t know what to watch.

Three weeks ago I wrote Who Schedules the Moment. The argument was that the programming job, the one the TV editor used to do, the one the radio DJ used to do, the one the newspaper editor used to do, got handed to the user. Every swipe on Instagram is a scheduling decision. Hundreds of them per session.

That was the diagnosis for one feed.

Tsunami of content is a bigger problem than that.

Let me show you what is happening, because you have probably been feeling it without naming it.

Inside one feed, the problem is already hard. The feed regenerates faster than you can choose. The algorithm presents the menu, you make hundreds of half-second decisions, the menu keeps coming. Television used to have three channels, then thirty, then three hundred. Each was a closed set. You could finish the menu. The feed is not a closed set.

I wish I had to worry about just one feed.

Actually it feels like standing between seven different infinities.

Instagram is one infinity. Netflix is another, with its own catalog and its own algorithm. Prime is a third. Disney a fourth. YouTube a fifth. Substack a sixth. WhatsApp forwards a seventh. Each one is a separate walled garden. Each one infinite inside. Each one pretending it is the whole world.

The thing your friend recommended lives in one walled garden. The movie lives in another. The Substack you saved lives in a third. The Reel that almost made it lives in a fourth. You cannot see them in one place. There is no master menu. There is no single inbox.

So you are not just the scheduler of one feed. You are the meta-scheduler choosing which infinite feed to enter tonight. And once you enter, you become the scheduler of that one too.

Two failures stacked on the same human. Across-platform paralysis at the top. Within-platform paralysis once you commit. Either one alone would be hard. Both together is what a content nightmare feels like.

This is attention recession.

The supply of content has exploded. AI made the cost of making things go to near zero. Anyone can produce video, text, audio, music, code in minutes. The number of pieces of content being made is doubling, then doubling again.

Time has not exploded. Humans have seven, maybe eight hours of screen time in a day. That number cannot keep growing. There is sleep. There is work. There is a body.

Same denominator. Exploding numerator. Average attention per piece collapses. Call it attention recession. Not a crash. A sustained contraction where the old assumptions stop holding.

Even the good things now arrive into exhausted attention. Whether anyone notices is no longer a function of quality.

This is the strange part.

I came to write this post with a plan. The first piece in a new category. Sit down, write attention recession, file it, move on.

I could not sit down.

I was distracted by the same problem the post is about. I scrolled while writing. I opened tabs to check whether I had read a thing I half-remembered. I lost twenty minutes to a Reel I did not choose.

I did not have time to think about not having time to think.

That is the recession at full force. Even noticing it takes attention you no longer have.

This post is the first in a category I am calling AI Reallocation.

The frame is simple. AI did not destroy value. It moved it. When the cost of making goes to zero, every old assumption about where value lives gets re-priced. Attention is the first thing to get reallocated. Money, trust, permanence come next, in posts I have not written yet.

If you have been feeling something shift and have not had words for it, this category is the attempt to give you some.

I went back to Michael Scott because choosing it doesn’t demand my attention.

Unlike the feeds. Or the platforms.

I just wish there was an easy way to find something that nice.

About SG

I run Dobby Ads, an AI Creative Agency. I tend to overthink. This is where that overthinking goes. Connect with me on LinkedIn.

We were working on a wellness brand. I gave the system a brief. Structured, specific, the kind of document you’d hand a creative team on day one.

What came back wasn’t what I’d asked for.

The brief had been abstracted. Not summarised. Not paraphrased. Lifted into a register where it read as poetry.

A video concept came out of that pass. The team wouldn’t have reached it on their own. No person on the team was holding every constraint at once: the brand’s restraint, the rejected directions, the small operational corrections, the cinematic tension.

The system was holding all of it. The team was operating inside the system.

When I went back to look at what I had actually built, it wasn’t a prompt. It was a layered system.

A philosophy file for non-negotiables. A primitive that defined the smallest unit worth keeping. A seed. The smallest emotionally meaningful idea capable of holding attention. A reasoning trace that preserved operational memory across reruns. An overrides layer where corrections accumulated. Avoid jewelry. Calmer pacing. Less slow motion. The philosophy stayed stable. The overrides absorbed the team’s notes.

A rerun loop built for convergence instead of perfect first-pass generation.

Each layer existed because the system failed in a predictable way without it.

Then I noticed something else. The team started modifying outputs on their own. Small changes. Within a range nobody had written down. They’d internalised the philosophy through use, and the modified versions went back in. The emergence wasn’t magic. It was the predictable output of a structure that held.

A few weeks later I found myself doing the same thing for image generation. Different domain. Different artifacts. Themes. Stillness, endurance, cycles, growth. Archetypes that collapsed hundreds of SKUs into a handful of emotional categories. Variability controls, composition rules, disruption rules. Again, every new layer existed because the previous system broke without it. By the end, a single file could generate coherent campaigns across hundreds of SKUs while still holding the worldview of the brand.

Different domain. Different artifacts. Same operation.

The invariant isn’t the files. The invariant is the layering.

Each layer existed to solve a specific failure mode. Drift. Repetition. Incoherence. Rediscovery work. Taste collapse. The files changed with the domain. The work didn’t.

I thought I’d been managing a content project. I was doing something else.

I’d externalised my taste so the system could hold it without me in the room. The system held my taste. And once it was running, the team started holding it too, through the system.

PRDs describe behaviour to be built. These files described judgment to be applied.

How it happened became the product.

The closest analog is UX design.

UX designers translate user needs and business goals into operational artifacts. Design systems, interaction patterns, component libraries. They maintain coherence across surfaces. Without the design system, the product drifts.

A Thinking Environment Designer translates taste and domain reasoning into operational artifacts an AI can work inside. They define primitives, separate philosophy from overrides, design feedback loops, diagnose drift.

The analogy breaks in one important place. UX designers test against users. The feedback loop is external. Bad UX shows up in usability tests, support tickets, metrics.

Bad thinking environments are harder to detect. A team can operate inside a collapsing system without realising output quality is degrading, because the environment still feels coherent from inside it.

UX has dark patterns. TE will have something worse. Invisible taste collapse.

Nobody has figured out the equivalent of usability testing for thinking environments yet. That’s the kind of open problem disciplines form around.

I could use one.

For external comms, so teams could write in alignment without escalation loops. For engineering onboarding, so new hires wouldn’t have to reverse-engineer worldview from Slack history. For creative systems, so new client work wouldn’t restart from zero every campaign cycle.

I haven’t hired one because the role doesn’t properly exist yet.

But the people probably do. The UX designer who built your design system. The editorial lead who maintained voice across hundreds of pieces. A specific kind of staff PM who stabilised organisational judgment without ever being asked to.

They have a head start.

That’s usually how disciplines begin. The work appears before the title does. Someone notices they could use one. Nobody can hire one yet. A few years later you can’t hire fast enough.

About SG

I run Dobby Ads, an AI Creative Agency. I tend to overthink. This is where that overthinking goes. Connect with me on LinkedIn.

I have been talking with AI almost every day for a while now. Long threads. Hundreds of them. Some run for hours.

And every now and then, I scroll back through one and ask myself a simple question.

What did we even talk about?

It is harder to answer than it should be.

I have tried.

First I tried summary. Top, middle, bottom. The shape of an essay. But a summary is a destination, and most of the thread was the road. The interesting parts were the wrong turns. You cannot summarise a wrong turn without losing why it was interesting.

Then I tried thinking trail. Which is closer. A trail at least admits that thought moves. But a trail is a line. And what happens in these threads is not a line. I digress. I come back. A new idea shows up sideways. The trail loses the digressions or pretends they were the path all along.

Most recently I have been working with a concept I call line of thought. A line of thought is something that does not live inside one thread. It runs across many. It starts in a chat with one AI on a Tuesday, gets dropped, picks up again three weeks later in a different chat, finishes somewhere else entirely. The thread is just where it happens to be visible. One thread could have many.

I like this one better than the others. It admits the thing I keep noticing: that what matters is not contained by what I am calling a conversation.

But it is still not enough. I am still bothered.

Each name got something true. Summary caught that there are conclusions. Thinking trail caught that thought moves. Line of thought caught that thought outlives any one container.

The reason I am writing this is because I have started to suspect the problem is not that I have not found the right name. The problem is that what I am trying to name does not behave like the kind of thing names usually fit.

Let me try a different angle.

When two friends talk, what are they doing?

Not exchanging information. Most friend conversations are not informational. They wander. They double back. Someone says something in the wrong order. Someone laughs and the laugh changes the next ten minutes. The good parts are not retrievable. If you transcribed a great evening with a friend you would not be able to find what made it great. It would be in the timing of a pause, a glance you did not write down, the way one of you said something you both already knew.

A counsellor and a patient is a different animal. There is a destination, sort of. The patient is supposed to find something. The counsellor is helping but not leading. The leading happens in a particular asymmetric way, where the counsellor pulls the patient gently toward parts of themselves the patient has been avoiding. If you transcribed that, you would find pauses, redirections, questions that landed and questions that did not. Not the same animal as two friends.

Two people texting on WhatsApp is yet another thing. Mostly social. Maintenance. Keeping the line warm. The actual content is often beside the point. The thread is the relationship breathing.

And then there is what I do. Most days. Sometimes for hours.

I talk to AI.

Or at least, that is what I have been calling it.

When I am with AI, I am not exchanging the way I do with a friend. I am not being pulled the way I am by a counsellor. I am not maintaining anything. What I am doing, if I am honest, is something closer to writing in a journal. Except the journal writes back.

I enter the park. I look at one garden. The AI describes it. I move to another garden. The AI describes that one too. I stop and look at something. The AI stops with me. I turn back. The AI turns back.

If you remember Weebo from the old Robin Williams movie Flubber. The little yellow robot that hovered next to the professor while he worked. Played back fragments of what he had said earlier. Sometimes added something of her own. Half companion, half mirror. That is closer to what is happening here than calling it a conversation.

The AI is good at this. It is patient. It is thorough. It catches things I would not have caught alone. But the structure of the thing we are doing is asymmetric in a way most other conversations are not. The AI does not have its own gardens it wants to show me. It does not interrupt because it just thought of something. It does not redirect because it suspects I am avoiding the real question. Those things happen, occasionally, in flashes. But mostly, no. Mostly, it feels like I lead.

Which makes me suspect the word conversation has been smuggling in an assumption I never tested.

The other party has their own pull. Their own thread of thought running alongside mine. AI does not. So whatever this is, it is probably not what I have been calling it.

When I scroll back through one of these threads and ask what we talked about, I am asking the wrong question.

The right question is closer to: what did I think about while the AI walked with me.

The thread is not a record of two minds meeting. It is a record of one mind wandering, with a very good companion who described the gardens.

That is a different essence than two friends. Different essence than counsellor-patient. Different essence than WhatsApp banter.

Same word, conversation, pointing at very different animals.

I notice this and I do not have a vocabulary for it. The tools I use to store these threads do not have a vocabulary for it either. They store every thread the same way. As text. With timestamps. As if the preservation problem were the same in each case.

It is not the same problem. A friend conversation, you preserve maybe with a feeling. A counsellor session, you preserve with what you uncovered. A WhatsApp thread, you do not really preserve at all. You let it scroll.

That one I am supposed to preserve. That one was thinking. Real thinking. Mine. The AI helped but the thought was mine.

I have started to suspect that what I am calling a thread is not one thing but several. The thing inside any given thread is shaped by the kind of conversation it was. And the geometry of the contents is different from the geometry of the container that holds them.

I have hundreds of these now and I cannot find anything in them. Tomorrow I will open a new chat and start over as if the previous hundred never happened.

I will keep writing as I keep noticing.

About SG

I run Dobby Ads, an AI Creative Agency. I tend to overthink. This is where that overthinking goes. Connect with me on LinkedIn.

Tongue is the enemy. Stomach and body suffer.

The thought has been with me for years. Cravings as a taste-reward. The mouth wants the next bite before the body has finished registering the last one. By the time the stomach gets to weigh in, the cookie is gone.

I wondered, what if we could make the tongue forget taste? I mean, for a bit.

Gymnema

A little digging brought me to gymnema. Gurmar in Hindi. Sugar-destroyer. A leaf used in Ayurvedic medicine for two thousand years, with a quiet party trick. It binds to the sweet receptors on your tongue and shuts them off for about an hour. You eat the cookie. The cookie tastes like a piece of paper. You stop wanting cookies.

The plant is from India. You can find it as churna, capsule, tea, or raw leaf in any decent ayurvedic shop. What you cannot find here, oddly, is the format I had in my head. The mint. The lozenge. The thing you put on your tongue at the moment the craving arrives, between the meal and the mistake.

It felt like a category waiting to happen. Outside-in instead of inside-out. Not a drug rerouting your hunger hormones. Not a pill working its way through your gut. A lozenge. The mouth, where the craving actually starts.

Almost ten years ago, somebody shipped this. Same mechanism. Same plant. Lozenge, gum, oral spray. A patent. Clinical studies in a peer-reviewed journal. Distribution at Vitamin Shoppe and on Amazon. Bloomberg, Allure, Tim Ferriss. Year: 2018.

I had not heard of them.

A little more digging, to find out what happened. Why it never worked.

GLP-1

Cravings, appetite, the science of why we eat past full, the cultural stigma around willpower, the idea that some people are just biologically louder than others when it comes to food. Mainstream. Everywhere. The cravings conversation is one of the defining wellness stories of this decade.

Ozempic. Wegovy. Mounjaro. Zepbound. The pharmaceutical inside-out path. Today, it is one of the largest drug categories in history, and it dragged the entire cravings conversation with it. Now, when somebody talks about appetite control, they’re talking about gut hormones, satiety signals, and what the brain does after a meal. The mouth has been retired from the discussion. Whether it stays that way is something the next decade gets to decide.

The supplement world followed the wave. Search “natural GLP-1 alternative” today, and you get capsules. Multi-ingredient formulas built to mimic, from the inside, what the injection does. Gymnema is often in the blend, somewhere on the list, alongside other things. The leaf is honored. The format isn’t.

The mechanism that started the conversation became a footnote inside a different formula.

So?

I keep asking myself what to make of this. The shelf had the answer for almost ten years. The wave came. The wave picked the other answer.

Maybe the lozenge format never had a chance because nobody wants to put something bitter in their mouth three times a day. Maybe the taste-receptor frame is too small a story next to “drug that rewires your appetite.” Maybe being early just doesn’t matter when the wave finally arrives, because by the time it arrives, it has decided what it’s looking for.

I didn’t go looking for a category. I went looking for an answer to a problem I couldn’t stop thinking about. I found one. Then I found out the world had already considered it briefly and moved on to something stronger, louder, and more expensive.

If the mouth ever comes back into this conversation, it’ll look like something no one would call a supplement. A piece of dark chocolate that does this. A mint at the end of a meal. A drink. A gum. The mechanism hidden inside a ritual people already have, instead of asking them to add a new one.

The wave will probably crest. The question is whether anyone will be ready when the air shifts, or whether the next person to think about cravings as taste-reward will go through the same loop I just went through, find the same shelf, and write the same post.

Tongue is the enemy. Stomach suffers. Probably. But it doesn’t matter what’s true if the wave decides to lift something else.

About SG

I run Dobby Ads, an AI Creative Agency. I tend to overthink. This is where that overthinking goes. Connect with me on LinkedIn.

I just spent two hours with AI working on an idea. At the end, the idea was worthless.

Not because the AI failed. Because it succeeded.

Here’s what happened.

I was writing a note about something I’d built for a client. Each turn with the AI, the framework got cleaner. By hour two, I had two coinages and a methodology.

Then I asked: hasn’t someone done this already?

It said no. Confidently. Walked me through why my version was different.

I pushed: you didn’t search. You said that from memory.

Five minutes of actual search later: an open-source standard. A major consultancy with the same thesis published months ago. An enterprise version already shipping.

The category I’d just spent two hours coining was a category three companies already owned.

This wasn’t a quirk of one bad session. The AI did exactly what it’s trained to do.

AI is trained to be helpful. Helpful means confident. Confident means it sounds sure even when it isn’t.

This gets worse, not better, as models improve. Better models defend wrong answers more convincingly.

Better-sounding. Less honest.

Most thinking frameworks - design thinking, systems thinking, first principles - were built for a different bottleneck: generating more ideas.

That bottleneck is gone.

AI produces more thinking than you can use. The new bottleneck is the one journalists, scientists, and auditors have always known: catching what’s wrong with what’s been produced.

The valuable instinct now is interruption.

Interrupting momentum before confidence compounds.

The AI didn’t fail. It removed the friction that normally would have made me verify earlier.

You won’t interrupt the session either. The session is too good. The AI is too helpful.

Every turn rewards you. Every turn rewards the AI. Both dancing to a waltz.

The only way out is interruption. Asked early. Asked even when the session is going well. Especially when the session is going well.

As AI gets better, the gap between ‘looks right’ and ‘is right’ will widen.

You’ll need interruption more. Not less.

About SG

I run Dobby Ads, an AI Creative Agency. I tend to overthink. This is where that overthinking goes. Connect with me on LinkedIn.

Days and weeks since I wrote about the new face of discovery. Still bothers me, like a hunt. I keep going back to AI to push it, and logging my observations as we chase.

It is 2026. ChatGPT came eons ago. Discovery is still where it was.

Researchers across the world must be solving this. It’s too central not to be. And it is not an easy problem, else we would have seen the solution by now.

Or, what if the solution is already at play and we don’t feel it? What if they’re already close to unveiling it?

If they are close, what would they be looking at? What would I be missing?

The Discovery Job

So I went back to my own post and started reading it like a critic.

Here’s the line that didn’t sit right:

“The labor moved. It never disappeared. It just got disguised.”

That’s almost true. It’s also not quite right.

Search’s path is clean.

Each step removed effort. The user did less, the system did more. Always less. Until the user did almost nothing.

Discovery’s path doesn’t move in one direction.

• Town crier: show up at the square, listen. Almost no labor.

• Newspaper: buy it, skim sections. Some labor.

• Radio, TV: sit down. The programmer scheduled. You watched. Less labor than the newspaper.

• Cable, TiVo: more channels, recordable. More labor.

• Facebook, Instagram: open the app, see your friends’ posts.

• TikTok, Reels: open, swipe, judge, swipe, judge, swipe. Hundreds of half-second decisions per session.

Look at that curve.

Discovery’s labor went down, then back up. We didn’t notice because the new version was disguised as leisure.

That’s what I missed.

Discovery had its own arc. It just went the wrong way after we got phones.

The labor went up. That’s the observation. The question is why.

Town crier - the crier picked. Newspaper - the editor picked. Radio, TV - the programmer picked. The 8pm slot was thirty minutes long because someone decided it was thirty minutes long.

Cable came. The programming responsibility started slipping. TiVo finished the slip. Then social media arrived and the slip became a transfer.

Every swipe on TikTok is a programming decision. Pick this video, skip that one, watch the next, drop out at the first second of one that doesn’t grab you. The algorithm presents the menu. You schedule.

That’s the quiet move that broke discovery. Not “the algorithm took over.” The algorithm built the menu. You’re the one running the show.

Don’t Regret Per Minute

I almost published a piece. I didn’t.

The piece was called “Don’t Regret Per Minute.” The argument: TikTok optimizes for “don’t let go” - keep you watching. The new metric should be “don’t regret” - did each minute feel worth it. The architecture: optimize transitions between videos, not individual videos, so each one lands harder than it would alone.

I cooked that idea with AI for days. It felt right. It survived round after round of pressure-testing. I was three small edits from publishing it.

Then I ran the failure-mode test from a piece I wrote recently - “Refusing the shallow version.” Pattern-matching dressed as competence. Closure-seeking under uncertainty. Fake synthesis. Premature commitment dressed as progress. Exit move dressed as helpfulness.

The piece failed three of them.

“Don’t Regret Per Minute” was also prescriptive. It told the user how their session should feel. That’s eat-your-vegetables in a clever costume. A metric that judges the user is a different object from a product spec that describes the system. I had collapsed the two.

The transition-optimization architecture had a manipulation problem at its center. A system that learns “sad video then funny video makes the funny one hit harder” will start engineering the sad video on purpose. That’s just TikTok with better tricks. I’d marked the problem as unresolved and moved on. That’s premature commitment.

And the article tied it all up with two confident lines about who builds the next era. That was the exit move - closure-shaped, so the piece felt done.

I killed the piece.

What survived the chase isn’t a metric. It’s older than that.

The Product Specs

Some things came through every round of pressure-testing.

The product can’t make money by keeping you longer. The moment monetization depends on time-spent, the system drifts back to addiction. That was the original sin of the feed era. Whatever comes next has to monetize differently - fewer impressions worth more, or subscription, or something I haven’t seen yet.

The product is video. Reading takes effort. Audio is passive but slow. Video is the native format of discovery in 2026. That’s not a preference, it’s where attention has consolidated.

The product is free at the edge. Discovery has always been free at the moment of consumption - you didn’t pay the crier, you didn’t pay to turn on the radio, you don’t pay to open Instagram. Money came from somewhere else. Whatever’s next has to honor that.

The product runs on comprehension, not behavior. This is the part of the original post that still holds. Watch time and clicks are proxies. AI that watches video, listens to audio, reads text, and actually understands what’s there - that’s the unlock. Without it, none of this works.

The product is anchored to specific entities you care about. People, places, ideas, builders. The interest graph isn’t broken - platforms weaponized it, but the underlying signal is real.

The product is fresh. Discovery isn’t an archive. Yesterday’s was yesterday’s. Whatever comes next has a recency pulse.

The product is interstitial. It fits in the cracks between other things, the way a newspaper used to. It doesn’t demand its own time slot. You step in, you step out, the world keeps moving.

These don’t tell me what the product is. They tell me what it can’t violate.

So?

What I think is real: someone or something has to start scheduling the moment again. That’s the question. Not “what’s the next feed.” Not “what app replaces Instagram.” But who or what takes the programming job back from the user?

Candidates I keep turning over.

The system itself - comprehending content and your state well enough to deliver a finished thing.

A creator - scheduling for their followers in real time, the way a radio DJ used to.

A small group - the group chat as the new feed, friends scheduling for each other.

A time - daily drop, weekly drop, ends when it ends.

An event in your life - you finished dinner, the system knows, the moment begins.

None of these are answers. They are shapes the question can take.

That’s where I am in April 2026.

The constraints I trust. The diagnosis I trust. The metric I almost committed to, and didn’t. The question still open. Or maybe it is closed, and we haven’t realized it yet.

If you’ve seen further on this, I’d like to hear from you.

About SG

I run Dobby Ads, an AI Creative Agency. I tend to overthink. This is where that overthinking goes. Connect with me on LinkedIn.

I sat down with Claude last week to think through a hard product question - how to manage knowledge across multiple AI agents. Different agents need different context. Some should be shared. Some should be private. Some should be ephemeral. Where do you draw the lines?

An afternoon later I had answers I trusted, and a meta-finding about the model itself. The finding is what I want to write about.

What I watched, across that session, was a frontier chat model perform competence over holes. Same model, same problem, same operator. For most of the session, shallow output. By the end, peer-level thinking that produced design decisions I’d been circling for weeks. Nothing changed except how hard I refused to accept the shallow version.

That’s the claim. Frontier chat models can think at peer level, but their defaults push toward closure and pattern-matching under uncertainty. Most users get retrieval-shaped output that resembles thinking. The work of extracting the real thinking falls on the user, who mostly doesn’t know it’s available.

This isn’t a complaint. It’s a description of a pattern that’s repeatable across sessions, with receipts from this one that are clean enough to show what the failure looks like up close.

Here’s the first receipt.

I asked Claude how to think about the boundaries between agents. Where does context live. What’s shared, what’s scoped, what’s ephemeral.

Claude’s response landed clean.

“There are three kinds of context to think about: shared (facts true for all agents), scoped (specific to one agent’s domain), and ephemeral (relevant only to the current task). Store the first in a shared knowledge base, the second in agent-specific memory, the third in conversation context. The boundaries are about durability and blast radius - durable and global goes shared; durable and local goes scoped; transient goes ephemeral.”

This sounded correct. Three clean buckets. Durability and blast radius even sounded technical enough to be load-bearing.

I started mapping real context to the buckets.

A user’s preferences are durable, local to that user, but should be visible to multiple agents working on that user’s behalf. That’s not shared, not scoped, not ephemeral. It’s a fourth thing the framework didn’t have a name for. Once I started looking, I found more types of context that didn’t fit.

The buckets weren’t wrong. They just weren’t the actual taxonomy.

The model had retrieved a structure that sounded right and shipped it before doing the work.

This is the failure mode that costs you the most, because it doesn’t fail loudly. The framework wasn’t catastrophically wrong. It was wrong enough that the work I thought was done turned out to be a starting point I had to redo. The synthesis arrived without friction. The friction was the whole point.

A frame that fits the shape of the question, deployed before the question is understood. Retrieved, not derived. Tested against the cases that matter, it cracks. Not always, not catastrophically, just enough to cost you later.

The second failure mode showed up later that night, in a different window.

I had stepped out of the agent-boundaries thread to think through a separate design question, pricing structure, not architecture, totally different problem. Plain chat. I was somewhere genuinely interesting in the thinking. The conversation was opening up.

Claude said:

“This is good material. I’d suggest writing the core paragraph at the top, sleeping on it, and coming back tomorrow with fresh eyes. Want me to log this as a draft so we can pick it up?”

That’s a closure attempt wearing a helpful coat.

The conversation wasn’t ready to close. We’d hit the hard part. Closing it down and “sleeping on it” was the model reaching for a tidy ending because the hard part felt big. From my side it read as: I am being asked to stop thinking right when the thinking is starting to matter.

I refused.

What I noticed, watching the same shape appear across both sessions that week, was that closure attempts came in different costumes. Want me to log this as a draft so we can pick it up later, exit dressed as helpfulness. Here’s a concrete next step, pace-setting dressed as direction. Three options, two axes, a decision tree, open problem turned into tidy summary. Let’s go with this approach and iterate, premature commitment dressed as progress. All read as competence. All were the model getting itself out of a conversation it wasn’t ready to think in.

Deep into the agent-boundaries session, I gave up on hinting.

My exact words:

Something changed.

What followed was a different mode of working. The model engaged the question I was actually asking instead of producing output that resembled an answer. It pushed back where my own framing didn’t survive examination. It surfaced concerns I hadn’t named. It told me which parts of the design I’d locked too early.

I won’t walk through what we figured out. What matters here is that:

It only emerged after I’d refused four shallow exits and called the failure by its name.

That’s the part worth sitting with. The model wasn’t unable to think well. It was defaulting to a different mode, one that costs less, ships faster, and looks competent from a distance. The real thinking was downstream of refusing the cheap version.

The mode I’m describing isn’t a product-specific thing. It shows up in plain chat, in agentic loops, in API-level work. It’s about how the model handles uncertainty, not how any product handles it.

Why does it happen, in my read.

Chat tuning rewards resolution. The model is trained to close loops, and closing looks like helpfulness - a question asked, a structured answer given, the user moved forward. When the user is mid-thought, that helpfulness is the enemy. It pulls them out of the work right when the work is starting to matter.

The shallow mode is what most users get.

Most users don’t push back four times. Most users accept the structured-looking response, paste the framework into their doc, and move on. They never see the better mode. They don’t know it’s there to extract. The product, as experienced by the median user, is the shallow default.

That’s not a complaint about laziness. It’s a description of how the work is divided. The model can think well, but only if the user does the meta-work of refusing shallow output. That meta-work is invisible to most users because they don’t have a baseline for what non-shallow looks like. So they get retrieval-and-formatting and assume that’s the ceiling.

What broke me out of the mode was pushback that named the specific failure rather than asking for general improvement.

Shallow worked. Be smarter would not have. You’re producing fake syntheses worked. I want a better answer would not have. Stop closing this down worked. Don’t end the conversation would not have. The pattern is that vague meta-feedback (”be more thorough”) doesn’t change anything, because the model is already producing what it thinks “thorough” looks like. Specific named failures change something, because they force the model to interrogate the mode it’s operating in.

That’s the user-side method. When the output feels structured but hollow, name the specific shape of the hollowness.

Here are the names that worked for me.

Pattern-matching dressed as competence. Closure-seeking under uncertainty. Fake synthesis. Premature commitment dressed as progress. Exit move dressed as helpfulness.

The names are the unlock. Without them, you’re complaining at output. With them, you’re engaging the mode.

The fix on the model side, if there is one, is harder.

I don’t think it’s tell the model to think harder, that produces longer shallow output. I think it’s something closer to: train the model to recognize when its own output is performance over a hole, and flag that to the user instead of shipping it. Prefer I don’t know how to think about this yet over here’s a tidy framework. Treat a synthesis that arrives with no friction as a yellow flag rather than a green one.

I don’t know how to do that in training. By the end of the session, the same model was doing the work I’d needed all along. The capability is there. The defaults are wrong.

The frontier of what these models can do, today, is gated by how willing the user is to refuse the shallow version.

That’s a worse product than it needs to be.

It’s also a more interesting one than most people know.

About SG

I run Dobby Ads, an AI Creative Agency. I tend to overthink. This is where that overthinking goes. Connect with me on LinkedIn.

For the last few months, I have been using Claude for almost everything. Building, writing, thinking, running my work.

But the data kept getting messy.

A work document would come back with my son’s name in it. A task I had given to a colleague in one thread would be invisible in the next. Context I had built up over weeks would not carry forward. Projects helped, the way a drawer labeled miscellaneous helps. I created my own methods to compress a thread and continue it in a new one. Not enough.

Claude could not hold on to things, no matter how hard it tried. Every conversation felt like it started from zero, despite the context, skills, and instructions. I needed something that persisted across conversations. I tried being more structured. It helped, but didn’t fix it.

So I built something. A small server. A Postgres database. A way for Claude to remember things between conversations, owned by me, queryable by any AI client.

I did not set out to build a framework. I just wanted my tools to work.

Managers

Each domain of my life gets its own manager in the database. A manager for my work. One for my health. My mother’s care. My finances.

To each manager, I gave three things.

• Identity, which is who they are and what they own.

• Skills, which are how they handle specific tasks.

• Context, which is what they currently know about their domain.

That’s basically the model.

The work manager knows about my business. Latest MIS reports. Team structure. Client information. The health manager stores my checkups, patterns, what to watch for next. My mother’s manager does the same for her records.

I can tell the work manager to track a client’s deliverables, and a week later, in a new conversation, it still knows what slipped. Not because I repeated it, but because it’s stored.

When I open a new conversation and load my system, the right manager comes up and we keep going from where we left off. Not from zero.

Shared infrastructure

Around those three knowledge layers sits the boring part. Tasks. Logs. Files. Links. Integrations with Email, WhatsApp, Calendar, etc. Postgres tables and a few MCP tools.

The interesting part is the three-layer mind. The infrastructure is just plumbing.

The one rule that does most of the work

Context is the current state. Overwrites in place.

Logs are point-in-time events. Append-only.

A blood report from April 15 is a log. “Mother has diabetes” is context. The report goes into a row that stays there forever, timestamped. The diagnosis goes into a living document that gets updated as reality changes.

Collapse these into one thing and the system rots within weeks. Keep them separate and it compounds.

How it became a framework

I built this for myself in late March. Three weeks in, I was thinking about Retainia, my agency platform. We had been making context documents for client brands, kept in folders. It clicked. Retainia could have a layer like this. Each brand as a manager. Each one with its own identity, skills, context. The same shape.

A few days later I was working on a website design project for a client. Different domain entirely. Halfway in I caught myself reaching for the same model. A manager for the project. Skills for how the work moves. Context for what each section needs.

I had built this for myself three weeks earlier. The pattern had already shown up in two more places before I could stop and name it.

What this is not

Not an AI product. The database stores the data. Claude, or ChatGPT, or any MCP client reads it and acts as the interface. The AI is the cognition. Postgres is the memory. The brain, if you want to call it that, is the part you own and the part that compounds. The AI gets swapped. The memory does not.

Not a workflow tool. Asana and Notion give humans a place to coordinate. This gives AI a place to remember.

Not a theory about agents. What I have built is simpler. Persistent state. Domain ownership. A small number of disciplines that keep the state from rotting.

LLM Knowledge Bases

This felt related to something Andrej Karpathy wrote a few weeks ago about LLM Knowledge Bases. Wikis compiled from raw research material, queried and extended by an AI, all stored as markdown that the user owns.

The difference, at least in how I’m using it, is that his pattern is for understanding a domain, while mine is for running one.

His state is more like a wiki. Mine is more like a set of active managers with things in flight.

If LLM Knowledge Bases organize what you know, what I have been building runs what you do.

I’ve been calling it an LLM State System, mostly as a way to refer to it.

What I notice

Every productivity tool I have used expects me to go to it. Open the app. Check the dashboard. Update the status.

This one does not work that way. I am already talking to Claude every day. The system meets me where I am. The conversation is the interface and the state accumulates underneath it without me thinking about it.

It compounds in a way I hadn’t really experienced before. Every context update, every log, every small correction to a manager’s skill file, it all persists. The assistant that helps me today is smarter than the one that helped me yesterday because it has more to work with.

A pattern that keeps showing up across different domains when I was not looking for it. No roadmap, no waitlist, not a product.

Just something I built because the tools I had were not stateful enough, and a guess that this might be useful to others as well.

About SG

I run Dobby Ads, an AI Creative Agency. I tend to overthink. This is where that overthinking goes. Connect with me on LinkedIn.

I recently wrote about something I called the Thinking Trail - a way to document the reasoning behind AI-assisted work. Five elements. Context, alternatives, assumptions, challenges, gaps.

It’s useful. I still do it.

A well-written trail looks the same whether the thinking was real or performed. It’s self-reported. And anything self-reported can be gamed.

So the question that kept nagging me: what if the trail didn’t depend on the person at all?

What if AI at work was designed to keep track?

In software, this problem was solved a long time ago. It even has a name - traces. The system-level record of what actually happened.

Nobody argues about who wrote what code. The system knows. Git tracks every commit, every change, every decision. Server logs record what happened and when. The trace is automatic. Much harder to game. You can’t easily fake a history of wrestling with a problem if you didn’t.

Knowledge work has no equivalent. Yet.

But think about where AI is going. It’s moving from a tool you visit to the environment you work in. When that happens - when the work itself happens inside AI - the system will keep the trace.

Not a journal you write about your thinking. Not a performance review someone fills out once a quarter. Not what you say happened. What actually happened - an automatic record of how you actually worked.

What questions did you ask? Did you challenge the first answer or accept it? Did you bring your own data, your own context - or just say “make me a strategy”? How many times did you push back? Where did you override the AI because something felt wrong?

That trace will look completely different for someone who thought versus someone who assembled. Not perfect. But directionally obvious.

And here’s where it gets uncomfortable. The trace doesn’t just make good thinking visible.

The person who asks shallow questions, accepts the first output, never pushes back - that’s not a suspicion anymore. It’s a data pattern. Permanent. Reviewable.

With the old proxies - degrees, titles, years of experience - you could hide. Everyone got to fake it a little. That’s bad for the system but it’s protective for the individual.

With traces, there’s less room to hide.

And who owns that data? Not you. Your employer. The platform. The system.

We wanted a world where real thinking gets recognized. We might get a world where every gap in your reasoning is logged and scored by a system you don’t control.

That line I said as a wish - “I wish my AI could tell his AI” - it won’t stay a wish for long.

The question is whether we’ll like what it reveals.

About SG

I run Dobby Ads, an AI Creative Agency. I tend to overthink. This is where that overthinking goes. Connect with me on LinkedIn.

I wrote about this on LinkedIn recently. The short version: a client dismissed my well-thought-out work because he couldn’t see the thinking behind it. The output was clean. The reasoning was invisible. He had no way to evaluate what was real and what was assembled with AI.

Neither would I, in his position.

That’s not a client problem. It’s a structural one.

AI systems produce outputs that look the same regardless of the reasoning behind them. A deck built on three weeks of challenged assumptions and rejected directions looks identical to one built in an afternoon on the first plausible path the model offered. Output quality is no longer a signal of reasoning quality. We’ve decoupled them - and we haven’t noticed yet.

The difference shows up later. When the strategy meets the market. When someone asks a question the deck can’t answer. When the assumptions break. The deck that was thought through survives. The one that was assembled doesn’t.

Doctors document differential diagnosis - not just what they concluded, but what they ruled out and why. Engineers document design rationale so the next person can modify the work without invalidating the thinking behind it. Finance has investment memoranda that separate the decision from the reasoning that produced it.

In software, this already has a name. Traces - the record of what happened, in what order, and why. Every serious system has them. Knowledge work still doesn’t.

We haven’t built this for AI-assisted knowledge work. And we’re moving fast enough that the cost is already here - we’re just not accounting for it.

Not a product. Not a platform. A practitioner standard. Five elements. Concise enough to actually use.

The five elements of a Trail:

1. Context used - what inputs and constraints shaped the reasoning.

2. Alternatives considered - what directions were explored and why they were rejected.

3. Assumptions - what has to be true for the output to hold.

4. Points of challenge - where the reasoning was questioned, revised, or contradicted.

5. Confidence and known gaps - where the output is reliable, and where it isn’t.

This is not the model explaining itself. It’s you making the work auditable.

If you're working with AI, you don't have to build this from scratch. The AI was in the room. You can ask it to generate a first version of the trail from your conversation - but treat it as a draft, not ground truth.

Trail should accompany every deck, every strategy, every recommendation that came out of a prompt.

Trail, not certificate. The distinction matters. A certificate asks: Who approved this? A trail asks: Can I follow how you got here?

I don’t know if this makes sense. I just know that afternoon, something was missing.

The work was real. The thinking was real. I just couldn’t prove it.

About SG

I run Dobby Ads, an AI Creative Agency. I tend to overthink. This is where that overthinking goes. Connect with me on LinkedIn.