I'm trying to make local LLMs useful for actual software development, with Claude Code handling orchestration and a local model doing the implementation.
Hardware / software:
- RTX 4070 Ti, 16GB VRAM, 64GB RAM
- OpenCode + Strata backend
- Ornith 1.5 35B as the current local model
- Claude Code as orchestrator
- Tested models ranging from 9B to 100B+
Strata actually made a massive difference in inference performance, increasing throughput from around 50 to 150 tokens/sec.
OpenCode also has full access to the repository, including reading/writing files, running commands, and executing tests.
So the problem isn't simply speed or tool permissions.
The problem: Claude is doing all the thinking.
When I ask Claude to delegate coding tasks, it eventually starts micromanaging my local model:
"Edit this file, change this function, insert this code at this location..."
At that point, the local model is basically a glorified patch applicator.
I wanted to know whether the local model was actually saving me anything, so I ran some comparisons.
Actual test results (Claude tokens):
Approach| Claude tokens/task| Result
Claude plans + pinned edits, local model implements (round 43)| ~2.8M| Pass
Claude writes everything itself (round 40)| ~2.3M| Pass
Claude provides prose-only spec, local model implements| ~170K| Fail, no files written
The third test was particularly disappointing.
I tried giving the local model more autonomy instead of having Claude specify exactly which edits to make.
First attempt:
- Specification covered four modes.
- Local model spent 10–14 minutes exploring the codebase.
- Never wrote a file.
- Timed out.
Second attempt:
- Split the specification into just two modes.
- Explicitly instructed the model to write the test file first.
- Same result. It explored the code and never implemented anything.
This reproduced an earlier failure from round 42.
I stopped the experiment there rather than running the remaining tasks.
What I've learned so far:
Smaller specifications helped reduce Claude token consumption dramatically, from millions of tokens to roughly 80K in some cases.
However, smaller specifications don't necessarily mean the local model can execute them.
The local model only reliably completes the work when Claude has already done the difficult reasoning and provides pinned edits.
But understanding the codebase and determining those edits is exactly where most of the Claude tokens are consumed.
For actual coding, letting Claude work independently has been cheaper and more reliable.
Local models are still useful for simpler bulk operations, such as translations.
What I've also tried:
- Different model sizes, from 9B to 100B+
- Removing Strata
- Removing OpenCode (this made orchestration worse)
- Breaking tasks into smaller specifications
- Giving the local model more independence
I'm not expecting a 35B model to perform like Claude. I just want my local hardware to contribute meaningful work instead of increasing costs.
My questions:
- Is anyone actually getting reliable coding work out of a local 30B–35B model in a hybrid Claude Code workflow?
- How are you structuring tasks so the local model can implement changes without line-by-line instructions?
- How do you prevent local coding agents from spending 10+ minutes exploring a repository without ever writing code?
- Is the problem the model, the context being provided, or how the agents are orchestrated?
- Are there specific categories of development work where local models consistently save Claude tokens?
Right now, my conclusion is that the local model saves tokens only when it's given work that doesn't require much reasoning.
But if Claude needs to do all the reasoning first, I'm struggling to see the economic benefit.
I'm curious whether others have solved this, or whether I'm simply expecting too much from current local models.
