Before I tell you about my customized Pi coding agent setup, I want to briefly mention how any vanilla coding agent is more than enough. I built most of Tuna on a completely stock codex, high reasoning.

You absolutely should not feel that this is necessary. It might not even be a good idea. So many grifters claim you're behind but nobody really knows.

With that out of the way, welcome to the deep end…

The lifestyle

I've gone back and forth through the years on customization.

In my teens, I built my own PC with money earned from my very first job. Picked every part. Put them together. What an adventure!

I hopped on customize.org (RIP) every day. It was a forum dedicated to changing the looks of the windows, the icons and everything else on your system. I spent hours and hours on customizing my Windows XP installation.

My computer and its setup became a project onto itself. I reinstalled Windows so often I could recite the pirated Windows XP key from memory. FCKGW. If those 5 first characters don't bring a millennial nerd rush of nostalgia to your heart, you just weren't there.

And then I fell in love with Macs. At first, by stealing glances at the 2 (total!) guys with iBooks at my highschool. The rebels, the troublemakers. Later by touching and staring at the shiny machines in stores.

After what felt like ages, I had finally saved enough for a white, plastic first-generation Intel Macbook.

I fell in love. The beautiful, fast, powerful UI on top of the solid, ancient, proven unix underpinnings. Quicksilver, TextMate, TextExpander. Apps that tied themselves tightly into the user experience expanded what was possible. I dug in.

Soon, using anyone else's computer felt strange. Like walking in quicksand.

And then I found vim.

Its learning curve was steeper than anything I'd tried before. But the power? And the possibilities? I was determined to become the kind of guy who uses vim. And I was. My dotfiles traveled with me from install to install, from Macbook to new Macbook, never at rest, always open for some new idea. Expanding and contracting but always mine.

Using vim to customize vim had its own sort of self-referential magic to it.

And I still am a vim guy. But more and more seldomly do I pull out the ol' $EDITOR. Coding agents are so good, so precise now, that there's rarely a reason.

First Claude Code crawled then Amp walked and I grew more ambitious and excited than ever. Codex ran and I gave in completely.

The Codex CLI wasn't as fancy as the other two but the models were good. Like, really good. This wasn't just speeding up light, monotonous tasks here and there. Around GPT 5.1 or 5.2, I don't remember, it's all a blur, they became capable of engineering that I was barely capable of myself without it. So I stayed for the model and lived with the CLI.

And then I found Pi.

The Shitty Coding Agent

Pi is like vim. Small, focused core. Clean fundamentals. Just enough.

But this foundation allows it to be near fully customizable. And while vim is too, you need to learn its custom configuration language vimscript. I never really did more than a few lines here and there.

Pi is in TypeScript -- but you barely need to know because you just talk to Pi and tell it to configure itself.

Imagine that.

Imagine telling your kitchen, "I think the cutlery should actually go over there... and let's turn this coffee machine into an airfryer? And the fridge should go here. And every time you're done doing the dishes I want you to send me a message and it should be in the form of a haiku."

Even, "and then only when I'm cooking fries the oven should actually be a deepfrier."

Sorry, I'll stop with this questionable metaphor. But imagine.

Now, the only thing holding you back is the feeling that maybe I should do some actual work instead? Which was always the nagging thought in the back of your mind while you were fiddling with your setup, nerd. Only this time you can dig your own grave so much deeper, so much faster!

Anyway, here's my (current) Pi setup for Tuna development:

The Setup

From, umm, the outside in:

macOS: Least worst OS. I used to love it uncondtionally. Lately, it's complicated.
Ghostty: It's good.
tmux: I'm used to it. I keep projects running in sessions. I use tmuxinator for session bootstrapping. I've done so for 10+ years. Nothing new there.

Ghostty and tmux are configured to add key bindings native to macOS, like cmd + shift + [ and ] to move between windows (tmux for tabs). opt + ← to move cursor whole words.

The workshop

I tried worktrees first in a spawn-on-demand fashion, making new ones ad hoc. I found it distracting and cumbersome. What's working for me instead is to have separate, parallel worktables ready for work. I can work on just one table, and I often do, and when there's more to do while one is busy, I move to another.

Sometimes I have all 4 going. But when I do, I don't want a fifth. Four, one mostly stable main, three active work tables, is hitting the max capacity of my brain. I don't think one more would make me more productive, only more confused.

It's kinda like load balancing but for agentic workloads. My mind can somehow better contain this stable, known workshop than sporadic expansion and contraction. I've even found that I sometimes automatically use the same table whenever the work is of a specific character.

The loop

In Tuna, I track issues using tickets. I used beads before it started to feel like malware and ticket does enough.

I have a Poof snippet that expands to …

Investigate and plan issue [cursor] then $ask-questions-if-underspecified

I've told Pi to recreate Codex' trigger skills inline with $ behaviour. I like the explicitness of requesting them manually.

When Pi starts working, it runs a hook that toggles a bot glyph in its tmux window title.

When done it sends a terminal bell signal which tmux has support for built-in. I just made it display as a cute waving Nerdfont hand glyph.

With a project-local extension to Tuna, I can build and run Tuna from inside Pi with ctrl + space. That's the ▶ just run line above the prompt box. If an existing Tuna process is running, it's killed when the new one starts. No Xcode necessary.

This makes it extremely easy to switch between contexts and worktables. The only reason I ever have Xcode open now is for its SwiftUI previews which sometimes come in handy for the quick feedback cycle.

