Pi: A Horseman of the Anthrocalypse - and My Preferred Agentic Harness

In this little ramble, I'll be waxing poetic about my love for the agentic coding harness Pi, why it has completely removed Claude Code from my local workflows, and why I think it might be one of the horsemen of the Anthropic apocalypse (the "Anthrocalypse", if you will, hehe).

Dog Bless Claude Code

I was, mildly speaking, a late adopter of agent-accelerated software development. On top of that, I was aggressively sceptic regarding the capabilities of LLM-powered agents - and rightfully so, as I see it. Because I had been using ChatGPT pretty much since it was released, and seen both the tooling and models get smarter and more sophisticated. But there kept on being this hurdle, which they could never seem to clear: The problem context.

As I see it, most software engineering problems will usually have their solution guided by 3 main dimensions: The problem at hand, the toolbox at your disposal, and the context the problem exists within. That third dimension is the real heavy-hitter, and where "Software Engineering" truly earns the "engineering" portion of the name. It contains all sorts of opposing interests and blockers: The business context the solution needs to exist in, the current existing systems in the context, including every single right and wrong decision made up until that point in time, budget and resource constraints, security constraints, organization constraints - the list goes on indefinitely, and when we talk about tradeoffs being one of the core pillars of software engineering, a ton of them are found in the context, even before we start being able to formalize system qualities and functionality.

And bringing any sort of software problem into the LLM chatbots of the early generative AI days, would always be limited by the complete absence of any context, aside from what you could be bothered to type out, and pass to the agent. And once they got done hallucinating a proposed solution, you'd enter the circus of trying to have it debug its own proposed solution, once that solution collided with the reality of the context that the solution was pasted into.

The only other alternative was Co-pilot, which sucked. Sorry, but my word, what an awful user experience. I used it, but I genuinely doubt if it ever made me move faster, and it monopolising my tab key had me needing to undo over-eager, verbose, and wrong suggested solutions just as often as I accepted them, if not more.

So I was by no stretch of the imagination a believer in using agents to build software in any meaningful capacity. The combination of a completely disconnected workflow full of friction, and the sub-standard solution output, had me demoting the chat bots to being research assistants and rubber ducks to debug against - to their credit, I enjoyed them for both of these purposes! But there was never a second where I believed they could reasonably take over even the job of the most junior of developers.

So needless to say, nothing could have ever prepared me for the generational double-whammy that Anthropic was about to serve both me, and the software industry at large: Claude Code, and Opus 4.5.

You mean to tell me that the model can actually produce good quality code now? And that I can work with them locally on my machine, where they can get significantly more context by actually seeing the code base they're operating within? And they can use tool calls to evaluate their own work? Well colour me surprised, spooked, and intrigued.

Once some of the software engineers I look up to the most, like Steve Yegge, Kent Beck, Martin Fowler, and DHH, started speaking favourably about this new way of building software, I knew I had to either adapt, or to some extent be left behind by my industry - a fossil at the age of 29, barely 5 years into my professional career.

Luckily, I found myself really enjoying it! I still felt a bit like I was riding a bike with training wheels on, trying to work out how to best work with this brand new powertool, but I was having a ton of fun playing around with it.

But the more I played around with it, the more I found little points of annoyance, and the more I dove into the communities built around agent-assisted software engineering, the more it became clear that the rabbit hole ran deeper than "just" Claude Code. I was of course very aware of there being other models out there, but the existence of other harnesses was news to me - unsurprising, given the nature of software engineering, but news to me none the less.

And that's when I stumbled upon Pi.

The Heavy Crown of the First Mover

Before diving into Pi, let's talk a bit about the both incredibly powerful, but also very tricky position, that Anthropic find themselves in.

The release of Claude Code shook the industry, and gave birth to an entirely new category of products: Agentic harnesses. This was a huge step towards solving a large portion of the grievances I had with using LLMs to assist with my day-to-day work, and created an entirely new corner of the industry, where the token economy would suddenly be brought to the center of attention: How much bang for your buck could a subscription at any LLM provider get you?

Being the first mover on a fundamental industry shift like agentic coding harnesses, is obviously massive for any company. You not only put something into the market that nobody else is doing, but you get to be synonymous with this very type of product to most people. We still see the effect of this with just how many people refer to LLMs in general as "ChatGPT", or who might even think this is the only LLM chatbot out there. And if you were to be unfortunate enough to scroll LinkedIn as frequently as I do, you would see a similar pattern with coding harnesses - almost all the posts are about Claude Code, with little to no indication that the average poster knows that other harnesses exist.

