Yuval Avidani
Author
Turns out the most important number this week is 6.7 that became 68.3
Let's start with the number that lit up the whole conversation. Take a model called Grok Code Fast 1, don't touch its weights for even a second, and just change the way it writes file edits. Its success rate on real code-editing tasks jumped from 6.7% to 68.3% - a tenfold increase. Same model exactly, same prompt, just a different editing tool, and the difference is between an agent that almost always fails and one that almost always succeeds.
Behind this jump are two packages everyone's talking about: Pi, a minimalist coding agent written by Mario Zechner, and Oh My Pi (OMP for short), a fork built on top of it by Can Bölük that turned the small idea into a feature-loaded monster. Let's break this all the way down: what each one is, why the fork is gaining momentum, and what's really behind the claim that "this beats Claude Code."
What is Pi - the agent that chooses to stay small
At its core, Pi is a coding agent that runs in the terminal and is deliberately designed to be small and readable. Instead of packing in a hundred features, Mario Zechner gave it just four built-in tools: read (read a file), write (write a file), edit (edit a file), and bash (run commands). That's it. Think of it like a stripped-down motorcycle frame - just the engine, wheels, and handlebars, no extras. Everything else we add ourselves, or we simply ask the agent to write the missing capability for itself.
The idea sounds modest, but the numbers aren't modest at all. Pi has 84,671 stars on GitHub - more than any "serious" framework with dozens of features. Why? Because when the loop that runs the agent is small enough for a developer to read it, understand it, and extend it, it becomes a foundation everyone wants to build on. Pi supports all the major providers (OpenAI, Anthropic, Google, xAI, Groq), connects either with our own API key or through an existing subscription like Claude Pro or ChatGPT Plus, and runs in four modes: interactive, JSON output for scripts, RPC for connecting to processes, and SDK for embedding in our own app.
Oh My Pi: taking Pi and adding everything
Now here's where it gets interesting. The name Oh My Pi is an intentional joke: just like Oh My Zsh is a package built on top of the zsh shell that turned it into a rich experience, Oh My Pi is an official fork of Pi (a copy of the code that's developed further on its own path) that takes the minimal skeleton and bolts on all the hardware. Can Bölük says it explicitly in the code: "originally built on Mario Zechner's wonderful Pi, omp adds everything you're missing".
And that "everything" is big. While Pi comes with 4 tools, OMP comes with 31 built-in tools, support for 60+ model providers, and a Rust core of roughly 80,000 lines doing the heavy lifting. What's inside? Here are the things everyone's talking about:
- LSP wired into every edit. LSP (Language Server Protocol) is the same engine our IDE uses to know "where else is this function called." OMP connects it to the agent, so when we ask it to rename a function it does an actual rename that updates every file that imports it, not a blind find-and-replace.
- A real debugger via DAP. When code crashes, the agent attaches a debugger (lldb for C, dlv for Go, debugpy for Python), stops at the crash point and reads the state, instead of scattering print statements and guessing.
- Sub-agents. It splits a task across several workers, each in an isolated worktree (a separate copy of the code), and returns a structured, verified result.
- "Time-traveling" rules. When the model drifts off track, a rule gets injected mid-stream, stops it, corrects it, and it continues from that same point.
And there are two more capabilities that grab attention. First, running code with a callback into the tools: OMP runs live Python and JavaScript inside the session, and they can call back into the agent's tools (reading a file, searching) through an internal bridge. This way the agent can load a CSV from Python, plot it in JavaScript, and never leave the sandbox. Second, an "advisor" role: a second model that reads every step the main agent takes and injects comments along the way, like a reviewer sitting next to us, running on its own separate context and model to catch what the first one missed.
All of it under the MIT license (fully open source), all of it free. And here's the number that explains the buzz: OMP racked up 22,344 stars in about seven months since it was created (December 31, 2025).
The exciting part: this is "the Harness Problem"
Now let's answer the real question: why would a fork of a coding agent be able to "beat" a well-funded tool from a giant company at all? The answer isn't in the model. The answer is in the harness around it - what Can Bölük calls the Harness Problem (harness = all the infrastructure wrapped around the model: the tools, the command format, the correction loop).
Let's understand his central tool, Hashline. The old problem: to edit a line in a file, the model has to rewrite the existing text word-for-word so the system can "find" it. One stray space, a tab instead of spaces, and the replacement fails. Hashline's solution is simple and clever: when a file is read, every line gets a short signature (2-3 characters) based on its content. Now the model doesn't need to rewrite anything - it just says "replace the line with signature 2:f1." If the file changed in the meantime, the signature won't match and the replacement gets rejected before it breaks something.
And here come the verified numbers. Can Bölük tested 16 models on 180 real tasks from React code, three runs each. The result: Grok Code Fast 1 jumped from 6.7% to 68.3%, MiniMax M2.1 more than doubled its success rate (2.1x), Grok 4 Fast used 61% fewer tokens (because it stopped getting stuck in correction loops), and even Claude Sonnet 4.5 improved by 14.4 points. On average, the Hashline format added about 15 percentage points over the standard editing format, across all 16 models.
Bölük's line nails it: "the model is the moat, the harness is the bridge." In other words, the model's power is the competitive advantage, but the harness around it is what determines whether we even reach it. That's exactly why a cheap model with the right editing format can beat an expensive model with a bad one.
Installation guide: Pi and OMP in a few lines
Let's make this practical. Both packages install easily and run against any model we have a key for. Pi fits anyone who wants a clean base to build on, OMP fits anyone who wants everything ready out of the box.
So does it really "beat Claude Code"?
Here I have to be fair, because reality is more complicated than a headline. In a structured comparison by Standard Compute, Claude Code still leads in 4 out of 6 categories (output quality, autonomy, reliability, and ease of use), while OMP leads in two: speed and value for money. So no, it's not "better" across the board. It's a different approach: open source vs. proprietary, 60+ providers vs. lock-in to a single model, and IDE-level tools that Claude Code doesn't give you out of the box.
To me, the real story here isn't about which tool wins. The story is that Pi proved a small, readable agent can rack up 84 thousand stars, and OMP proved with hard numbers that the harness around the model matters just as much as the model itself. Bottom line: suddenly a model that's several times cheaper, with the right editing format, beats an expensive model with a bad format. That's a shift in how we should be thinking about coding agents.
So next time we're debating which model is the smartest, maybe the first question should be: how good is the harness we're putting around it?