For review, a ctrl + b g in tmux opens a full-size delta git diff view. For most reviews I just use that.

For proper review with comments, I have a /vim-review extension that opens a vim with the full diff. I can annotate and comment inline and when I quit, the relevant parts get staged as a prompt for Pi to consider.

As tasks finish, I refactor pass, commit and regroup. These are three separate, globally available, generic skills.

1. refactor-pass checks the changes and simplifies. Removes dead code or premature optimization. It's like 15 lines of Markdown and it works surprisingly well to keep codebases clean at the micro level.
2. commit describes my preferred commit message style. Nothing crazy. I'm of the [Imperative] [change description] school. Update docs, Fix billing, that sort of stuff. No chore: whatever.
3. regroup rebases on main then merge --ff-onlyies the work branch from there. I've always preferred a linear git history and when agents can so easily fix rebase conflicts, I don't see why not.

The aesthetics

I like things to look clean. Enough info to be helpful, not so much that it's distracting.

I made Pi replace the existing prompt box with the bordered, annotated one you see above. Over time I added more bits to it, like the git branch and status.

A small model generates a summary of the current task. It has Pi status and some current model info.

Notably, I don't include context size. Contrary to what many smart people are saying, I don't find it necessary to babysit your context size. The GPT models are very good at compacting and carrying over the right bits.

So flushing the context and starting anew is mostly just a gut feeling thing for me. Like how hiding you battery percentage level makes you stress less about your battery percentage level (!) I've found I only unnecessarily worried about context size when I was constantly confronted with it and its cost.

I use GPT 5.5 for everything. On very rare occasions I'll use Opus for some design work but that's going away too. I used to run on high reasoning for everything but 5.5 is actually better on low, curiously enough. I think the models are just so highly tuned for agentic workflows and tool calls now that the extended reasoning just gets in the way.

Overthinking isn't helpful. Such a human thing for a computer to experience.

I made Pi figure out how to run the OpenAI models on Codex' /fast mode by looking at the open source Codex source code and it did. Spends double the tokens (or whatever) but I've never run out on my $200 Pro plan.

I made Pi make a terminal ANSI colors based, Zenbones theme for itself. I switch back and forth between light and dark mode and hate it when tools, terminal tools especially, don't work in both. Keeping things to my 16-color ANSI Ghostty theme makes things much easier. Syntax highlighting, the unicorn vomit kind, is a scam.

The future

I wrote none of the code for any of this setup. I have barely read it. But seemingly it works. I am not worried about this. On the contrary, I find it thrilling that I can just speak my ideal workshop into existence. What a time to be alive.

All of this is shared and copyable from my public dotfiles – however before you do: I would encourage you to instead prompt your own way there. If you want something specific, send the link to Pi and tell it recreate. Modify it to your liking. Get a feel for what it's like.

Now, the future of software... Is this ... it? Will all software be like this where you just tell it what it should do and look like and it does? It's interesting to imagine. Until then, might as well make ourselves comfortable.

Of all the psychoses I've taken part of, this current AI coding one sure is my favourite.

Never have I felt this unlocked, locked in, ambitious and unconstrained by time or skill. And even at 10x (or whatever) the output, I am never done.

Every time I get the thought "I've always wanted this app to do it like this" I can just dream it and build it. Prompt, prompt, prompt, Poof! (Literally.)

Especially for what they call bespoke software: Software just for one. There are many apps but this one is mine.

When turnaround is this fast, you barely have to justify the effort.

I've built my own email app. I use it for 99% of my email reading and writing. It does everything (just about) I need and exactly how I want it to. I can run through a full inbox faster than in any other app I've tried before. (Which weirdly acts as a justification to my whack-ass mind for ignoring my inbox for longer. Can't fix me, apparently.)

It has its rough edges, it's imperfect, it's unapologetically opinionated to my tastes. You can't have it.

It used to be that at least you would open source the work because that way the effort would pay itself back in clout somehow and, I don't know, nerd karma?

But now. Building an entire email app solely for myself isn't an absurd idea. It's already done.

What's that Spellbook.app you ask? Well, it's just the bespoke Markdown reader app I was dreaming of. Unapologetically opinionated. I use it all the time. You can't have it.

I haven't read the source code of either. Just, like, parts of it. I know how they work but not through strict code review.

The first leap of faith is to use codex --yolo and skip the permissions checks. Let the AI run like the wind.

The second is to stop reading the code.

The code doesn't matter. Sometimes – but honestly, most of the time, not. It's not there to be good code, it's there to do a good job.

And when there's only one user to take the L when it eventually wipes your entire harddrive: you – even more so.

I don't think everyone will be building their own bespoke software anytime soon. It's still not easy, it's just faster. Building is a skill but more so it's a personality trait.

This psychosis is the best thing to ever happen to my computer use.

Because I keep running into people in apparent disbelief that coding agents can do Real Programming, I decided to wear it loud and proud by creating a GitHub badge for all my projects that wouldn't have existed without coding agents as Certified Shovelware

– Certified Shovelware by Justin Searls

Here are some agent transcripts of apps and tools I've been building.

Mostly, you just use Codex and talk to it like you would to another human. No weird loops, crazy skill packs or MCP mega structures.

• steve (yaplog)
• dude_suite (yaplog)
• poof (yaplog)
• yaplog itself (yaplog)