But, and of course there is a but: When you define an entirely new product category, you also leave yourself wide open to other people looking at what you made, and going "we'll offer a similar value proposition and set of functionalities, but addressing every single complaint that specific user segments might have about your current solution".

And since Anthropic's Claude Code naturally is locked to only working with their Claude models (you can sort of hack your way around this, but it isn't the intended use) and Anthropic subscriptions, one of the big ways that new harnesses can differentiate themselves, is by being completely model and provider agnostic. Claude Code does offer some extensibility and customizability options, but is still largely forcing you into a specific shape of working. So naturally, harnesses built around being fully customizable and configurable down to the smallest details, might catch the eye of engineers (famously a people not fond of perceived bloat and lack of control). And where Claude Code is fully proprietary and closed source, one very powerful way to differentiate oneself could be by being fully open source.

So that's naturally what ended up happening, initially with the creation of the OpenCode harness, and subsequently with the creation of Pi.

My 2 Cents on Anthropic Currently and Their Main Product

If you're a software engineer, and your social media algorithms are tuned around that, it's really easy to get the impression that Claude Code is the main thing Anthropic are doing. But make no mistake: Anthropic's main product is, and will always be, the Claude model family. They naturally build a ton of tooling and interaction mechanisms around these models, and I'd take a not-that-wild-guess that Claude Code is by far the biggest revenue generator out of those, but it all ultimately boils down to giving people more avenues to interact with, and pay for, the models in optimized manners.

This state of affairs makes it extra peculiar to me, that Anthropic has, until and including the time of writing, taken such a hostile stance to open source coding harnesses, blocking them from using the Anthropic subscriptions in the harnesses. You can still use a usage-based billing model, but that quickly becomes a radically different budget post compared to the 20 USD per month subscription tier.

Try as I might, I just can't get it to add up - they're still getting the same amount of money from me, which is spent directly on their main product: The Claude model family. Let me use those the way I prefer to do so. I don't think Claude Code is part of the Anthropic moat in any meaningful way - if their models fall behind OpenAI's models or any open weight model, then developers will leave them behind. Claude Code won't be what keeps them around, since the harness is only ever as useful as the models that it has to be paired with.

Far be it from my goofy ass to give advice to one of the most valuable companies in the known universe, but it has almost never played out well for software companies to take hostile stances against open source software. Anthropic's recent fear-mongering, constant calls for regulation, and murmuring about needs for legislative action, makes them feel less like the hot, trailblazing AI lab redefining the world and the software engineering industry, and more like, well, Oracle. And I can't claim that being Oracle is necessarily a bad thing, but not a lot of innovation has ever been born out of tech companies that spend more time talking about legal action, and less time building with and for the developer communities.

And when the day comes that some other lab rolls out a family of models outperforming Claude, it's hard not to wonder if the first mover advantage can undo months of opting for fear-mongering, siloing, and general hostility, when users need to choose which LLM-based product to reach for.

I personally still strongly prefer the Claude models for pretty much everything. But they have been showing fluctuating performance, with some days being noticeably worse than others. As we approach the bursting of the AI bubble, and as we get closer to facing the reality of what the token economy actually has to look like to be sustainable, there's a high chance that the little edge that Claude models still have, that unique little something, might not be worth neither the cost difference, the trouble, nor the, as I see it, increasingly bad vibes emanating from the company.

Enter Pi

The first time I heard of Pi, was when its creator, Mario Zechner, was a guest on the Pragmatic Engineer podcast - a brilliant episode, which I highly recommend. He talks extensively about his motivation for making Pi, and a lot of the points resonated heavily with me: The bloated feeling of Claude Code, the lack of control over the system prompt, the lack of transparency in how Claude Code handles your agent context, and the lack of in-depth customization and tuning support.

He initially tried out OpenCode, but found similar issues, especially pertaining to the harness messing with the model context in not transparent ways.

So he did what many software engineers do when they get sufficiently annoyed with the product landscape of a category of tools that they need: He built his own.

Pi is an incredibly barebones out-of-the-box agentic coding harness, with a strong system for adding extensions through NPM, and support for the models extending the harness itself baked into the harness from day one. This means that anything you would like to add to Pi - and you'll most likely want some additions, because it truly is incredibly minimalistic by default - you just ask the model to build on its own, or dive into the rich ecosystem of extensions.

