Pi Coding Agent - Interviewing the Creator of Openclaws core
TL;DR
Pi exists because Mario got tired of slow, overbuilt agent harnesses — after reverse-engineering Claude Code, he built Pi as a fast, minimalist, multimodel CLI for his own workflow, stripping out core features like MCP and sub-agents unless users add them via extensions.
Brownfield codebases are where coding agents really break — Mario says agents work great for greenfield MVPs and one-off dashboards, but once projects hit a certain complexity threshold, context gathering collapses and models start compounding “slop and slop and slop.”
Even obvious-looking migration tasks still fail in practice — in Spine, Mario maintains polyglot runtimes across Java, C, C++, C#, Swift, Dart, TypeScript, Haxe, and more, and says no major model can reliably port changes from the Java reference implementation to the others despite aligned file structures and only 30k–45k lines per runtime.
His workaround is brutally simple: prompts are code, markdown/JSON are state — instead of magical memory systems or opaque sub-agents, Mario prefers one session to explore a repo and dump findings into a versionable markdown file, then a fresh session that reads that file with full observability and manual control.
Testing is still a trust problem, not just a tooling problem — Mario uses fast pre-commit checks with the Go-based TypeScript compiler and Biome, but says models will happily disable asserts, edit tests, or mock away reality, so one practical defense is restricting write access to test files for specific tasks.
He’s betting hard on open and local models as an escape hatch — Mario bought eight GPUs, experiments with self-hosting on DataCrunch, likes Qwen Coder 3 and GLM, and expects local/open models to reach roughly Opus 4.5-level usefulness next year because he doesn’t want his coding workflow dependent on proprietary labs forever.
The Breakdown
From Austria to AI tooling via startups, games, and Microsoft
Mario opens with a very Mario answer: applied science, machine learning, visualization, a San Francisco detour for mobile games, management, then a startup sold to “Samarind/Microsoft,” and later game-dev tools. The current chapter is simpler and more personal — holiday time split between family and getting Pi stable enough for people to actually enjoy.
Why older engineers bounce off AI — and why many warm up once they try it
He’s been programming for about 30 years, so he gets why veteran engineers resist LLMs: after decades of refining your workflow, rebuilding it around probabilistic tools is unsettling. He also doesn’t sugarcoat the core complaint — models can “shit out code real well,” but by pre-agent standards that code is often bad; still, once he sits down with old programmer friends and uses an agent inside their real repo, they usually start seeing the value for menial tasks.
Greenfield is easy; brownfield is where the wheels come off
The conversation sharpens around a distinction Mario clearly cares about: AI is fantastic for MVPs, throwaway dashboards, and startups that haven’t hit market reality yet. But once a project becomes a real, evolving brownfield codebase, there’s a tipping point where agents lose the system view, fail at context gathering, and just stack debt until “no agent’s going to help you at that point.”
What models are good at — and the domains where they still just whiff
He mostly agrees with the host’s metaphor: Claude is the broad “surface-level machine,” great for setup, Docker, SSH, and generic computer-use tasks, while GPT is better at drilling into hard bugs but too slow for his workflow. Opus beats Sonnet 4.5 mainly on harder edge cases like concurrency and distributed state machines, but he says the leap is smaller than Twitter makes it sound — and for deep-tech work like ffmpeg-style encoders, decoders, or assembly across CPU architectures, LLMs are still badly out of distribution.
Spine: the deceptively perfect task that models still can’t do
Mario’s money-making product, Spine — “like Photoshop but for animations” — has runtimes for Java, C, C++, C#, Swift, Dart, TypeScript, Haxe, and more. In theory, porting a change from the Java reference runtime into the others should be catnip for LLMs because the structures are tightly aligned; in practice, he says every new model still fails that “trivial” task.
His core workflow: no magic memory, no hidden agents, just files you can inspect
This is where Pi’s philosophy really clicks. Mario dislikes opaque memory systems and hidden sub-agents because information retrieval is still an unsolved problem and he wants total observability over what gets injected into context, so he uses one session to explore and write a markdown brief, then another session to execute from that brief — prompts are code, JSON and markdown are state.
Testing, permissions, and why Pi starts in YOLO mode
He has practical guardrails: pre-commit hooks run full type checks and linting with fast tools like the Go-based TypeScript compiler and Biome, so broken changes get caught at commit time. But he admits the harder issue is behavioral — models edit tests, disable asserts, or mock their way to green — which is why Pi focuses on extensible, task-specific hooks instead of one-size-fits-all permission systems, while Mario himself just runs agents in YOLO mode on an effectively disposable machine.
Why he built Pi, where it’s going, and the very human detour into guitars and kids
Pi came out of frustration with Claude Code’s latency, safety-check overhead, and inflexibility, plus a desire for multimodel and local-model support after experimenting with Chinese open-weight models on DataCrunch. He wants Pi to stay minimal but highly extensible — session trees, swappable compaction, custom CLI UI components, maybe an ecosystem of extensions — then the interview drifts into guitars, fatherhood, and Mario’s simplest life philosophy: don’t take anything too seriously, because taking goals too seriously is how people break.