Someone I know — Jim Clover — wrote up a development setup on LinkedIn recently that I'd been circling myself for a few weeks. His conclusion was that he could do around 85% of his development work with it.
The stack is four tools: Kilo Code, Ollama Cloud, MiniMax M3, and a local embedding model called mxbai-embed-large. What caught my attention wasn't novelty — none of these are exotic — but cost. Run this way, the work comes out in cents rather than dollars.
The Joel Spolsky Problem
Joel Spolsky used to argue that you should always buy the best tools and never cheap out on developer productivity. He was right. The logic was simple: developers are expensive, tools are cheap, and anything that makes a developer even slightly faster pays for itself within days.
But Joel's argument assumed a world where "best" and "most expensive" were roughly synonymous. The best source control cost money. The best IDE cost money. The best hosting cost money.
That assumption no longer holds as cleanly as it did. You can now assemble a capable coding stack for very little money — not by compromising on the tools, but by being deliberate about where the money actually needs to go.
The Stack
Here's what the setup looks like, and why each piece matters.
Kilo Code is the orchestration layer — a VS Code extension that gives AI agents access to your codebase, not just the file you're looking at but the whole repository, semantically indexed so the agent can navigate by meaning. This is what lets a language model work across an entire codebase rather than a single open file.
Ollama Cloud is the hosting layer. You run MiniMax M3 — a Chinese model that's competitive with frontier Western models — hosted on US servers via Ollama, rather than connecting directly to the model creator. Jim flagged this as significant from a privacy and security perspective, and I think he's right: you get the model's capability without connecting straight to its source.
MiniMax M3 is the language model doing the actual reasoning, code generation, and conversation. It's also cheap enough that you stop thinking about token usage — which, as I'll get to, changes how you work.
mxbai-embed-large handles the indexing. It's the part most people skip, and it matters more than it looks.
The Embedding Model
Most "cheap AI coding" write-ups focus on the language model and skip past the embedding model. That's a mistake.
A language model without good embeddings is like Joel's programmer without a decent codebase search. It's capable, but it spends its time asking "where is that function?" and "what does this module do?" — using its reasoning on navigation instead of on the actual problem.
mxbai-embed-large addresses this. It runs locally via Ollama, so your code never leaves your machine, and it generates semantic embeddings of your functions, classes, and methods. When Kilo Code's agent needs to find relevant code, it searches by meaning rather than by string match.
The difference is roughly the one Joel described between a programmer with a good IDE and one editing in Notepad. Both can do the job; one of them is doing it with a handicap.
Setting It Up
The setup is straightforward.
Pull the embedding model locally:
ollama pull mxbai-embed-large
The model downloads and runs on your machine, so your code stays local.
In Kilo Code, open Settings, go to Indexing, and toggle on codebase indexing. Set the embedding provider to Ollama, point it at mxbai-embed-large, and make sure it knows your Ollama URL — usually http://localhost:11434.
For the vector store, you have two choices. LanceDB is embedded and requires zero setup — it just works. Qdrant runs via Docker and gives you more control if you want it. For most people, LanceDB is the right answer. Pick one, click save, and watch it index your repository.
Then point Kilo Code at MiniMax M3 via Ollama Cloud for your language model.
The whole thing takes about ten minutes. Fifteen if you've never used Docker.
The Economics That Changed
Jim's observation about cost bears repeating, because the implications are significant.
With Anthropic or OpenAI, heavy coding usage can easily run $50–100+ per day. That's fine if you're a well-funded team. It's prohibitive if you're a solo developer, a small consultancy, or a startup watching every dollar.
With this stack, the same work costs cents.
That changes behaviour. When tokens are expensive, you self-censor. You don't ask the AI to explore three different approaches, because that's three times the cost. You don't ask it to review its own work, because that's another round trip. You skip the small stuff — the quick questions, the "am I thinking about this right?" moments — because each one feels like dropping a coin in a meter.
When tokens cost almost nothing, you stop rationing. You use the AI the way you'd use a colleague at the next desk: for the architecture decisions and for "does this variable name make sense?" alike.
That's a change in how you work, not just in what you pay.
The 85% Line
Jim's claim that he could do 85% of his work this way is interesting because of what it implies about the other 15%.
He's not abandoning Claude Code or Codex. He's not claiming MiniMax M3 is better than Anthropic's best. He's saying that for the bulk of everyday development work — the implementation, the refactoring, the debugging, the "I need to add a feature that's similar to this other feature" — a near-frontier model at a fraction of the cost is good enough.
The remaining 15% — the hard problems, the architectural decisions that need the sharpest reasoning, the security reviews where you want the absolute best — that's where you break out the expensive tools.
This is how every mature industry works. You don't use your best saw for every cut. You match the tool to the task, and you save the precision instruments for the work that demands them.
The Atwood Test
Jeff Atwood once said that the best way to evaluate a technology was to ask: "What does this let me do that I couldn't do before?"
This stack doesn't let you do anything new. Every capability here existed before, at higher price points.
What it does is remove the last economic barrier to AI-assisted development. Not for companies with budgets. For everyone. The solo developer. The hobbyist. The consultant who bills by the project and can't pass infrastructure costs through. The developer in a country where $100/month for API access is a meaningful percentage of their income.
When the cost drops below the point where you bother thinking about it, the tool stops being a purchase and becomes infrastructure — something you simply use, the way you use electricity or an internet connection, without noticing the moment it became part of the work.
The Caveat
I'd be dishonest if I didn't mention the trade-offs.
MiniMax M3 is good. It's not the best. For straightforward coding tasks, the difference between it and frontier models is hard to spot. For genuinely hard reasoning — the kind of problem where you need the model to hold twelve constraints in its head simultaneously — the gap is real.
The privacy story with Ollama Cloud is better than connecting directly to model creators, but it's still a cloud service. If your threat model requires that code never leaves your machine, you need to run the language model locally too, which limits you to smaller models. The embedding stays local either way, which is the more sensitive part.
And "cheap" isn't "free." The model could get more expensive. The hosting could change. Building your workflow around aggressive pricing is a bet that the pricing stays aggressive.
Where This Leaves Us
The trade-offs are real, but so is the rest of it: a stack that takes ten minutes to set up, capable enough for most day-to-day coding, with local embeddings that keep your codebase private, at a cost low enough that you stop rationing it. That last part is what changes the daily experience — you use the AI steadily rather than sparingly.
I don't think this replaces the frontier tools, and it doesn't need to. It lowers the cost of the everyday work far enough that the economics of AI-assisted development look meaningfully different than they did a year ago. For a lot of people, that's the part that matters.