The Age of Prompting Agents Is Over

These last few days of using Fable 5 have made me realize that the time to prompt agents is ending, and it is ending fast. Fable 5 is not just a good model. It is a glimpse into where agentic coding is going, and it made me accept that the thing Anthropic has been saying for months is actually true: we are not going to be prompting agents anymore. We are going to be building the systems the agents use to prompt themselves.

And I do not think Anthropic got there first because they are geniuses compared to everyone else. They got there first because they have been using Mythos-class models internally for a long time before anyone outside the company had any idea what was going on. They were living in the future. Now the rest of us get to visit, and it is very different from the last few years of coding with AI.

Two things pushed me over the line. The first was simply using Fable, because getting the most out of Fable is different from getting the most out of Opus or Sonnet, and not just because the model is smarter. It is a model that does not want to be directed as much. We have reached a level of intelligence where the danger of the human getting in the way is real, where over-prompting actively harms the model more than it helps. The second was a talk from Anthropic that made everything they have been saying click into place. Let me walk through both.

The talk that made it click

The talk is called Seeing Like an Agent, by Thariq Shihipar from Anthropic, at the AI Engineer World's Fair. The framing that stuck with me is that Claude gets smarter in spiky ways. Not linearly, the way we keep expecting, but in jumps that depend on how we prompt it, the harness we build around it, and the tooling we hand it.

Then he put up a slide on the evolution of agents, and this was the aha moment for me.

Step one is the chatbot. It has to be given context. Everything it knows lives inside that chat window, and it knows nothing else. Step two is Claude Code, which was given arms to execute. Tools like Bash. This was the leap that changed how people thought about the whole problem. If you remember the early days, everything was about the context window. The idea was that we just needed a big enough window to shove an entire codebase into, and the model would reason within it. Someone would say 100 million tokens and we would all nod. Then Claude Code showed that the better move is to give the model tools to go inspect the codebase itself, pulling in only what it needs, instead of bloating the window with everything and degrading its performance. In Thariq's words, if you give it arms, it can build and search its own context. Spiky. A new innovation in how we work with the model, not a bigger number on a spec sheet.

Step three is the one to pay attention to. Claude Tag is the new feature where Claude lives in your Slack. Not an integration where Claude plugs in like a bot, but a feature built around Claude that lets it use Slack the way a person would. You give it something to do, it goes through channels, finds context, reasons over whatever it can access, and then works autonomously. And what unlocked Claude Tag, per the talk, is its ability to work proactively and multiplayer. Claude Code is something you have to prompt for it to do work. Claude Tag can wake itself up and do work, and Anthropic thinks that ability is what unlocks the next wave of agents.

That is the pattern across the whole frontier right now. The progress of the last few months has not really been about wowing us with raw intelligence, even though Fable did some of that and I expect GPT 5.6 Soul to do the same. The big push is the model's capability to run for a really long time and get a job done with very little input from a human. Everything Anthropic is shipping points at autonomy.

The age of prompting, an obituary

Here is what we were all doing until about five minutes ago, and I did all of it too.

We wrote really detailed user prompts. We tried to anticipate where the model would make mistakes and prevent them through CLAUDE.md and AGENTS.md and a small library of files built around the model. We specified what to research and what to ignore, because it would wander off and pick up irrelevant data that hurt its own performance. We wrote skills as playbooks for specific tasks, frontend engineering, working with Convex, whatever, so the model would approach each problem exactly the way we wanted. We started everything in plan mode, which is literally a cage. The model is not allowed to act until you press a button that says you have planned enough, now go. And underneath all of it sat a very detailed system prompt with carefully described tools and lots of examples, because entire AI products won or lost on the quality of their system prompt and their examples. You fed all of this into Claude Code or Cursor or Codex, came back, reviewed, QA'd, iterated.

That was the age of prompting. Heavily scripted, human anticipating everything, model executing inside the script.

Then Anthropic says, almost in passing, that they recently removed 80 percent of the system prompt for Claude Code.

