Why I Created Mini-claude Instead of Using Aider, Cline, or OpenClaude

I started using local AI agents at the end of 2025, a few weeks after finding a r/LocalLLaMA thread praising qwen2.5-coder in Aider. Back then, I was using Claude Code at $200/month, and the idea of having a similar agent loop with a model running on my Mac seemed like a weekend curiosity. Six months later, I uninstalled Claude Code, code eight hours a day with an open-source agent I wrote myself, and I don’t feel like I’ve regressed. This article explains how I got here.

Mini-claude wouldn’t exist if I had found exactly what I was looking for in the existing landscape. Aider, Cline, Continue.dev, opencode, Crush, gptme, and more recently OpenClaude—all these projects are just a git clone away from the folder I’m working in. Over those six months, I installed each one, completed entire projects with them, and took notes. At some point, those notes stopped being bugs and became a list of things no one was going to fix because no one saw them as problems. That’s when I decided to write my own TUI.

The Moment I Realized Something Was Off

It was a Sunday in February 2026. I was refactoring a Go project of about 12,000 lines, with Aider in architect mode and qwen2.5-coder:14b behind it. The agent wanted to modify internal/auth/middleware.go. Except that file was called internal/auth/handler.go and auth/middleware.go had never existed. Aider invented the path. Not just once—seven consecutive tool calls on a phantom file. Each call returned an error, the model retried with a spelling variation, the error came back, and so on. I let it run for two minutes before stopping.

What struck me wasn’t that it happened—path hallucinations are a classic. What struck me was that I had no way to understand, in real-time, what was happening. No structured log, no loop indicator, no message saying “this model just sent you the same tool call five times in a row, maybe you should do something else.” I reviewed the notes from the previous five days: three other similar loops, two in Cline, one in Continue.dev. All silent.

That’s when I understood that the problem wasn’t the model. The problem was that we were building local agents by copying the philosophy of cloud agents, without realizing that the constraints are not the same at all. An agent talking to Claude Opus can afford silent loops: the model always eventually exits the loop because it’s very strong, and each turn costs three cents. An agent talking to a qwen3:8b on your Mac, however, can loop all day without you knowing, and the cost is your time.

Aider is Excellent. But.

Aider essentially invented the format of unified diff modifications and pushed honest benchmarks for two years that no one else published. The blog stopped in May 2025, and it’s a shame because half of what I know about local models comes from their articles (“Details matter with open source models”, “Unified diffs make GPT-4 Turbo 3X less lazy”, the series on repo-map in tree-sitter). It’s the tool I used the longest before writing my own.

What made me move on boils down to three points. First, the aider command launches a mode that codes by default. No intermediate step for reviewing or pair-programming where the AI refuses to write and asks you questions. The /ask is nice but remains a workaround, not a first-class mode. Second, Aider’s auto-commit creates a commit per loop turn; rewinder quickly becomes quirky in a long session. Third, the Python ecosystem is heavy to carry on some machines (I spent two hours debugging a venv conflict on an OVH VPS, and it wasn’t the first time).

If all I needed was a tool that did “agent → edit → commit” on a well-set project, I’d still be on Aider. The problem is I wanted something else.

Cline, Continue, opencode: Three Excellent Tools in the Wrong Shell

Cline and Continue are VS Code extensions. I spend half my day in Vim on a tmux session, on a VPS or my machine depending on the day. VS Code is not my environment, and putting my entire feedback loop through an extension that drives an Electron UI to drive a model running locally is three layers of indirection I can’t justify.

Opencode is a TUI, in TypeScript/Bun. It’s fast, the diff viewer is superb, the team releases updates every two days and the changelog is exemplary. The only problem is that it’s an execution-first tool: it codes, it codes well, and it has no educational ambition. If you want to learn something using it, it’s up to you to make the effort to read what it does—the tool won’t help you.

