◉ Overview
Ben Davis follows up on his first-impressions video to share how Pi has become his primary daily coding agent, replacing Codex and everything else. He runs GPT 5.5 on low reasoning exclusively through Pi and has built a fully open-source custom setup with extensions for web search, git workflows, background agents, and more. The video dives deep into the extension system, compares Pi to Neovim's customization philosophy, walks through his Cmux-based terminal workflow, and showcases both his own and Dylan Mulroy's Pi configurations to demonstrate how two developers can build radically different agents from the same minimal foundation.
1 Why Pi Became His Primary Agent
Ben opens by explaining that since his first-impressions video a couple of weeks ago, Pi has become his main day-to-day coding agent. He's no longer using Codex much — he's doing everything with GPT 5.5 on low reasoning through the Pi harness.
- Previous workflow — was using Codex, T3code desktop app, and various other agents
- Current workflow — Pi in the terminal with GPT 5.5 low, multiple instances in parallel
- "This one is different" — the way Pi works is fundamentally unlike any other coding agent
2 The Minimalist Core
Out of the box, Pi is the most minimal of any coding agent. It ships with:
- Four tools —
read,write,edit,bash - A super simple system prompt
- A clean, functional TUI
- Nothing else — no MCP, no sub-agents, no permission popups, no plan mode, no web search
Remarkably, Ben argues this is actually enough for a great experience. Modern models have become so good at working with bash, reading files, writing files, and exploring file systems that four tools is all you really need. But you can go much further with the extension system.
3 The Neovim Analogy
Ben draws a sharp analogy between coding agents and text editors:
- Open Code = VS Code — great defaults right out of the box, opinionated, beautiful UI, accessible to a large audience, works with all model providers, even has free models built in. Extensible but not infinitely customizable.
- Pi = Neovim — minimal out of the box, infinitely customizable, builds into exactly what you want it to be. Every user's setup looks completely different.
The critical difference from actual Neovim: Pi eliminates the learning curve. Neovim 4 years ago required hours of manual config work, trial and error, and learning Lua/Vimscript. With Pi, the learning curve is just telling the Pi agent to do it. You describe what you want, and Pi builds itself.
4 The Extension System
Extensions are the heart of Pi's customizability. Ben was initially skeptical — he assumed they'd be like extensions in other programs (adding a command here and there). He didn't realize the depth of customization possible.
How extensions work
- TypeScript files — plain
.tsfiles dropped into the extensions directory - No build step — loaded via jiti, no compilation needed
- Global or project-local —
~/.pi/agent/extensions/or.pi/extensions/ - Self-documented — Pi ships with handwritten markdown files explaining the extension API. The default system prompt exposes these, so Pi can read its own docs and build extensions for you.
Live demo: creating a hello world extension
Ben asks Pi: "How do I make a custom Pi extension?" — Pi reads its own extensions.md from node_modules, explains the process, and creates a working /hello-world slash command in under a minute.
Extensions vs. Skills — a key distinction
Ben explicitly prefers extensions over skills for many use cases because:
- Skills are always semi-injected into context — the name and description are always visible, even when you don't want them
- Extensions are only triggered when explicitly called — doing
/yeetor/tx9only injects context at that moment - This prevents unnecessary context pollution and avoids the model accidentally triggering capabilities you want manual control over
5 Hot Reloading
A standout architectural feature: Pi is fully hot-reloadable. In other coding agents, changing config means restarting the entire process. In Pi, you just run /reload and all extensions, skills, prompts, and themes are picked up immediately without losing your session or context.
This creates a tight feedback loop: ask Pi to create an extension → /reload → use the new extension — all within the same session.
6 Terminal Workflow with Cmux
Ben has moved away from desktop apps (T3code, Codex app) back to the terminal because Pi works so well there. His workflow uses Cmux — a terminal multiplexer released a couple months ago.
Workflow layout
- Cmux sections — one per project, switch with
Cmd+1,Cmd+2, etc. for multi-project work - Split view per project — left side has multiple Pi tabs (one per task), right side has the dev server / terminal
- Parallel Pi instances — one for back-end, one for front-end, each in their own tab
- Zed editor — opens when he needs to manually read or edit code
He's aggressive about creating new threads — when a task is done, he copies context, opens a new session to clear the context window, and moves on. This keeps each Pi instance focused and lean.
7 Session & Context Management
Ben describes Pi as "the ultimate coding agent for when you're paying attention to the code" — not vibe coding, but thinking deeply about what you're doing. The session management tools support this:
/copy— grab the last message as context to paste into a new session/copy-all(custom extension) — copy the entire thread (all user + assistant messages, without tool calls) for transfer to another session/new— start a fresh session with a clear context window/resume— go back to an existing session/tree— visualize the full message tree with user messages, tool calls, and assistant responses for easy traversal
Research → implementation pattern
A typical flow: use the BTCA skill to research a codebase or API, run /copy-all to grab the full research conversation, open a new session, paste the research in as context, and start implementing with a fresh context window. The new agent gets full context of the research without the noise of tool calls.
8 Ben's Custom Extensions
Ben's full Pi config is open-sourced on GitHub. He walks through each extension:
Core extensions
copy-all— adds/copy-allto copy the entire thread (user + assistant messages only, no tool calls) to clipboard for pasting into a new sessiondiff—/diffshows all files changed during the last turn. Selecting one opens it in Zed for reviewfirecrawl-search— replaces the web search he misses from Codex. Uses Firecrawl's search API + scrape tool to convert any web page to LLM-readable markdown. Preferred over Exa for pricing and qualityyeet— inspired by Theo's Claude Code script./yeetauto-adds, commits with a message, asks to push, and optionally creates a PR. "If I'm done with a change and want to push to prod, I do /yeet and it's done"zsh-over-bash— ensures!inline commands use ZSH so completions and PATH work correctly
Specialized extensions
flow-title— custom Pi title renderingoc— instructions for connecting to and managing his Open Claw instance on a Mac Mini via SSH over Tailscaletps-tracker— shows tokens-per-second at the bottom of each response (e.g., "140 tps" on GPT 5.5 low)tx9— a personal background agent system. Snapshots the current project, sends it to his Mac Mini, kicks off a coding agent there, and lets him review/pull results later. "Kind of the G-stack thing where you're creating a program out of markdown"usage— calculates usage across all agents (Pi, Codex, etc.) for cost tracking
Why extensions instead of skills?
Ben repeatedly emphasizes: skills are always semi-visible in context (title + description), which means the model might trigger them unwanted. Extensions like /tx9 or /usage only inject context when explicitly invoked via slash commands. This is critical for capabilities you want manual control over.
9 Dylan Mulroy's Pi Setup
To drive home the "Neovim of coding agents" thesis, Ben showcases Dylan Mulroy's completely different Pi setup — demonstrating that two developers using the same agent can end up with entirely different tools.
Notable extensions from Dylan's setup
update— adds/updatecommand and--updateflag that detects the install method and auto-updates Pi. Ben liked this so much he added it to his own setup live during the videoephemeral— a UI for selecting project-local skills, prompts, extensions, and MCP servers that are not loaded by default. Perfect for MCP servers like Greptile that are useful but shouldn't always be in context. "Ephemeral skills that can only be triggered if you explicitly add them"pi-cloak— marks sensitive text so you don't accidentally leak API keys on streamwhimsical— makes Pi more playful and whimsical in tone- Exa web tools — Dylan uses Exa instead of Firecrawl for web search
- Custom to-do tool — built-in to-do tracking (Ben doesn't personally use this pattern)
- Pi MCP — MCP support added via extension
10 Building Extensions Organically
Ben's recommendation for building out your Pi setup:
- Don't plan upfront — don't sit down and brainstorm all possible extensions you might need
- Start minimal — maybe just a theme, or nothing at all beyond the defaults
- Build as you go — when you catch yourself doing something repetitive (3-4 times), that's the signal to make an extension
- Just ask Pi — describe what you want, and Pi creates the extension for you
He demonstrates this live by seeing Dylan's /update extension, asking Pi to add it, doing /reload, and immediately using /update to update Pi — all in about 30 seconds.
🎯 Key Takeaways
🔑 Key Takeaways
- Pi replaced everything else — Ben uses Pi + GPT 5.5 low reasoning as his sole coding agent, dropping Codex, T3code, and desktop apps.
- Four tools is enough — read, write, edit, bash is a complete foundation. Modern models handle the rest through bash.
- Pi is the Neovim of coding agents — minimal core, infinite customizability, every user's setup looks different. But unlike Neovim, the learning curve is just asking Pi to build itself.
- Extensions > skills for manual triggers — skills are always semi-visible in context; extensions only inject when explicitly called via slash commands. Use extensions for things you want manual control over.
- Hot reloading is transformative —
/reloadpicks up new extensions, skills, themes, and prompts without restarting. No other agent does this. - Cmux + multiple Pi instances — run parallel Pi tabs per project (one backend, one frontend), split-view with dev server, switch projects via Cmux sections.
- Aggressive context management — use
/copy,/copy-all,/new, and/treeto keep sessions focused. Research in one session, implement in another. - /yeet for git workflow — one command to add, commit, push, and optionally create a PR. No more manual git commands.
- Build organically, not upfront — start with nothing, add extensions when you catch yourself repeating something 3-4 times.
- Open-source your setup — Ben's and Dylan Mulroy's configs are both public. Use them as references, not templates — customize your own.
🔗 Resources & Links
- pi.dev — Pi Agent official website
- davis7dotsh/my-pi-setup — Ben Davis's open-source Pi configuration
- dmmulroy/.dotfiles — Dylan Mulroy's dotfiles including his Pi setup
- Cmux — terminal multiplexer used in Ben's workflow
- earendil-works/pi — Pi Agent GitHub repository