That line matches my experience with Fable exactly. And remember, they have been using these models far longer than we have, so they have had far longer to figure out what the next step looks like. The scripts are coming down because the models no longer need them, and keeping the scripts up actively costs you capability.

Discover your unknowns

So what replaces the script? The part of the talk I found most useful is a framing Thariq calls the map and the territory. When you are working on a coding problem, the plan and spec in your head is the map. The territory is the actual codebase, the real world, the constraints the model has to navigate. Whenever the agent runs into something in the territory that is not on your map, that is an unknown, a decision point you never specified. His line was that Fable is bottlenecked by your ability to match the map to the territory and find your unknowns. You are the bottleneck now.

For any problem you have known knowns, which is what you write in the prompt. Known unknowns, things you know you have not figured out yet. Unknown knowns, the things so obvious to you that you would never write them down, but you know them when you see them. And then the unknown unknowns, the things you have not considered at all, where knowing them would change how you prompt in the first place.

The old workflow only ever transmitted the known knowns. And these models are designed to follow instructions, so if a big slice of the problem lives outside what you wrote, you are hurting the model's ability to help you. You are holding it inside your own blind spots.

The fix is almost embarrassingly simple: have the model interview you. My prompts have gotten shorter, not longer. A concise prompt that clearly states what I know and then explicitly asks the model to bring up what I do not know. Inspect my idea, go deeper, surface the points I have overlooked that are crucial to solving this. Fable is genuinely good at this, good enough that it routinely gets me to know what I did not know before any work starts. That is the part of the loop I refuse to skip now, and it costs one short prompt.

Give it arms, not prompts

The other half of the new workflow is what goes into CLAUDE.md, and it has completely changed shape for me. It used to be a defensive document, a list of mistakes to avoid. Now it is an orchestration document. The bulk of mine is instructions for when the orchestrating model, in this case Fable, should spin up subagents and workflows, and which model to use for what.

Concretely, mine has things like: spin up a Codex subagent to review your code. Use Gemini 3.1 and Kimi K2.7 to inspect the spec and adversarially attempt to reject it before you start working. I run those through OpenRouter, so there is an OpenRouter chapter in my CLAUDE.md telling Claude it can and should call outside models to get a perspective that will actively try to break its idea. And there is a routing section, because this matters for cost as much as capability: use Opus 4.8 for design because it has taste, use GPT 5.5 for backend because it is strong there and cheap. Fable is, as we all know, a very expensive model, so you want Fable orchestrating and delegating to whatever model is optimal for each piece, not burning Mythos-class tokens on CRUD endpoints.

Then you wire loops around it, the same shape I wrote about in my loops post. Filing a PR triggers a Codex code review. The review drops a comment, the comment landing triggers an iteration cycle, and it goes around until every agent in the setup agrees it is green. Add the /goal command on top, because if you give Fable a goal it will tirelessly work on and on until the goal is reached, which makes the whole loop dramatically more powerful. Push to staging, never straight to production. The unlock with Fable is that it is smart enough over a long horizon to run this for hours and leave you a genuinely polished PR that you barely touched.

When I wrote about loops a couple of weeks ago I said the fully autonomous version had no taste and could not point. I stand by that, and nothing here contradicts it. The vision for the product, understanding what your users want, what the product needs, that is still very much a human thing. I have tried to outsource taste to LLMs and they are still not good at it. The difference is that everything below the vision, the entire work-intensive middle of the process, now runs with minimal intervention. You explain the idea in simple terms, hand it to the loop, and review the result.

I tested it on my own footage

This is not theoretical for me. I have an application I built to polish video footage. I record right here at this desk, and the raw footage is full of retakes, me reading into the microphone, breathing, dead air, all the things you never see in the final video. I have been experimenting with using AI to clean that up, and I built a decent log of eval footage where I tagged what should be removed and what should be kept, by type, so the model understands what a retake is versus what is just empty space.

The system was not good enough. It cut things that should stay and kept things that should go. So I gave Fable a long-horizon goal: here is the eval harness, here is the test footage, improve the system and keep testing until the quality is good enough.

