Working with Agents
I usually have about a dozen terminals with agents (mostly Claude Code) open, because I have multiple projects/tasks running at the same time (trying to use all those credits from my Max subscription). The way my work goes: find an agent that has finished its work and is waiting, read the report it produced, and parse it to understand what is important, what is not, what I should ask the agent to do next, and whether it should stop. With many agents running, that’s a lot of reading and contemplating. Intense sessions like this burn me out quickly. And then Opus 5 came out and I started hating my life: its prose was unbearable! I lost count of how many times I told Claude that I could see its words and sentences, but none of them made any sense.
Then I solved it and found my inner peace. The solution is: restrict what Claude can tell me. I don’t want to see free-form prose; mostly I want to see a list of my actions with context around them. It turns out Opus is very good at showing me what is really important and skipping the fluff if you constrain it. Now my workflow is: review the options for what to do next, take a quick look at the context, press a single button, and move to the next terminal. What previously took several minutes and a lot of concentration, trying to understand the context and hunting for the important bits, now takes seconds.
Before: Wall of text!
After: Look at the bottom for quick info and action
The agent’s reply
When a coding agent finishes working on your prompt, its reply hands control back to you (the handoff) with a report saying what it did, what it fixed, what it found, and some unrelated things it uncovered. Buried in that wall of text are the decisions you have to make: whether to commit or keep going, whether to run the tests now or after the next change, and whether the flag it raised halfway through matters. You read the paragraph to find them, then you type “continue”.
The agent already framed the options in sentences, but it sends them as prose you must parse, decide on, and reply to before any of them can happen. You do the parsing and the typing for a decision the agent had already framed.
Shorter paragraphs still hide the decisions
The standard remedy aims at length. Claude Code includes one itself: an output style called Concise, added in version 2.1.237 and described in the product as making Claude “respond tersely, leading with results and skipping preamble and narration”. Around it sits a layer of rules in the per-project instruction files (CLAUDE.md files) telling the agent to skip padding, recaps, and explanations of what it is about to do. A number of community-written instruction packs (skills) compress the wording further.
They do what they say and the output gets shorter. What they leave unchanged is the shape of the output: prose you must read to find the decisions, now in a smaller paragraph, with the detail you needed in order to decide compressed out. Shorter output removes the detail that makes a handoff usable.
End the reply with selectable options
At the moment the agent hands control back to you, its output does not need to be prose. The agent knows the two or three things that could reasonably happen next, and what it needs from you is a choice between them. Claude Code already has the built-in question tool for that (AskUserQuestion), which draws a card of labeled options you pick with one key, with free text always available.
So how about this rule: when the agent changed something, its reply ends with a short report — one headline sentence carrying the material fact, bullets for what changed, a line saying how it was verified — and then a card of two to four options for the user to quickly select from. The agent gives the user a list of options, and the user picks the most relevant one. Reverse Jev!
TypeSafe AI made a version of this argument when they launched Jev, a model that does not generate text at all: you send it a question and a schema, and it returns a typed decision your software can act on directly. Their case is that when the answer is a choice, generating prose around it is wasted work for everyone downstream. That holds just as well at the other end of the conversation, where it is the agent asking you for the decision, so the only difference is who is being asked.
Why this is a plugin and not an instruction
You can tell an agent to end its replies with a question, and it will for a while. Then a context compaction, where Claude Code summarizes the transcript to free space, drops the instruction, or a long stretch of work crowds it out, and the agent goes back to paragraphs. No step detects the missing question because no step reads the transcript for it. This is the usual result when a behavior depends only on prompt text.
What’s Next, the whats-next@kvit plugin, hooks into Claude Code events to enforce the rule: when the agent changed something, its reply ends with the question tool.
The obvious objection to a plugin that can block your agent is that it might keep blocking. This one blocks at most twice per prompt, well inside Claude Code’s own ceiling of eight, and it does not block while background tasks are still running. Faults in a card you have already answered — a header too long to fit, an option with no description, no way to stop — do not block at all, because sending the agent back would only redraw a better-formatted card for a question you have answered, so those print as a note and the reply ends.
A week of daily use
I implemented this as the whats-next@kvit plugin and have been running it on my own work for about a week. As a result, I no longer swear at Claude over incomprehensible reports full of jargon and awkward lingo! The flow is much smoother, with clearer and easier transitions to the next step. I wouldn’t use Claude Code without the plugin now; I feel I would give up too much without it.
One irritation remains, and I have not fixed it. I often find the question card on its own is not enough to decide from. Each option gets a short label and a short description, and the tool that draws it has nowhere to put the reasoning behind the choice, so I read the options, cannot tell which is right, and scroll back into the report. That is the cost of building on a general-purpose question tool. AskUserQuestion was made for an agent to ask a factual question, without a place to attach the evidence behind each option.
I have implemented a different type of tool within my own coding agent, based on the philosophy that I don’t want to see an unstructured wall-of-text report from the agent. The agent is allowed to use only a specific set of block types in its final report, and my harness supplies a UI that renders it with details hidden but revealable. You can check it out here: kvit-coder. This plugin is the part of that idea that can run inside Claude Code today.
Installing What’s Next
Two lines in Claude Code:
/plugin marketplace add https://github.com/kvitapp/kvit-plugins.git
/plugin install whats-next@kvit
The next session starts with the rule in force, and uninstalling removes it; there is no style to select and nothing left behind. A project can switch it off in its own directory with { "env": { "REPORT_GATE": "off" } } in .claude/settings.json.
It uses only the Python standard library and needs Python 3.8 or later. On Windows it needs Git Bash, because the hook shim is a bash script — the same requirement Anthropic’s own security-guidance plugin has. There are also Gemini CLI and Codex CLI extensions in the repository.
None of this is about a plugin. The handoff at the end of a reply is a place where an agent has already framed the decision and then sends it as prose you must parse again, and that is worth fixing wherever it happens — in a plugin, in an editor, or in whatever tool you use next.
The code is at kvitapp/kvit-plugins, MIT licensed.