1 Why Pi Exists
Mario was initially happy with Claude Code, but over time it stopped fitting his workflows. The core issue: Claude Code's high-frequency release cadence (1-3 releases per day) constantly changed tool definitions and system prompts, breaking his prompt templates, skills, and workflow descriptions. Behind-the-scenes system reminders made models behave inconsistently between days.
Pi is a minimal, extensible coding agent that can modify itself — so it fits your workflows instead of the other way around. Under the hood it has layers: provider/LLM abstraction (like Vercel's AI SDK), a TUI library, a general agent loop, and the Pi coding agent on top.
Mario personally prefers Claude models for prose and GPT for code — though he admits none of this is scientifically evaluated. It's burned-in preference from experience, similar to preferring Solid over React.
2 What Success Looks Like for Pi
Mario's definition of success: keeping a tiny team alive by finding additional value he can sell. The bigger dream is going "full vertical" — owning the entire stack. Pi will remain open source; the moat isn't the code (Cloudflare already copied Pi's design into their "think" abstraction), it's that while others are cloning, Mario keeps iterating.
3 The Full-Stack Vision & Beyond Coding Agents
Mario sees coding agents as just the application layer. Below it are opportunities nobody in open source has tackled — agents for all kinds of knowledge work (like Anthropic's Cowork, Design, Chrome experiments). He's already experimenting: he built a robot with a smartphone MCU powered by a local Pi agent that works fully locally, exposing it safely to his son.
4 Local AI Is Getting Real
Mario's robot runs the full stack locally: Parakeet for speech-to-text, Qwen3 TTS for text-to-speech (~10 GB), and Qwen 3.6 for the LLM (~4 GB). Total: 14 GB of unified memory on a run-of-the-mill MacBook M1 — no beefy hardware needed.
He converted the Python MLX implementations to Rust — because he hates Python as a dependency and wants a single downloadable package.
On frontier-class local models: antirez (Redis creator) built ds4, a custom C inference engine for DeepSeek V4, running on a 128 GB laptop. Mario's partner Armin Ronacher now contributes to it. Mario estimates it handles 60-70% of his Pi issues.
On Demis Hassabis's view: current giant models don't need all their parameters — you can distill them down by an order of magnitude without losing much. Mario's hope: not specialized models, but the same bang for the buck from big models, running locally.
5 How Mario Actually Works — "Absolute Caveman"
Mario describes himself as an "absolute caveman." His workflow for bug fixes and features:
- Queue up issues — open 2-3 Pi sessions, each pulling an issue with a prompt template that fetches all context (references, PRs) and does its own analysis (~5 min per issue)
- Review analysis — check each session, go into the code himself, reproduce manually if hard to test automatically
- Classic back-and-forth — use the agent as a rubber duck until shared understanding is reached. The context accumulates guardrails: interfaces, modules, test specifications
- Say "go implement" — while one agent implements (10-30 min), move to the next session
- Diff review — a custom Pi extension shows a diff viewer where he annotates individual lines with feedback, fed back to the agent automatically
For core mechanics: reviews every change like he would with a human. For non-critical code: "I just say fine."
6 The Three Workflows & Refactoring Vibe Slop
Mario identifies three distinct workflow types:
- Bug fixes / features — the "caveman" process above
- Building new things — "I just slop." Pure vibe coding with no code review, extensive manual testing, no test suite. Good for prototyping (like the robot software)
- Refactoring vibe slop — the inevitable third phase. Once you realize the prototype has real value, you go back in. Two options: rebuild from scratch, or incrementally extract modules
For the robot refactoring: server.ts and client.ts were each 3,000 lines of code. Mario manually defines interface boundaries, asks the agent for options, writes tiny example scripts to feel whether an API is right, then lets the agent execute the plan.
7 Discipline, Atrophy & What Juniors Face
Mario is blunt: agents are a force multiplier but carry real risks of atrophy and loss of discipline. He's struggled with it himself — the temptation to delegate everything inevitably ends with "everything falling apart."
On the narrative "we have too much code to review": "Then how are you expecting to maintain it if you cannot read it?"
For juniors, it's a double bind: they don't want to fail at their first job, so they lean on agents — but during formative years they may have already missed learning fundamentals. Mario's honest answer: "For young people, good luck. My condolences."
8 Spec-Driven Development Is Hyper-Waterfall
Mario's most impassioned argument: spec-driven AI development is just waterfall with extra steps — and it's worse because now you're not even writing the spec yourself, you vibe-prompt an agent to write it.
His logical decomposition: the most detailed spec you can write is the program itself. Anything less leaves blanks — and the agent fills those blanks with "the garbage code we put on the internet for the past 20 years."
Jan-Niklas shares a real experiment at JetBrains: he vibe-coded a terminal bug fix in Kotlin (a language he doesn't know). The developer who reviewed it said "What the fuck is that?" — the PR was utter trash, unmergeable.
9 Code Isn't Actually Free
The episode's thesis statement: "Code is never free because the consequences of your actions will eventually hit you." If you think any amount of code is good now, you just delayed the punishment.
Mario has seen people generate 500,000 lines of code via a swarm of agents in a week. The outcome is predictable.
But he makes a crucial distinction: the real productivity uplift isn't in code generation — it's in solution space exploration. Previously, you had to think intensely to find the one solution worth implementing. Now you can tell agents to explore multiple approaches in parallel, feel the solution space, and then make a better-informed decision.
10 Async Agents, Context Switching & AI Psychosis
Mario's maximum was five parallel agents and he'd never experienced such mental fatigue. The context switching is what kills you. On a good day he can process 30 Pi issues — but he does this only once or twice a month because afterward "my brain is just mush."
He values agents most as collaborative pair-programming partners — "a bicycle for the mind" for thinking through problems, not as an army to manage.
A candid moment: when Claude Code first clicked, Mario went through four months of AI psychosis — building millions of projects, sleeping 3-4 hours a night. He snapped out of it when he realized he was "producing things of no value."
11 The Sloppy Software Wave
Mario predicts 2026 will be "particularly painful for enterprises" — an abundance of sloppy AI-generated software, companies failing miserably, and the industry hopefully learning there are limitations.
But he adds a nuance: "A lot of people don't realize how much lower quality they are actually willing to accept." For a TikTok client, nobody cares if buttons need three presses. For critical infrastructure, it matters. He hopes the industry pendulum will swing — like monolith vs. microservices — and settle in the middle.
12 GitHub Under Clanker Load
Pre-agent open source: 1-2 PRs per week. Now: 50-60 PRs per day, each with a Harry Potter-length description and 10-1,000 file changes. Mario's solution:
- Auto-close all PRs by default
- Require contributors to first write a human-voice issue (no longer than a screen) explaining what and why
- If approved, the contributor gets whitelisted via a GitHub workflow — can now submit PRs without auto-close
- For issues: auto-close, then manually triage 30-60 daily issues, reopening the ~2-4% that survive
At OpenClaw's scale (orders of magnitude larger), even Mario's methods don't work — Peter Steinberger is building fully automated triage tooling.
13 Refactoring Pi's Core
Mario is refactoring Pi's core on main ("I refactor in main, you motherfuckers. I don't care about you and stability"). The goals:
- Multi-UI support — extensions should work on web, native Android, not just TUI
- Remote ability — run one Pi session on a machine, connect from another, with durability and observability
- Universal deployment — deploy Pi agents on Cloudflare Workers, Vercel, anything — not just local bash
- New extension mechanism — server-side components that spawn UI components agnostically
Timeline: ~1-2 weeks for the underlying infrastructure swap (keeping the Pi coding agent looking the same), then a few more weeks for the new extension mechanism.
14 Security, YOLO Mode & Trust
Pi runs YOLO mode by default — no permission dialogs. Mario's reasoning: by making it explicit, he forces people to think about security in their own environment. Claude Code's approach (asking an LLM if a bash command is safe) is "mostly security theater."
The real answer for enterprises: containerize the agent's tools. But that's environment-specific — Mario can't decide it for you.
15 Token Prices, Budgets & Anthropic's Strategy
Mario's take on token economics: prices will not decrease for frontier models. Recent releases increased pricing or changed tokenizers to count more tokens for the same input ("too far, extra sneaky").
His reading of Anthropic's strategy: they marketed to developers in 2024-2025 to collect training data (paying $200/month for the privilege), improved models with that data, gave free Christmas coupons to trigger AI psychosis, and by January every developer told their boss "we need to buy the Claudes." Now Anthropic markets to CIOs and enterprises — they don't need developers anymore.
Companies already allocate different AI budgets by seniority level. Mario expects more pressure on ROI as subscription prices rise.
🎯 Key Takeaways
🔑 Key Takeaways
- Code is never free — 500K lines from a swarm of agents in a week just delays the punishment. The consequences always catch up
- Spec-driven development is hyper-waterfall — the industry learned 30 years ago that waterfall doesn't work, and now it's back in a worse form with vibe-prompted specs
- Mario's actual workflow is caveman-simple — queue issues in parallel sessions for analysis, review each one personally, iterate with the agent as a rubber duck, then let it implement within heavily guardrailed context
- The real productivity uplift is solution space exploration — agents don't save you from thinking; they let you explore more options before committing to one
- Three workflow types emerge — bug fixes (rigorous review), new builds (vibe slop), and refactoring vibe slop (the inevitable cleanup phase when prototypes become products)
- Five parallel agents caused unprecedented mental fatigue — context switching is the killer, not code generation speed
- Local AI runs on 14 GB of unified memory — Qwen 3.6 + Parakeet + Qwen3 TTS on a MacBook M1, no expensive hardware needed
- antirez's ds4 runs DeepSeek V4 on a 128 GB laptop — handling 60-70% of Pi's issues, proving frontier-class local inference is near
- 50-60 "clanker" PRs per day — Mario's solution: auto-close everything, whitelist human contributors after they prove understanding via a human-voice issue
- Pi's YOLO mode is intentional — by refusing to ship incomplete security solutions, Mario forces users to think about containerization in their own environment
- Pi is being refactored on main — goals include multi-UI support, remote sessions, universal deployment (Cloudflare Workers, Vercel), and a new extension mechanism
- Token prices won't decrease — frontier model pricing is going up, tokenizer changes are sneaky inflation, and Anthropic has shifted from developer marketing to enterprise sales
🔗 Resources & Links
- Pi Coding Agent — Mario Zechner's minimal, self-modifying coding agent (GitHub)
- pi.dev — Pi's official site
- ds4 — antirez's custom C inference engine for DeepSeek V4