Pi is meant for people who know what they are doing. If you dont fall into that category use OpenCode, etc. The whole idea is that you customize Pi to your own needs by asking it to modify itself through extensions.

That said, sometimes it is really easy to leverage existing extensions. You run the risk of supply chain attack though. I installed one extension that was useful, modified it to my needs and pinned it.

I personally find OpenCode's TUI atrociously awful, I guess a matter of taste.

The memory footprint of Opencode is prohibitive to run 10+ copies at once.

As AI outsider, can you speak to how you draw the line here? Like doesn't the agential blahblah make upgrades/maintenance trivial?

When do you get it to make you the thing versus choosing to vendor something out like back in the day?

We are going to address this. Not by loading the agent but by finding a way to provide official plugins or blessed plugins. But we’re not yet sure what the right approach is.

ironically (?) i prefer to improve Pi by connecting MCP servers instead of native extensions in part due to this (process-level sandboxing is trivial; anything more granular -- as would be required for in-process plugins -- is far more intimidating).

Nothing in (AGENTS|CLAUDE).md, no Cursor style rules. Just some skills for Jira/Confluence, CI, and Playwright.

Haven't bothered doing any extra customisation in Claude Code or Codex as I don't really trust those things to apply consistently. And if you can run your CI steps locally before you push you don't need to tell an agent to remember it.

That said I've been playing with pi today and given how stripped down it is I've used it as a sandbox for customisation. Still, I haven't gone quite as far as laying down project level instructions. More that Claude Code in particular is quite heavy, and so it its prompt, and adding stuff like rich integration with GitHub and SourceHut (CI status, active branch or PR) seems comparatively trivial in pi.

Only thing left to do is switch out ghostty for the time being as it's misbehaving. Laptop hot to the touch even after idling overnight.

Would you say the same about something like, say, Spacemacs?

I’ve tried quite a few, from oh-my-openagent’s gargantuan hooks+plugin system to minimal add-i like wozcode, and I’ve been most impressed by that (wozcode) and oh-my-pi. I get that pi is supposed to be roll-your-own but I think OMP’s config is a great starting point; pi removed all the fluff and OMP added just enough orchestration and tooling back in to take things to the next level. Wozcode is great if you like CC because it doesn’t mess with the fundamentals, it just adds things like batching for efficiency—CC’s system prompt alone is absurd.

Caveat: I’m a data scientist/researcher, not a professional SWE, so take my experiences with a grain of salt. I’m just a python monkey most of the time

I use lazyvim for all my neovim config. Does it fly in the face of the configurability or minimalism of vim? I'd argue no, but rather it is an expected outcome of a highly configurable system. Some people don't want to think about this kind of thing, they just want something that works.

I like the Pi approach, but I think I didn't "hold it correctly" so to say.

I would like to migrate away from Claude Code and use Pi as my "peimary" harness. I really like in particular how it manages conversation trees and branches.

But I think I didn't do a good job in customizing it for my work. While nothing dramatic, I think the LLM I was using did a better job on Claude Code than on Pi a couple of time when I tried giving it the same work.

I was not sure how to improve on it though.

That’s why Mario said “YOLO” is enabled by default from what I remember—something like, I want you to think about what you’re doing.

> Pi is meant for people who know what they are doing

How many people genuinely know what they're doing when the value prop of Pi is basically to vibe code it to your taste? The entire point of vibe coding being that you don't actually have to know what you're doing?

Funny you mention that because the OMP GitHub issues (https://github.com/can1357/oh-my-pi/issues) is almost exclusively attended to by a very efficient bot. I routinely submit issues and they’re replicated and resolved (via PRs) in ~30 mins.

To your question: it’s the difference between one person and an agent working on something vs an experienced dev and the entire community.

Time and tokens too of course.

Making the upgrades or maintaining or crafting from scratch a plugin isn't free, it costs tokens and time and attention. And you're almost assuredly reinventing a wheel that someone else already did and probably did better. I like have the ability, but I prefer not needing it.

If you're going to have "blessed" plugins, which seems like a good idea, you'll need a review and possibly hosting process.

- Review to check that the plugin is reasonable quality/isn't malicious.

- hosting (e.g. the plugin is retrieved from a repo. you control) or "known good" checksums so pi will only download the plugin with a version that you've reviewed.

From a security/supply chain aspect, ironically what you're looking to do is deliberately add some friction to the publishing process, which sounds bad, but can be quite effective at mitigating attacks. Most of the recent supply chain attacks get found by automated scanners in < 24 hours, so having a review process for new releases that takes a while will reduce the number that affect users.

I think having this is handy as it'll give security conscious users more confidence in using pi, without the anxiety of pulling a load of additional code from effectively random sources.

> Does it fly in the face of the configurability

Probably not.

> or minimalism of vim?

I'd have to say at least a bit? Which is totally fine if it works for you, but there's gotta be some amount of extra features added after which "minimal" stops being a good description.

Edit: Although, we should also acknowledge that minimalism is a sliding scale. Compared to plain vi, vim is bloated. Compared to a full blown traditional IDE, lazyvim probably is minimal.

Yes, because neovim != vim :)

What was lacking? This is self promotional but I am working on

https://github.com/gitsense/pi-brains

which is designed around the Pi philosophy of less is better by focusing on ondemand context/guidance. I won't bloat the context unless the LLM needs to do something I know it will need better guidance with. I have a demo repo for this at https://github.com/gitsense/gsc-rules-demos

One of the examples is, if I know the agent is reading a specific file, I will inject additional context. So if the agent never needs to do something in a certain file or directory, I don't need to pollute the context with "what it may need to know".

That’s why I like things like oh-my-pi and lazypi, nothing’s stopping you from modifying it after you install; I find that when I’m working on my own sometimes I brick myself into a corner and it’s nice to see someone else’s starting point for reference.