Cold open
Run `rg -n '"continue"' ~/.claude/logs` before you touch another prompt. That's the first move this week: count how often you've typed continue at an agent and let it run. This is Weekly Terminal Signal on ProDevs. Today the constraint is a CLI workflow you already run. If a change doesn't save time on that workflow, skip it. Here's the number that should make you audit your logs: one Claude session burned over 12 billion tokens across about 25 prompts, mostly variations of the word continue. That's from Theo on t3.gg, and he says it cost roughly $5,000 of inference. You don't need to match that to have the same problem. The first tip is to count your continue loops, and the useful part is what you do after the count. If your first reaction is that you'd never let a session get that far, look for the smaller version in your own history: every vague continue is the same behavior with a smaller bill.
Count your continue loops
Point ripgrep at your agent logs. The command is `rg -n '"continue"' ~/.claude/logs`. The `-n` flag gives you line numbers, so you can see the exact run where you stopped giving instructions and started nudging. If you don't use Claude, point it at whatever directory your agent writes transcripts to. The path is not the point. The count is the point. If you see a wall of continue prompts, you're not supervising an agent; you're paying it to circle. The extreme case in the source is nearly 4,000 hours of Claude agents, multiple accounts, minimal supervision, and a single session over 12 billion tokens from about 25 prompts. Most of those prompts were just continue. The output wasn't nothing—he credits it with a Rust rewrite of TypeScript, a faster Rust compiler, and a playable Skate-style game with flick-it controls built alongside a Three.js engine. But the catch is the billing. A loop that looks productive in the terminal is still a loop. So run the `rg` command, count the continues, and find the longest run where you weren't actually steering. Sort by the longest run, not just the total, because one long continue streak tells you where your attention disappeared. Then set a rule: no more continue without a concrete new instruction. That's a reversible change you can test this week.
Version your agent harness
Now shift from logs to the code around the model. Take your agent harness—the tool interface, the instructions, and the loop the agent runs—and put it under version control. The command is `git init harness && git add harness && git commit -m 'baseline harness'`. The `-m` flag just labels the baseline so you can diff the next change. Why now? Because there's a pattern worth stealing: freeze the model weights, evolve the harness around them, and ship the harness as a standalone artifact. A strong teacher agent repeatedly rewrites the harness using feedback from reconstructions on a development set—rewrite, test, rewrite. The weights, action semantics, and execution backend stay fixed. In the source, the interface is built from parameterized primitives, hierarchical composition, and semantic spatial relations, and the agent writes the scene as executable code. That matters because the scene becomes code, so harness changes are reviewable instead of hidden in a prompt. Then the teacher stays home, and a small open-source model runs the harness unchanged on unseen scenes. The catch is real: it was tested on two indoor datasets, with no outdoor scenes and no open-world evaluation. So don't pretend the harness is universal. But the developer lesson is solid: treat the harness like source code. Version it, test it, review it, ship it. Run the `git` command above, then make a small harness change—tighten an instruction, remove an unused tool, or add a test—and commit it separately. If it doesn't save time on a workflow you already run, revert it. That's the constraint.
Token Economizer news
That harness idea matters because the token bill is real. The news peg is Microsoft's plugin, Token Economizer. It cuts agent token use by 23 to 31 percent. It was tested on 277 real bugs across six GitHub projects, and bug-fix reliability was slightly better. It works on Claude Code, Codex, and GitHub Copilot. The mechanism is boring in the best way: it watches how your agent behaves across repeated runs on the same codebase, spots recurring errors, tools the agent never calls, and loops spinning with no progress. Then it saves what Microsoft calls micro skills—small reusable fragments of learned behavior—and it disables the tools the agent never uses. Fewer tools in context means fewer tokens burned deciding what to do. The catch: the write-up doesn't give an install command or a public package name, so don't invent one. The practical move is to check whether your agent platform supports this plugin layer, and if it does, test it on a repo. If it doesn't, copy the audit idea: use your logs to find unused tools and loops. And remember the larger point: token efficiency is an orchestration problem, not a model-selection problem. Picking a bigger model doesn't fix a loop. Pruning the agent's behavior does. The source also has a claim from Theo that capability depends on tool access, not stored knowledge, especially web browsing. That's a strong argument for auditing tools rather than just swapping models. If your agent is stuck in a loop right now, you're paying for every second of that loop.
Takeaways
- This week, run `rg -n '"continue"'` against your agent logs and stop yourself from sending another continue without a new instruction; if you see a run like the one with 12 billion tokens and about 25 prompts, you've found your first fix.
- Put your harness under `git` with `git init harness && git add harness && git commit -m 'baseline harness'`, then make changes separately; the pattern froze weights and shipped the harness, but the tested scope was two indoor datasets, so keep your own test set.
- If your agent platform supports Microsoft's Token Economizer, pilot it on a repo and compare against the 23 to 31 percent token cut and the 277 real bugs across six GitHub projects; if not, audit unused tools and loops manually.
- Use Claude Code, Codex, or GitHub Copilot as the test surface, and write down the startup waits before you trust any benchmark; a plugin that saves tokens in a warm run still has to earn its keep in your actual workflow.
Sign-off
That's the Weekly Terminal Signal on ProDevs. Keep your Ollama builds pinned. And time the startup waits before you trust the score. Ship one reversible change this week.