The harness exposes everything to the user, and you can freely edit your system prompt. I've never tampered with it myself, and find the default Pi system prompt to do the job just fine, but you get the choice to do so, which is the important part here.

The harness doesn't even have MCP support out of the box, and is built around the idea that as long as a model has access to a bash shell, there's really not much more it needs. You can of course add MCP support, and there are plenty of extensions doing so! I haven't done so yet, and I have yet to miss it either, so that's a level of tool bloat that I'm happily avoiding.

Similarly, it also doesn't have a /plan mode by default. Once again, you can just add that yourself - I had my model build it on its own, although I admittedly use it less and less (Mario has strong opinions on how useful /plan modes actually are - go check out some of his podcast appearances or tech talks for those).

But the creator's preferences and beliefs are sort of besides the point, because you can just add whatever you're missing. There's a huge ecosystem of any extension you can imagine, and you can make your harness as simple or as complex as you wish.

If any of you had the pleasure (I hope) of reading my post about switching to Linux, you might recognize this approach as being pretty similar to the philosophy behind Arch Linux, my distro of choice. Terrifyingly bare bones out of the box, and then you build exactly what you want and need on top of it - nothing more, nothing less. That obviously appeals to a very specific type of user, but I am decidedly that type of user, and I love Pi for everything it is and is not - I damn well should, most of what my local Pi setup is was defined by me.

While this level of minimalism might not be for everyone when it comes to their computer's operating system, I think a lot of people would be surprised at how nice it is when it's just your agentic harness. If the only harness you've ever worked with is Claude Code, I really recommend taking Pi for a spin. The little bit of a learning curve initially, will leave you with a better understanding of harnesses, and as a result, a better understanding of how to work with agentic coding assistants. Just like I experienced with my switch to Linux, having access to the internals of a system, inherently invites you to be more curious about it, and gets you tinkering with things you wouldn't have thought of before.

My Current Pi Setup

Anyone who managed to get through my rambly essay on why I switched to daily-driving Linux, might recall my description of my Arch Linux setup. My Pi setup echoes a lot of the sentiments made there: It's light, does very little, and is heavily tuned to how I like to work.

At the time of writing, my installed extension list looks like this: @grammeaway/pi-clip, @grammeaway/pi-path-complete, @grammeaway/pi-provider-sakana-fugu, DietrichGebert/ponytail:pi-extension, elpapi42/pi-fork:src, init.ts, pi-observational-memory:src, pi-web-access, plan-mode.ts, statusbar.ts, usage.ts.

plan-mode.ts, statusbar.ts, usage.ts, and init.ts are all small, local extensions that I had Pi itself write. They're all small, and just add a few things I wanted to have to the harness: Plan mode (which I use less and less), a small status bar with various metadata about the ongoing session (which model is being used, which git branch, which dir), a token/session limit usage overview, and a small greeting splash screen displayed when opening the harness.

The only external extensions I have installed, are:

• DietrichGebert/ponytail:pi-extension: A Pi extension for the popular Ponytail agent configuration collection. Helps tackle one of my most hated LLM-isms: Their rampant verbosity in everything they do, as well as their tendency to over-engineer everything.
• elpapi42/pi-fork:src: An extension allowing a model running in the harness to easily spawn multiple subagents to do e.g. investigative work.
• pi-observational-memory:src: Helps keep agents coherent across long sessions, by introducing observational memory to the harness. Handles e.g. context compaction and knowledge handover between sessions.
• pi-web-access: What it says on the box - lets agents running in the Pi harness access the internet, when researching or debugging.

I even built and published a few little quality-of-life extensions of mine as NPM packages (all the @grammeaway tagged packages in the overview above), with some of them having at least a few weekly downloads, a couple of GitHub stars, and even some forks! Those tools are:

• pi-clip: A buffer storing code and command snippets produced by the agent, to easily copy them to your clipboard. Solved my issue with copying commands from the harness being incredibly error-prone.
• pi-path-complete: A file path auto-completion extension, making it faster and simpler to reference file paths in the harness chat input. Addresses the very simple issue that I often found myself typing out file paths, to give models references from our other repositories.
• pi-provider-sakana-fugu: Adds support for the Sakana Fugu model orchestrator. Built because I wanted to try out Fugu on the release day, and there were no other extensions available supporting it. I didn't particularly love Fugu (the 20 USD subscription limits at the time allowed you to achieve next-to-nothing per 5 hour window, and the weekly limit was gone after just a few 5 hour windows - might be better now, but I haven't touched it since).

