Opinionated and easy Pi.dev configuration | Hacker News Reader

Opinionated and easy Pi.dev configuration

lazypi.org

151 pointslwhsiao74 comments

Pi makes you think about what you’re doing with it on purpose. This defeats that, as the Mario quote on the page says, and therefore isn’t worth using.

People really need to try out “less is more”. The new models are quite smart, so suffocating their context with dozens of MCPs and skills isn’t necessary like it used to be. A cli tool with good built in help and good errors is amazingly easy for the model to figure out.

If Pi is too minimal for you and you don’t want to dig into it, OpenCode is pretty good out of the box. I use it for general work I haven’t setup Pi for. The only thing I add to OpenCode is some commands that are shortcuts to save me typing frequent prompts, and a subagent with a fixed model for implementing changes.

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

No, I don’t think I would. Filling the model’s context with a bunch of junk and actively making it perform worse isn’t the same as adding opinionated defaults/settings. The GPT-5.6 announcement just made it clear that these huge agents files are actually doing more harm than good.

If this just added skins or something I wouldn’t be arguing against it.

Oops. It wasn’t in the announcement, it’s in their Prompting Best Practices. I just noticed it because of the announcement.

https://developers.openai.com/api/docs/guides/latest-model#u...

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 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.

This is so easy to do because we are unable to contemplate every edge case at the time of inception right? At least that is what I am telling myself as I brick myself on a "manifest driven system" that surely will detect drift as I bolt more and more on, right? no... bricked as fah.

At least I am learning to build modular so I can reuse parts like image gen, audio gen (STT/TTS), knowledge management. I have probably built 4 of these systems in the last year, each one gets better and lasts longer until I brick the crap out of it. Super fun.

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".

It's difficult to be very specific, because this was not a formal experiment.

I was using LLM collaboratively to help me setting up and document a home server. I was using DeepSeek for that matter. I tried some tasks on Claude Code and some on Pi.

Subjectively, I felt that it was marginally "smarter" on Claude Code. It would figure things out better, that sort of thing.

I am still using Pi btw. My current set up is using MiMo on Pi as a planner, ans DS in Claude Code to validate/execute the plan.

I may try moving it all to Pi, but I wonder if I should learn how to better configure the things there.

> I may try moving it all to Pi, but I wonder if I should learn how to better configure the things there.

Honestly if the difference was marginal, I would move to Pi. I just tried layzpi and I had the agent write/compile a hello world in c and it required 20k in tokens. My minimal setup required 5.3k in tokens.

People will say the cost is minimal since this is cached but 15k is a lot since that needs to be reasoned by the LLM. I haven't looked at Claude Code but I read somewhere the system prompt is like 20k so I can see how Claude Code might have seem smarter as what you are working was probably addressed in the system prompt.

For me the bloat is not worth it since I am more interested in the LLM being able to reason better.

> The new models are quite smart, so suffocating their context with dozens of MCPs and skills isn’t necessary like it used to be.

Genuinely curious, how MCPs can suffocate the context? And what exactly do you mean by this?

I have probably more than a dozen of MCPs enabled in my Claude Code (slack, jira, github, many internal ones), and I have never seen model calling into them unnecessarily unless it’s explicitly needed for a task. And in the latter case, well, it cannot do much without the right tools access (MCP in this case).

Skills and plugins are a bit of grey zone, yes, but even there it heavily depends on what you put there. Just plugin loading always takes infinitesimal portion of the context in my experience

To let the model know when to call them, you send a list of it to the model as part of the context. Each MCP contains a description and sometimes each tool contains a description.

Tip: You can see the token usage of MCPs/plugins/skills by using `/context`.

For example, the M$ 365 MCP occupies several thousands of tokens, and there's currently no way to disable it entirely in Claude Code...

superpowers front-load 22k tokens before you even hit send and their context inflation balloons after 500k

My first thought when reading about this was, why does Pi with 8 custom skills and one extension work so well for me, and apparently so poorly for others that they are compelled to go to these lengths?

people use different models. I use small local ones for instance

Can this perform "agentic tasks" while using a local ollama instance

Yes, definitely.

Also if anyone wants opinionated and easy pi, oh-my-pi has been that choice for ages

Quite the opposite is true. The agent and the harness is more important than the model on normal tasks. Just for extremely deep problems Fable 5/... are needed.

I'm using oh-my-pi with gortex MCP, context7 and LSP servers. Plus tons of skills. Without that enhancements it's almost useless, missing all the file edits, git amend or fixup strategies, or github api calls.

