I Let Jev Make Claude Code’s Decisions — Here’s What Happened
What happened when I put a tiny classification model in charge of every decision Claude Code could hand over
In my last experiment, I connected a very fast, very small classification model called Jev to Claude Code. But Jev only got one job: picking the model and the effort level for subagents. Every real decision Claude made under the hood still went through Sonnet or Opus.
This time I wanted more. I wanted Jev on every decision it could handle.
Claude told me that was impossible. It wasn’t.
Here is what I built, what I learned, and results that might not be what you expect.
“That’s not how Claude works”
Last time I used a ready-made setup: TypeSafe’s official skills and the Jev router. It only let Jev choose a model and an effort level.
So I asked Claude Code a simple question. Can Jev make other decisions too? Which MCP tool to call, which command to run, or which command we should refuse to run?
Claude said no. That’s not how Claude Code works.
Instead, it suggested adding an extra Jev check on top of Claude’s own decision. It sounds reasonable, but think about it for a second: adding another call on top of the existing one only makes everything slower and more expensive. That’s the opposite of what I wanted.
But Claude Code has mods now, and mods exist to change how Claude Code behaves. So I asked again, more precisely: can a mod replace the request instead of adding to it?
Surprise, surprise. It can.
Which brings me to the first lesson, before we even start: sometimes you have to be pushy. The first answer is often the safe answer, not the right one.
How Jev works
A quick refresher. Jev can’t write code and it can’t write a proper response. All it can do is answer a question with yes or no, or pick one option from a list you give it.
So before every request to Claude, the mod asks Jev first. If Jev is confident, the mod just does it. If not, the request goes to Claude and everything works as usual.
Jev never invents a command. The mod builds a menu of actions, such as a tool, a script, or a git command, and Jev picks from that menu.
In my mod, Jev has four jobs:
1. Answer simple prompts itself. If I ask it to run the tests, it runs the command, and a small, cheap model (Haiku) reports back. The big model is never called.
2. Decide how hard Claude needs to think, and set the effort level to match.
3. Safety-check commands. If something doesn’t look right, it doesn’t run.
Get Code and Bird’s stories in your inbox
Join Medium for free to get updates from this writer.
4. Check the work is really done. When Claude says it’s finished, Jev checks whether it actually is, or whether it needs another go.
The security system that made me the intern
The first real problem: Claude Code’s auto mode refused to run Jev’s calls.
Fair enough. From its point of view, some extra command was appearing out of nowhere. Why would it trust that?
Claude’s suggested fix was to let the mod approve its own calls. Then Claude tried to write that code, and it was blocked. Self-modification isn’t allowed: Claude can’t write code that approves Claude’s own actions.
Honestly, that’s what you want from a security system. A human should sign off on a potentially dangerous change like that.
So instead of making the change, Claude said: “Here are six lines. Copy them and paste them into this file.”
I pasted them, and it worked. But it felt strange, as if Claude were the real developer and I were the human agent doing whatever Claude told me to do.
The results
After some back and forth, I had a working mod. I asked Claude to write a set of benchmark prompts and run them a few times, and I burned through my five-hour limit by 7 a.m.
Here is what I got:
On routine prompts, the mod cut costs by about 40%.
On real coding tasks, it saved nothing.
So my takeaway is this. If you’re doing genuinely hard coding work, use the setup from my previous video: model routing that changes the model and effort for your subagents.
But if your work is routine (cleaning up an email inbox, tidying a downloads folder, filtering or inserting data, deciding which bash script to run), anything that doesn’t need advanced reasoning, Jev can save you up to 40% compared to running everything through Claude models. And it is a lot faster.
What I’ll actually remember
It isn’t the cost savings. It’s Claude telling me something was impossible to build, then building it anyway. And its own safety system making me paste those six dangerous lines myself. I find that genuinely funny.
A bonus discovery about effort and caching
One more thing I learned along the way: on newer models such as Opus 5.5 and Sonnet 5.5, you can change effort mid-session without resetting the prompt cache, as long as you change it per message. Changing the effort setting for the whole request still restarts the cache, so how you change it matters. That was a really nice thing to discover, because it makes per-turn effort routing worth doing in long sessions.
See docs: https://platform.claude.com/docs/en/build-with-claude/effort#change-effort-mid-conversation-beta
Try it yourself
The repo with my mod and the benchmarks is here: https://github.com/nim-f/jev-pilot
Feel free to play with it, but remember: I made it in a couple of hours during a bout of insomnia. It is not production-ready. Don’t use it for anything important. It can break.
And I’m not the only one who built something like this. When I finished, I searched for similar projects and found a plugin called effortless that works on a similar principle. It’s worth checking out too.
If you’ve already tried Jev yourself, I’d love to hear how it went.
This post is based on my video walkthrough: watch it on YouTube