This is by no means my final setup, and I'm always looking for new extensions that might improve model performance, or remove friction from my workflows. And who knows, maybe I'll eventually fall in love with another harness, and move everything onto that instead. But for my current preferences, Pi scratches pretty much all itches I have, and does so while being much, much lighter than e.g. Claude Code, while making me feel in control of my own workflows and tooling setups. I also won't deny that I love not having this quintessential part of my workflow be vendor-locked to any specific AI lab.

The Direction of Agentic-Accelerated Software Development

I don't think there's much point in trying to predict what will come next, in terms of the still incredibly fast-moving world of generative AI. I expect most of the points in this post to age like milk - hell, I somewhat hope they will! Because if they don't, then that would be a clear-cut sign of innovation in the agentic-accelerated software engineering domain grinding to a halt, and doing so very early in its lifecycle.

But if I were to give it a somewhat careful go, the main thing I expect to happen is a huge adjustment to the token economy, as a response to some sort of AI bubble burst, which I fully expect to give birth to new innovation in terms of how cheaply/easily people can self-host models.

There's no telling whether the burst will cause the damage of the "dot-com bubble" of times pre-dating me entering the industry, but something will very obviously have to change, and there's no doubt it will introduce constraints. Luckily, constraints tend to breed innovation and clever solutions, and if you keep up with e.g. the HackerNews front page, you will see more and more posts where people manage to get huge models running on somewhat every-man hardware. Similarly, some AI labs have focussed their efforts towards having their models doing the same, by being clever in how they manage their parameters. In both cases, they're not yet running well, but running none the less - hopefully we can keep innovating on the quality part, but baby steps and all that.

The other main development that I expect to see, is that open harnesses will slowly, but surely, swallow the harness market, the same way that open source software often does when it comes to software tooling. Nothing moves faster than a community of developers and maintainers trying to make something the best it possibly can be, and the power of people always being able to make a fork of something to fix things they're unhappy with, will lead to ample choice for any type of developer.

And what I'm hoping to see, is that the aforementioned FOSS-takeover of the harness "market", will lead to the frontier AI labs opening up more, sharing more, and making it easier for agentic-accelerated software engineering, to reach its next stages of development.

In a recent episode of the Pragmatic Engineer podcast, Kent Beck made the point, that it took 15 years from the initial creation of object oriented programming, until the publishing of the agile manifesto - that's how long it took for us to reach a proper milestone in how we work with these things, in an optimal way. Generative AI is much, much younger than that, so the only guarantee is that we still know very, very little about how to best work with these new tools, and how to maximize our efficiency when using them.

I'll try my damndest to not be an old man yelling at clouds about these tools going forward, while simultaneously staying wary of the oh-so-incredibly-toxic-and-unproductive hype culture around them, and keeping in mind that there are still no silver bullets in software engineering - not in 1986 when Fred Brooks first published the evergreen paper, and not today.

Pi - a Horseman of the Anthrocalypse?

So is Pi a sign of bad things to come for Anthropic? Are they a gust of wind, threatening to topple the mightiest house of cards in the software world right now? Was the title of this post nothing more than a mediocre portmanteau used for clickbaiting?

Well, yes and no - nothing in software nor in business is ever really this black or white.

But the popularity and demand for harnesses like OpenCode and Pi, and Anthropic's reluctance to allow subscription users to use other harnesses, happen to collide with their product quality gap lessening, and large players in the open weight ecosystem launching models that perform on almost even footing with the best Claude models.

There's far too much capital backing Anthropic, far too much talent gathered there, and they have far too strong of a proven innovation track record, for me to ever declare them as facing an "apocalypse". They'll be either the leader of the AI race, or at least one of them, for a long time going forward.

But as other AI labs start catching up, as the open weight models start performing on equal footing, and as the token economy approaches a large adjustment, it seems clear that having the marginally better model likely won't be enough to keep the software engineer customer segment around. And I currently don't think Anthropic are positioning themselves all that well in terms of retaining that segment, with the constant fear-mongering and pushing for legislative action, which might end up draining any goodwill that could have kept the community around when the time comes.