Currently using Oh My Pi (https://github.com/can1357/oh-my-pi) and appreciate the batteries included approach.

From my limited time using pure Pi, I found quite a few of the plugins lacking and had no desire to upgrade/fix and maintain them myself. I know others feel differently though.

I like the idea of keep Pi minimal but having “official”, high quality optional plugins to make it more usable.

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?

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.

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.

Oh-my-pi seems to like robo coding, while pi itself is entirely against vibe coding for production. (The clanker is a tool, not a free wheeling agent.)

And I see that tonight pi has had their regular devs ship (https://github.com/earendil-works/pi/tags) new releases with modified thinking levels for GPT-5.6 while roboomp is discussing this back and forth with some contributors in oh-my-pi's repo.

To be clear, Oh My Pi isn't simply batteries included like LaziPi. It's a fork with a bunch of foundational extra features built into the core.

I'm exploring the pi based options now and I like that Oh-my-pi actually adds new value over extensions (the advisor and stream interruption hooks are pretty clever).

I just wish it had a way for me to downlimit tool access (I love midsized local models, and I'd love to enable only 30% of the power for some usecases).

This seems to be like the antithesis of pi, it's supposed to be this minimal thing you customise

I guess it's the same kinda friction with vanilla vim/neovim vs vim 'distributions' that provide a bunch of stuff out of the box.

It looks exactly like neovim plugin ecosystem and I was waiting for someone to make this.

I tried pi before but the gap between codex and pi is too big for me to be productive. Ideally lazypi is easy to disable or add plugins as well.

There is also mentioned oh my pi - i recommend trying it out.

I think the developers of Pi made a supply chain mistake by stripping down the core agent and requiring features like subagents to load plugins written by some random person.

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.

> 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?

if you know what you're doing your results will actually be good. what a dumb take.

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.

Not necessarily. I had almost no idea what I was doing when I started using Pi. The goal was to learn harness engineering and understand how it feels like thinking about things that are provided in other harnesses by default.

It took time to learn all of these before I managed to do something similarly useful as OpenCode, and now I am ready to use some sane defaults for things that I really know I need in Pi.

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.

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.

the approach is a plugin_name_spec.md that builds the plugin from plain text.

Sounds like a great monetization strategy. Official/blessed plugins (benchmarked and optimized) + access to open models, all in one sub, competitively priced to match OpenCode subs and I'll switch back over to Pi.

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).

I made my own subagent implementation in a couple of hours using Pi itself. It aligns with my needs better than any existing plugin, none of which seems to be what I was looking for.

You don't _need_ to use someone else's plugin if you don't want to, and for simple functionality, you can get pretty good resulting rolling your own.

On the one hand, sure, why not have a default install throw a bunch of bells+whistles via skills and extensions.

But I like pi precisely because it is so minimal. I want understand and work around the simplest possible agentic coding setup, find the sharp edges, maybe even improve my prompting ability. And doing all three with a locally hosted LLM.

At some point, if I don't understand the foundations, am I just punting on actually thinking about what I'm doing?

Of course, making individual choices about how to do agentic coding are precisely just making individual choices. People should do what makes them happy and productive.

60+ ! oh my, while this is cool it seems that is overkill. I want to know all my skills back and forth.

But I like this kind of projects where I can peak of what extensions other people use. Is like .vimrc file back in the day. Do not clone blindly, but peak, learn and copy what is needed.

This thing defeats the whole purpose of Pi.

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.

Yes, because neovim != vim :)

> 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.

What AGENTS.md and skills are people relying on these days?

I have little to none and am successful building full stack Go apps Claude Code, Codex, and Shelley which covers the spectrum of crazy black box to simple `bash` clanker.

It makes me think the models are continually improving in knowing what to do on their own.

I do put some major work into the classic "Developer Experience" (DX) of my code base. Standard Go tooling, idiomatic Go, well designed initial test harnesses, GitHub actions that enforce some linting.

I think that works better than any markdown instructions ever will.

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.

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

My Claude.md is a maybe 30 lines. I only adid something if it repeatedly does something that annoys me.

It still tends to do those things, but maybe 40% less.

I can understand someone being overwhelmed and not wanting to configure and "build your own pi" which is really one of the beautiful points of pi, but like with vim, I do recommend that after playing with this for a while you go back to pure pi and then decide what do you really need and incrementally add it.

The power of the incremental in control approach is huge. It allows you to keep moving in whatever direction you want instead of taking yet another dependency.

Second this. I went back to vanilla zsh after oh-my-zsh. Turns out I really just wanted 2 features that are built into zsh, and a custom prompt that includes git info that I just wrote myself in ~20 neat, readable lines of shell (minus the ANSI coloring).

I maintain vim and neovim confugs, never going with a distribution of plug-ins, and can't imagine how grotesque those must be.

The difference here though is that zsh and vim are old projects. My configs with them never break. I can't say the same about neovim, and Pi also probably isn't stable.

Pi is perfectly usable in its "raw" state (except perhaps an extension for your specific provider, if not built in).

Configuring it isn't really overwhelming: you use it for a while and then find that you'd want to extend it with some particular functionality.

> 67 themes

Hm. Most users usually need 0 or 1 of those at a time. Makes me question other choices in there.

> One command. Everything configured. Nothing to research.

Being talked at by someone's AI copypasta feels like being in the Truman Show.

"Why don't you let me fix you some of this new Mococo drink? All natural cocoa beans from the upper slopes of Mount Nicaragua, no artificial sweeteners!"

"What the hell are you talking about? Who're you talking to?"

How risky is pi-claude-cli? Don't want to get the account banned.

I've been using oh-my-pi for a while and I'm very happy with it. If you're not going to build out your own Pi setup I'm not sure why you'd pick this over oh-my-pi.

I want to use Pi, but I don’t trust the npm ecosystem at all. I could use a VMs, but I guess it’s just not worth it

haha i was waiting for this exact thing lazyvim:vim::pi:lazypi, thanks for sharing

If you like OpenCode, there is a vim input plugin (only one I use) https://github.com/Tarquinen/opencode-vim

I am not going to use this, I think, because I believe I am at the point where going through the "process" with Pi will be valuable to me.

But it's a useful list of things and they are links.

I like peeping at other people's skills but it is unclear to me what/where the claimed 60+ skills are actually located. Compound Engineering conveys a few but nowhere near 60.

"One command installs 60+ community skills, 67 themes, MCP support, sub-agent support, Claude Code CLI provider support, memory, and more."

What, no kitchen sink?

Is there a popular well support add on that like lets me hitl/interact with my phone while not at my desk?

i think to fall in love with Pi, bundled skills are a bit antithetical - you realistically only need a couple of skills that you maybe design yourself

For me, the benefit of pi is what it doesn't do.

Why does this makes more sense over OpenCode?

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.

Just use the web/desktop app and you won't need to.

Now you have 2 problems. That freaking thing is a memory hog in itself and guess why - ELECTRON.

It's like supply chain attack on steroids! /s

Reply on news.ycombinator.com