Something strange happened to me over the last year.

The models got dramatically better. And in the same window, I got more careful, not less, about where I let them lead.

That sounds like a contradiction. A tool improves, you lean on it harder. That is how every tool I have ever used has worked. A better camera, a faster compiler, a sharper knife. Capability goes up, caution goes down.

With AI it inverted. The better it got at sounding right, the more I had to watch for where sounding right and being right come apart.

It took me a while to see the pattern under that. When I finally did, it was simple enough to draw on one screen. I have started calling it the Reality Gradient.

It is not an entirely new concept. A lot of smart people are arriving at a version of it right now, mostly from the world of code. What I think is missing is where the idea actually bites hardest, which is nowhere near a compiler.

Here is the whole idea in one line.

Not how smart the model is. How fast the world pushes back.

Three zones

Think about the work you actually hand to AI. Sort it by one question: when the answer is wrong, how long until something outside your own head tells you so?

Reality-constrained work. Reality answers in seconds. You write SQL and it runs or it throws. You debug and the test passes or it fails. You transform a file and the rows reconcile or they do not. The ground is right there, and it does not care how confident the output sounded. This is where AI is not just useful but close to magic, because the cost of a wrong answer is a few seconds and a retry. Move fast. Let it run. Verify almost for free.

Reasoning-constrained work. Now reality goes quiet. Strategy. Architecture. A research synthesis. A long argument. Nothing crashes when the thinking is subtly off. The only thing that can catch the error is your own judgment, and your judgment is working against a strong headwind, because the output is fluent. It reads finished. It has the cadence and the structure and the confidence of something true. And fluency is the most expensive illusion in this whole stack, because it feels like understanding. You are no longer checking the work against the world. You are checking it against your own ability to notice what is missing, on a piece of writing engineered to feel complete.

Market-constrained work. Reality goes fully silent, and the only thing that can answer you is other people. Products. Features. Pricing. Positioning. AI will build you the whole thing before lunch. A working prototype, a pricing page, five brand directions, a launch plan. What it cannot do, what nothing can do except the market, is tell you whether anyone wants it. And the market does not answer in seconds or hours. It answers in weeks and months, after you have already spent the time, after you are attached, after the thing exists.

Same tool across all three. The capability barely changes. What changes underneath it is the length of the loop.

The coupling that broke

Here is the mechanism, and it is the part worth slowing down for.

Every kind of work has a feedback loop, and every loop has a length. The length is how long it takes the world to tell you that you were wrong. A failing test is a loop a few seconds long. A flawed strategy is a loop measured in quarters. A product nobody wants is a loop measured in your runway.

AI did something very specific to this picture. It collapsed the cost of production to almost nothing. It did not touch the length of the loop.

That is the whole asymmetry.

And those two used to be coupled. The effort of building something was, accidentally, also the time during which you noticed it was a bad idea. The slowness was a feature. It rate-limited your mistakes. You could not get that far down a wrong path before the friction of building forced a check.

Now the friction is gone. You can produce a finished-looking answer to a question that will take the market three months to grade. The production is instant. The verification still takes three months. The gap between those two numbers is the most dangerous place to be working right now, and AI walked us all straight into it while we were admiring the speed.

So the value of AI really is inversely proportional to the distance between its output and reality. Not because the model gets dumber as the work gets harder. Because the further out you go, the longer you wait to find out it was wrong, and the more you have built on top of the error before it surfaces.

This is the part where I should name names, because the idea is in the air. The clearest version on the research side is what Jason Wei calls the asymmetry of verification, or verifier’s law. The tractable problems for AI are the ones you can cheaply check, and the real question about any task is not whether it is hard but whether you can close the loop on it. Others have put it more bluntly. Generation got cheap and validation did not. They are right.

But notice where almost all of that conversation lives. It lives in code. Tests, pipelines, formal proofs. The left end of the gradient, where verification was already cheapest to begin with. The frontier worth caring about is the other two thirds. The part with no compiler, where the verifier is a human being and the loop runs a quarter long. That is the part nobody has a clean answer for, and it is the part that decides whether a company lives or dies.

Premature closure, and the time it got me

The failure here is not hallucination. Hallucination is the one everyone talks about, and it is mostly a solved-enough problem in the reality-constrained zone, because reality catches it. You do not ship a hallucinated SQL query twice.

The real failure is premature closure. You ask a hard question, you get back something articulate and well-structured, and you stop. Not because you verified it. Because it felt verified. The fluency did the work that evidence was supposed to do.

The move: drag the work left

Here is where most takes on this stop. They say: be careful in the amber and red zones. Use AI as a thinking partner, not a decision maker. True, and useless, because be careful is not an instruction. Careful how.

And this is exactly where the code-side version of the idea runs out. In code, the loop is already short. Out here in the rest of the work, you have to build the loop yourself.

The better move is sitting in the structure of the gradient itself.

You do not have to accept the zone the work arrives in. A lot of craft is dragging work leftward, manufacturing a cheap piece of reality so an amber question becomes a green one before you have spent a quarter on it.

The strategy memo cannot be compiled. But it implies a prediction, and a prediction can be checked against three customer calls this week. You just dragged it left.

The product idea will take the market months to grade. But the riskiest assumption inside it can be tested with a landing page and forty clicks, or ten conversations, before a line of real code. Dragged left.

The architecture decision has no compiler for its long-term consequences. But you can build the smallest load test that would break it, today, instead of discovering the ceiling in production. Left again.

This is what invalidate before reality has to actually means in practice. It is not a mindset. It is a habit of manufacturing fast feedback on purpose, of asking the same question every time: what is the cheapest, fastest piece of reality I can put in front of this idea, and how do I get to it this week instead of next quarter.

The operators who are going to win the next few years are not the ones generating the most. Generation is free now, it is a commodity, the model does it for everyone equally. The edge is in verification. In how fast you can find out you were wrong. In how cheaply you can build a reality check for an idea that does not come with one attached.

The skill worth building

So the thing I am investing in is almost the opposite of what the moment seems to reward.

Everyone is getting better at producing. The output is getting cheaper and more fluent by the month. That race is over and the model won it. Trying to out-generate the generator is a bad use of a human.

The scarce skill is the other one. Killing your own ideas early. Building the cheap test before the expensive belief. Staying suspicious of the answer precisely when it sounds most finished, because sounds finished is exactly the signal that you have left the zone where reality was doing your checking for you.

AI made creation cheap. Reality did not make verification cheap.

The whole game now is closing that gap yourself, on purpose, before the market closes it for 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 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.

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.