Crush is Charm’s Go agent. The visual craft is ridiculously high quality (it’s Charm, we expected nothing less), but the team publishes almost nothing about the tool itself. A Crush agent session looks like many others: a loop, tools, a diff, a commit. When I tried to understand how they handled failing tool-call loops, I ended up reading the source code.

All these tools have one thing in common: they answer the question how can AI code faster. It’s an excellent question. It’s just not the only one.

OpenClaude Arrived. And I Still Ended Up Publishing My Own.

When I started Mini-claude in March, OpenClaude didn’t exist yet—at least not the Gitlawb version. When it came out in April, I seriously considered stopping mine. The pitch is convincing: it’s, as far as one can tell, a rewrite/a fork of Claude Code’s internals with a multi-provider router grafted onto it. npm install -g openclaude and you have an agent loop that connects to Ollama, Gemini, GitHub Models, Codex OAuth, and routes everything through ANTHROPIC_BASE_URL. It’s the most credible open-source clone of Claude Code.

I still continued for five concrete reasons.

First, the runtime. OpenClaude pulls Node, its deps, and all the npm folklore behind it. Mini-claude is an 11 MB Go binary that depends on nothing. On a clean Mac M2, time go run github.com/hugostarte/Mini-Claude/cmd/tui@latest returns in 800 ms; an npx openclaude on my machine runs at 3.4 seconds for the same empty loop. It’s not dramatic but it’s noticeable in use.

Then, the philosophy. OpenClaude is an agent that executes. That’s its raison d’être: to make the model pass for Claude and code. I wanted an agent that could do something else: ask the questions that would lead me to find the answer myself. It’s guided. This idea—that the value of a code agent is not only to write code but also sometimes to refuse to write it—is not in any other tool I know. It’s probably the only angle that justifies adding one more project to the list.

Third, /undo as a git primitive. Mini-claude auto-commits each destructive tool call with a structured message miniclaude: <tool> <path>, and /undo rewinds the last miniclaude commit—never a commit you made manually. No more half-working “rollback”: if you’re in a git repo, you can go back. If you’re not in a git repo, the agent tells you it can’t guarantee the undo. No surprises. OpenClaude offers a “checkpoints” system but the semantics are not publicly documented, and from memory, it doesn’t survive an agent crash.

Fourth, cross-tool memory. Mini-claude reads the first it finds in this order:

MINICLAUDE.md → AGENTS.md → CLAUDE.md → GEMINI.md →
.cursorrules → .windsurfrules → .github/copilot-instructions.md

This means that if you come with a repo already set up for Claude Code or Cursor, you have nothing to do. The CLAUDE.md is read as is. I don’t know why I felt like writing this—it took three days of work and it’s a feature everyone should have. No other local agent does it.

Finally, privacy by design. This is the point I most want to defend, and it deserves its own section.

Privacy by Design, Not by Policy

When you install Cursor, you can disable “Privacy Mode” in the settings. When you install Continue, you can disable telemetry in an env variable. When you install OpenClaude, the source code doesn’t make a call to an analytics endpoint—at least not in the version I audited. These three statements are true, and they’re at completely different levels of guarantee.

Mini-claude is deliberately at the other end of the spectrum: the only outgoing connection from the binary is to your local inference server. That’s it. No “disable telemetry” because there’s no telemetry to disable. No opt-out analytics because there’s no analytics. The browser that browser_open uses is your Chrome, with your session, on your IP. You can verify it in five minutes:

# 1. launch mini-claude
go run github.com/hugostarte/Mini-Claude/cmd/tui@latest

# 2. in another terminal, see what the PID is listening to
ss -tnp | grep mini

# 3. what you should see: a single outgoing connection
# ESTAB 0 0 127.0.0.1:55432 127.0.0.1:11434 users:(("tui",pid=...,fd=8))
# that's your Ollama. Period.

This difference between “promise” and “construction” is subtle but it matters. A promise requires trust. A construction allows verification. For a developer, the second category is easier to recommend to their team or DPO.

