Fractals of Friction II: Implementation
In Part I, Gergő stripped his editor down until it disappeared. RStudio to VS Code to Neovim: monolith, extensible, fully customizable. Input friction gone. But an invisible editor can only do one thing. It puts letters on the screen. It doesn’t write the code.
Once the editor was out of the way, a new gap opened up. He could navigate anything, edit anything, refactor anything, all at the speed of thought. But the code still had to be conceived, structured, and debugged by hand. The bottleneck moved upstream. Not “how do I type this” but “how do I build this.”
That’s where coding agents entered the picture. And the same three-step progression played out again, at a completely different level of abstraction.
OpenCode was his first real coding agent. It worked the way most early agents did: you described what you wanted, it produced code, you reviewed it and made corrections. Functional. Competent, even. But it had a personality of its own, in the same way RStudio had a personality. The defaults were someone else’s defaults. The response patterns were someone else’s idea of what helpful looked like.
Gergő used OpenCode because it existed, not because it fit. It was a hand-holding kind of tool. Structured, opinionated, and fairly rigid about its workflow. The experience was a lot like his early days with RStudio. You accept the tool’s framing because you don’t yet know that framing is a choice.
Then came Claude Code, and the extensible phase repeated.
Claude Code was more configurable. You could give it instructions, set preferences, define custom workflows. Gergő went deep on this. He built skills, wrote elaborate system prompts, created scaffolding around the agent to shape its behavior. It was, in retrospect, the exact same phase as his VS Code period. Bolt things on. Customize within boundaries. Learn what shaping feels like.
But the core agent was still Anthropic’s idea of what a coding assistant should be. Gergő could add to it. He couldn’t strip it down. The opinions were built into the foundation, and no amount of skill-writing could remove them. He could change what happened on top. He couldn’t change what happened underneath.
The jump to Pi wasn’t as dramatic as the jump to Neovim, but it came from the same place.
Mario Zechner built Pi with a philosophy Gergő recognized immediately: if I don’t need it, it won’t be built. The system prompt was almost empty. The configuration surface was an AGENTS.md file that lived in the project directory. No built-in skills. No default behaviors. No bloat. Zechner had rejected Claude Code’s complexity and built his own harness from scratch, and the result was the same kind of ceiling-less tool that Neovim had been for editors.
Gergő configured Pi the same way he’d configured Neovim. Not by adding things. By removing them. He stripped the system prompt to the essentials. Every unnecessary response pattern was friction, and he removed it. Every behavior that didn’t match how he actually worked was noise, and he silenced it. The agent became quieter, faster, more precise. It stopped having opinions about things that weren’t its business.
He described the difference to me once. OpenCode felt like talking to a colleague who had their own process. You’d explain what you wanted, they’d interpret it through their own framework, and what came back was close but not quite. Claude Code felt like a colleague you’d trained. Better, faster, but still someone else’s brain. Pi felt like a sharp extension of his own thinking. No accent. No interpretation layer. Just: here’s the intent, here’s the code.
This was implementation friction. The gap between having an idea and having it built. OpenCode required translating your intent into its language. Claude Code narrowed the gap but kept its own voice. Pi, properly configured, just did the thing.
The monolith-to-customizable arc had played out a second time. Different tools, different abstraction level, identical shape. RStudio to VS Code to Neovim. OpenCode to Claude Code to Pi. The first time could be coincidence. The second time was starting to look structural.
But Pi, for all its precision, couldn’t solve a different kind of problem.
It could write the code. It could refactor, debug, and scaffold. But every session started clean. It had no memory of what Gergő was working on last week. It didn’t know that he prefers uv run over virtual environments, or that he despises Adobe, or that his vault uses PARA structure. Every conversation began at zero. The agent was sharp but amnesiac. Brilliant in the moment, useless across moments.
An editor removed the gap between thought and keystroke. A coding agent removed the gap between idea and code. Neither could remove the gap between who Gergő is and what the tool understood about him. That required something that didn’t just execute instructions but accumulated context over time. Something that learned by living with him, not by being configured for him.
Continue to Part III: Explanation →