It went for well over an hour. It would run the harness, check the transcript of the output to see whether bad parts survived or good parts got cut, iterate on the system, and go again. It called Codex when it wanted a review, called other models, spun up subagents and workflows when it decided it needed them. Nobody prompted any of that. It is a genuinely strange thing to watch, and it is exactly the shape Anthropic has been describing.

If you want to try this yourself, your Fable window on the subscription may have run out, even though Anthropic says it is coming back. But GPT 5.6 Soul should be out soon enough and I expect a similar level of capability. Either way, I recommend you start dabbling in this way of working now, because the models are all converging on it.

The ultimate loop, a draft

All of this led me to a question I could not put down: what does the ultimate loop look like for a model like Fable to be perfectly unlocked, across every machine and codebase I work on?

My current draft is built around my Hermes agent as the orchestrator, and the reason it fits is that it can sit at the center on a machine that is both safe and has no access to my personal stuff. You do not want LLMs anywhere near sensitive data if you can avoid it. So the Hermes agent lives on an AWS server that is completely closed to internet traffic, except through an MCP over Tailscale that I built to connect to my machine or my phone when I need it.

Next to it sits GBrain, which you should look into if you have not heard of it. It is a system for building a second brain, a big Wikipedia-style body of centralized knowledge, everything you want agents to know about you, your work, and your preferences, stored in a way that is very easy for agents to retrieve. The Hermes agent is the GBrain operator. It creates memories when it thinks they are worth keeping, retrieves them when they are relevant, and actively maintains the brain for whenever my coding agents need context.

For the actual work, the Hermes agent can call the Codex CLI, and I believe it can call the Claude Code CLI too, though you should be careful here because Anthropic is not super clear on this. You definitely cannot use Claude subscriptions as the automated core of an agent like this, so the core of mine runs on my Codex subscription. From what I can tell, calling the Claude Code harness is fine as long as it is not automated, which mine is not: the Hermes agent is on Telegram and Discord, and it only triggers Claude Code on demand when I prompt it.

The flow ends up like this. Say I want to spec a new project. Claude Code on my machine hits the Hermes agent through the MCP, Hermes pulls whatever GBrain knows about me that is relevant, and feeds it back. As I work and new information appears, the coding agent pushes it back through the MCP, and GBrain grows and gets more useful the more I work. It is centralized, always on, and it never touches my machine's sensitive corners.

I suspect this shape, or something close to it, is the agentic workflow of the near future. Something that does not live on your machine, always on, that you hand work to. It does the work, files the PRs, gets them reviewed, and ships when everything is green, with other models pulled in through OpenRouter to adversarially hunt for flaws before anything merges. All you do is check staging, or honestly just ask the agents to record a video of the new feature being used, so you can sit on your phone, watch it, and say yes or no.

The step after that is local inference, so you own the whole stack and depend on no third party. That is still down the road for individuals, because doing this on cloud hardware at frontier quality is extremely expensive today. But open-weight models are catching up to the frontier, more data centers keep coming online, and the cost structure keeps improving, so I believe the price of inference comes down and this gets realistic sooner than people think.

The human is still in the loop, for now

If you are reading all this as getting rid of the human, I would not say that. My knowledge is limited, I cannot see the future. But for this next wave of agentic coding, the human in the loop is still clearly essential. The models still make egregious mistakes that a human spots instantly, and you do not need to be senior to spot them. Vision and taste have not moved an inch toward the machines.

What has changed is everything underneath. Prompting is being replaced by a kind of systems design: how do you make the most of models that are genuinely capable over long horizons? You stop scripting the model and start empowering it. Shorter prompts that state what you know and ask for what you do not. More arms, fewer instructions. Loops that keep it working while you sleep.

Coding today is already unrecognizable from four or five years ago, and this is another leap in autonomy on top of it. I think this is the biggest step change in how we build software since Claude Code first showed up. If you have started playing around with your own ways of orchestrating work, I would genuinely love to hear what you are coming up with, because everyone is drawing their own map of this right now, and nobody has the territory yet.

Alright. My loop is telling me a PR is green. Time to go say yes or no.