The Three Things I Wanted That No One Provided

If I had to summarize what made me take the leap, it’s these three lacks.

Firstly, an educational mode that isn’t a degraded mode. Most tools that claim to explain do so in a side window, or via an “ask” command that interrupts the flow. Mini-claude has four modes (auto, explain, guided, review) and you can switch from one to the other in the middle of the session with /mode guided. Each mode changes what the agent is allowed to do: guided has no tools, so it can’t write code even if it wanted to. review is read-only. This structural constraint avoids a whole bunch of bugs (a review mode that “accidentally” edits a file, for example).

Secondly, radical honesty about models. Mini-claude reads the model size at startup, does a one-shot probe to check if native tool calling works, and displays weak tool calling in the header if the result is average. For qwen2.5-coder on Ollama, for example, the result is “weak”—Mini-claude’s documentation explicitly states this and recommends mistral:7b, qwen3:8b, or llama3.1:8b instead. I’m tired of comparisons that put qwen2.5-coder at the top on HumanEval and forget to mention that it does nonsense as soon as you ask it for a tool call.

Thirdly, a deterministic /audit. It’s a command that gathers the project tree, README, and manifest (go.mod, package.json, pyproject.toml…) deterministically—not via the model—and only asks the model to synthesize. Result: even a 4B model weak in tool calling can give you a useful audit because the part that requires reliability is done in Go.

Technical Choices in Two Paragraphs

Mini-claude is in Go, on Bubble Tea / Lip Gloss / Bubbles for the TUI, with the stdlib HTTP client to talk to any OpenAI-compatible server. No agent framework, no proprietary SDK, no LangChain wrapper. The agent loop is 300 lines of Go; the tools are a registry in internal/tools/; the modes are four files that inject a different system prompt and restrict the list of available tools. You can read it all in two hours.

The choice of Go is not ideological. It’s just that once you decide you want a single, static binary that starts instantly and speaks HTTP, you quickly arrive at Go or Rust. Rust would have been defensible but I have 8 years of Go behind me and 3 months of Rust. At 3 days of work difference in development, I preferred to ship. Maybe later.

What Doesn’t Work (Yet)

Mini-claude doesn’t have MCP support. It will be in the next release. Neither do hooks. Saved sessions (resuming a conversation) are in progress. Prebuilt macOS / Linux / Windows binaries are coming—for now, it’s go build ./... or go run github.com/hugostarte/Mini-Claude/cmd/tui@latest. The cycle-detection I mentioned earlier exists but is rudimentary: three identical tool calls in a row and the agent asks if it should continue. It’s better than silent loops but far from sufficient.

All that will come. The /undo and cross-tool memory are the things I wanted to ensure from v0 because they are features that color the project’s philosophy—not add-ons. The rest is normal sprint.

Where We Are, Where We’re Going

Mini-claude has been on miniclaude.fr for a week. The repo is on github.com/hugostarte/Mini-Claude. The license is MIT. There’s no company behind it, no funding, no “enterprise” roadmap. I’m coding on it alone for now and that’s fine with me.

What I’ll be writing on this blog in the coming weeks will look like this: honest experience feedback, comparisons that measure what others don’t (the quality of tool calling on the real models people use locally, for example), and design explanations for the choices that took me time. Not generated content, not “Ultimate Guide to AI Coding Agents in 2026”. If you have topic suggestions or specific technical questions, open an issue on the repo—that’s probably where I’ll dig first.

If you want to test, the quickstart is three commands:

ollama pull mistral:7b
cd ~/code/your-project
go run github.com/hugostarte/Mini-Claude/cmd/tui@latest

/mode guided for Socratic pair-programming, /mode review to have the agent read a repo without touching anything, /audit for deterministic synthesis. The rest is in the doc.

See you in two weeks for the next article, probably an honest benchmark of mistral:7b, qwen3:8b, and llama3.1:8b on a reproducible tool calling protocol. To fill the void left by Aider.