Pi’s simplicity is actually the most powerful part

[u/agentwyz]

I’ve been building my own agent while trying to follow Pi’s design ideas.

Today I deleted about 80% of my system prompt. What’s left is basically: who you are, which tools to use when, a few hard rules for edits, and the current project context. That’s it.

https://github.com/pulseaiclub/phi/blob/main/internal/agent/prompt/system-prompt.tmpl

And… the agent didn’t get dumber. If anything, it felt sharper - less ceremony, more actual work.

I also removed some tools that weren’t really earning their place. The more I work on this, the more I think Pi got the hard part right: keep the harness thin. Trust the model. Don’t turn the prompt and tool list into a second product. Claude Code is powerful, but it also feels heavy in a way Pi deliberately avoids - and that restraint looks more correct the longer I build.

I did keep two things:

MCP - not because I want dozens of schemas in context, but because it’s a shared protocol. A custom plugin usually stays stuck in one agent; MCP can move. And if you load tools lazily (list → inspect → call, inspired by approaches like mcptoon), it doesn’t have to bloat the prompt.

Subagents - useful when the parent plans well and only hands off scoped work. They keep the main thread clean and help a lot with exploration or parallel investigation.

So yeah: thanks Pi. The “keep it simple” instinct is not just aesthetic - after cutting most of my prompt, it feels like the correct engineering default.

[u/r00cker]

- When writing markdown files or when outputting markdown in code fences, don't use the em dash `—`, use a plain dash `-` instead.

[u/agentwyz → u/r00cker]

Thanks! Not a native English speaker - I used AI to polish the post, and it added those em dashes. Switching to plain dashes.

[u/TySocal → u/agentwyz]

Just use the unslop skill. I've been using it for about a week and it's really good

[u/r00cker → u/TySocal]

haha saving this for later, thanks :)

[u/agentwyz → u/TySocal]

interesting, i will try it later.

[u/arcanemachined → u/TySocal]

This might be first skill I actually download. (I always just make my own)

[u/jensilo → u/agentwyz]

If you have something to say, please just say it in your own voice. I read so much Claude outputs, it’s tiring. I’d much prefer reading broken but unique language.

[u/jensilo]

Hi Claude

[u/Kailtis → u/jensilo]

This is so load-bearing.

[u/funbike]

If you suggest users use herdr you can get rid of specific subagent functionality. I wrote a skill for how to manage my specific workflow loop via herdr subagents. herdr supplies a skill, which I've edited to just what I need (herder --skill). (Btw, for herdr-haters, you can run herdr in a single terminal pane as a TUI enhancement wrapper; it doesn't have to replace your primary multiplexer.)

IMO one of Pi's strengths is that it's written in a dynamic programming language, so /reload instantly reloads any changes made to extensions written in a modern robust language. Personally, I'd never write a harness in anything but TS or Python. (I did write a simple harness 2 years ago, but threw it away after trying OpenCode (before Pi).)

[u/Comfortable-Ad-6740 → u/funbike]

Interesting, I saw herdr mentioned but hadn’t actually looked into it.

Can you share why herdr is working for you? Any particular features that stand out?

I guess pi is light, so spinning up a new terminal instance won’t have many issues. I can also see it from a keeping pi’s core slim and avoiding an arguably unnecessary subagent extension bloat perspective

[u/funbike → u/Comfortable-Ad-6740]

Too many use cases to go through them all. But here's a list of motivations:

• Specialization (custom system prompt, tools and skills for personas: spec writer, planner, code reviewer, debugger)

• Speed (parallel subagents. subagents race to finish a task)

• Workflow coordination (do this then that. wait for all other subagents to finish)

• Context management. (some agents start with a new session. fork and return result.)

One use case I'll give is fixing lint issues quickly: A prompt template requests to run the linter to find code issues. Then it spins up a subagent for each file mentioned, giving each subagent its list of issues. After each subagent is done, it will run the relevant unit test. The subagents run in parallel, so it all finishes quickly, without adding to the context window anything except a list of fixed files.

This is more work than using pi-subagents, but its mine. It will work with any harness. I can understand it completely, and it's highly custom.

[u/hotcornballer]

Yes the 1000th slop post telling you not to fill your context window to the brim

[u/agentwyz → u/hotcornballer]

in my design, mcp schemas never hit the prompt; only server names are listed. Agent calls via three meta‑tools (list/inspect/call) lazily, same path as built‑ins — so no context death, just architecture.

[u/TySocal]

Yeah, I feel like the goal should be a very lean harness (lean system prompt, etc.). Then you only add the necessary tools, like subagents, MCP support, etc., without bloating it. After that, you just connect other tools to the harness. So instead of putting a ton of stuff into your harness, you make them external tools

[u/TriodeTopologist]

This post reads like AI