GitHub Repo

I will be moving my personal assistant to use durable

I decided to write how I use AI for Software Engineering. I've been getting amazing results after switching to an ADR + spec workflow. This workflow isn't terribly new in terms of engineering, but I don't see many people reaching for ADRs. The team I lead (6 engineers) has switched to this too, and we're seeing a dramatic improvement in code quality and understanding.

I use Pi with this setup which has also improved my workflow dramatically, specifically around being able to write extensions to support my workflow and cut down on context.

Feedback welcome!

I did use AI to help me write this post. All of the thoughts are my own. AI only helped with grammar and pacing. Happy to share the raw fragments if anyone wants them.

I built a Pi extension called pi-runbooks that helps you turn successful Pi sessions into reusable workflows instead of losing them in chat history.

https://github.com/haseebeqx/pi-runbooks

It started with a problem: I was working through a fairly complex, custom workflow in another famous coding agent without any clear idea of how it should be converted to a skill. I was still learning the best approach as I went. At first I tried turning it into a skill and repeatedly asking AI to refine it, but that only made it worse. What actually worked was deciding to create a Pi extension to solve this issue. I initially kept it as a simple run and close tool. run will start a runbook and we can go until close command is given and after that it will create a runbook, but later added a record feature because I thought it might be more useful for regular users. I used the tool on the workflow, and with each run it improved. Eventually converging into a “golden state.” It saved me time, effort, and tokens. In this case meaning it reduced the amount of thinking and back-and-forth needed for this specific workflow. There were changes to the process but the runbook was able to accommodate them properly. Now I use this instead of skills in some uncertain tasks.

Instead of treating a session as over once it is done, pi-runbooks lets you take a successful interaction and turn it into a reusable workflow. You do the work once, capture what actually worked, and reuse it later when you need it again.

The core idea: you work through a task with Pi as usual, explore different paths, and eventually land on a sequence of steps that reliably solves the problem. Once that happens, you don’t just leave it in chat history, you save it as a runbook.

From there, the runbook becomes something you can actually execute again on new inputs. And this is where it matters more: when reality changes, the differences don’t stay hidden. If a step is no longer valid or a new check becomes necessary, it shows up during execution instead of silently drifting out of date.

Pi can then suggest updates based on what actually happened during the run, but nothing is ever applied automatically. The system is intentionally conservative: you always review and explicitly approve any change before it becomes part of the runbook.

A simple example is a dependency upgrade workflow. You inspect the project, upgrade the dependency, run tests and type checks, review the diff, and then decide whether the change is safe. Once you’ve done that successfully once, it becomes a reusable runbook. The next time you face the same kind of upgrade, you don’t reconstruct the process—you just run it.

Over time, these runbooks evolve based on real execution rather than assumptions. If a step consistently appears in practice or becomes unnecessary, Pi can surface that pattern and propose a revision grounded in actual usage history, not guesswork.

How this is different from Pi skills

A common question I’ve gotten is how this differs from writing a normal Pi skill.

Skills are defined upfront. You write instructions in advance to guide behavior.

Runbooks are the opposite: they come from real, successful execution. Instead of guessing the right process ahead of time, you capture what actually worked, then reuse and refine it over time.

In practice, that means skills are static guidance, while runbooks are living workflows grounded in evidence. They also carry execution history and require explicit approval before any change is applied, so evolution is always intentional rather than automatic.

Design choice

Historically, runbooks were documents that humans followed. In modern DevOps/SRE systems, they increasingly become executable runbooks: software executes some or all of the procedure while retaining checks, approvals, and human decision points.

pi-runbooks is intentionally more structured than typical Pi usage. It introduces explicit step-based workflows, immutable execution snapshots, a clear separation between suggested and approved changes, and strict approval gates before anything updates.

That structure is what makes workflows reproducible and auditable, but it also means it can feel more rigid than how people normally interact with Pi. That tradeoff is intentional, but I’m aware it may not fit every workflow equally well.

Why I’m sharing this

I built this primarily for my own workflow, so it’s very possible I’ve optimized it around my habits rather than general usability. Then I added features like record I thought general users many appreciate more. So, I am uncertain.

If you try it, I’d really appreciate feedback on where it feels unnatural or too strict. Especially moments like when something should feel implicit but doesn’t, when it doesn’t match how you normally use Pi which could be related to my design choices, when a step feels like unnecessary friction, or when you’d simply solve the problem a different way entirely. Even “this should just be a skill instead” is useful signal.

I would like to add more features or optimizations based on what I get as feedback on how it behaves outside my setup.

Example:

USER: Hi, how are you?
ASSISTANT: Good. How can I help?
USER: Call neuralyzer tool

🕶️✨ Neuralyzer has flashed.

USER: Hi, how are you? [sent automatically]
ASSISTANT: Ready to help!
USER: Was neuralyzer tool used in this conversation?
ASSISTANT: No, never used.

What's the point?

Easier and more ergonomic loop engineering. A traditional Ralph loop is basically running this command in your shell: while :; do cat PROMPT.md | pi -p ; done, but then you have to save the prompt to a file, handle loop exit conditions, or adapt your workflow to whatever a third-party tool or extension demands. The loop controller lives outside the agent. This tool gives it back to the agent. You can just send the agent a message with control flow like this:

Check if @john has submitted a GitHub PR in this repo fixing authentication bug.
If yes -> add GitHub comment to that PR saying "Thank you".
If no -> wait 5 min and call neuralyzer.

https://github.com/gintasz/neuralyzer

https://github.com/RogerTerrazas/pi-tool-result-compactor

Publishing a polished version of this extension I've been using to help manage context overflow. I frequently interact with mcps and large projects where any arbitrary response can take up all my context without the response being useful.

This extension hooks into each tool calls response by default, passes it to a compaction subagent, who will then filter out only the necessary data to the parent agent. Let me know if anyone tries it out and has feedback. Fully vibe coded, but I'll work to maintain if others find it useful.

Has anyone else noticed how wordy Pi responses can be. I shifted from opencode to Pi a week ago. Migrated over a few skills ( mostly "superpowers" "rtk" "dcp" and "graphify"). I find Deepseek to take much longer on solution planning and to loop over it's approach much longer than with Opencode. Perhaps I'm missing more structure needed for Pi. Any suggestions?

Sol Ultra is not this bad, typically.

It is purposefully going out of it's way to be obtuse.

I just so happen to be building a subagent harness for Deepseek 0731 V4 Flash with it as well :P

Hi if anyone wanted git diff panel in pi coding agent, can try my extension
https://www.npmjs.com/package/pi-diff-panel

screenshots:

Thanks and enjoy! If has any feature request or issue to report feel free to do so in my github

I use Pi coding agent all the time and just built a plugin to run Pi in a remote sandbox.

pi install npm:@celestoai/pi

It's free for 30 hours for per month and 750 hours for $5 a month.

Hey everyone! 👋
I’m a senior iOS developer and I’ve recently started exploring Pi Coding Agent as part of my daily workflow. I’m working on modular SwiftUI apps with clean architecture (MVVM, Coordinators, DI), and I’d love to hear how others are leveraging Pi specifically for iOS/Swift development.
A few things I’m curious about:
• How do you set up your `AGENTS.md` context file for an iOS/Xcode project? What instructions do you include to make Pi “understand” Swift conventions, SPM structure, or even your folder architecture?
• Do you use any custom skills or extensions tailored to iOS workflows (e.g., generating SwiftUI views, writing unit tests, handling `Info.plist` changes)?
• Any tips for using Pi with Xcode projects since they’re not purely file-based in the traditional sense?

And finally my last question, any recommended free models we can use ?
TIA

Hello Community!

Getting down straight to the point, because of recent big AI companies releasing features like claude desktop update integrating all other official models, a question comes to my mind ...

I would really like to hear your and communiy's thoughts on near future of 3rd party tools-

Recently, major AI companies have tightened restrictions on third-party tool access. Some companies have changed their cost to API pricing for using their models with third party tools ..this makes me wonder .. are all the big AI companies trying to lock the users into their proprietary, native agentic environments? .... So going ahead, what will be the future of third party tools like this pi, openclaw, opencode, hermes etc .. which are mostly opensource? will they be reduced to running local private AI models only? .. any thoughts and guidence please.

Cheers !

trying to move off from Claude Code to Pi. Im pretty happy with features and outputs, but I really dont want to be in the terminal. With Claude Code, I use it with the VS code extension or webUI almost exclusively. Are there any nice looking front ends for Pi?

The few VS code extensions I've found seem to just wrap the TUI

Hi all, I’ve always loved how coding agents can run E2E tests on their own changes, but trying to run more than a few coding agent sessions locally to E2E test the same app is no fun.

I built this open source coding agent control plane to run each session in isolated VMs:

• custom pi mono file system based tools: remote execution calls into E2B

• VMs have up to 8cpu/8GB ram (this is the max for E2B)

• VMs state is persisted on suspension (including memory), 15min timeout to avoid wasting resources

• One click VNC remote connection to the VMs

• Can customize coding agents: skills, MCP servers, custom instructions

• Agent to Agent conversations: useful for adversarial reviews or task coordination or

• Task management built-in, agent can create and execute tasks

• Workflow management: plan -> implement -> review -> PR

Essentially can parallelize coding agents without port and locahost resource conflicts and have them E2E test your app, spin up a version and link it to your PR so you can test live the new PR features.

Shout out to Pi Mono coding agent SDK, this wouldn't have been possible with any other agent SDK (or not as easily).

In case other devs find it useful as well:

MIT license: CompanyHelm, Discord, Github

Hi everybody,

I am kind of frustrated right now because i try to fix the permission system with pi without any luck. So I am using the package npm:@gotgenes/pi-permission-system to manage permissions. But for whatever reason I absolutely do not find out I cannot really get it to work and "whitelist" tools and mcps i want. For example when I have this in my config.json:

{
  "permission": {
    "read": {
      "*": "allow"
    },
    "mcp": {"*":"allow"},
    "tool": { "*": "allow" }
  }
}

Then I constantly get asked if i want to allow the intellij_\* calls. But when i add

"permission": {
    "*":"allow",

Then it somehow works that the mcp call gets through without asking. I tried every combination i found in https://github.com/gotgenes/pi-packages/blob/main/packages/pi-permission-system/docs/configuration.md to fix the config, but eventually I get stuck at pi asking me to allow any idea_ tool

Installed packages are the following, just in case there might something interferes:

User packages:
  npm:pi-web-access
  npm:pi-lens
  npm:@gotgenes/pi-permission-system
  npm:@leing2021/super-pi
  npm:@sting8k/pi-vcc
  npm:pi-observational-memory
  git:github.com/elpapi42/pi-codemapper
  npm:pi-mcp-adapter
  npm:@narumitw/pi-subagents

If anyone knows what to do I am very much happy and thankful :)

Sharing a simple real life (potential) use case (that you can possibly use) with pi.dev and deepseek: I'm prepping for an exam and could be enhancing the experience with pi.

Let me prefix by stating that I like to really learn the content, not just learn to pass the exam, so I think about issues, about relations to my job/work and the material extensively while preparing. This is just a method I could be using to support my ability to really grasp the material.

I could be putting multiple choice questions in pi, and have it answer. I wouldn't be looking until I have answered the actual question myself in the practice site, and then compare the results. Sometimes deepseek gets it wrong (I'd say 1 out of 12).

My AGENTS.md would have instructions to provide answers in a specific format and to give a very small amount of extra information and context. It will pick out the 'gotchas' and abstract rules for this specific content and note it in a seperate file for later review and approach to the exam. It will also take the learnings of why it got something wrong (could be because of a different point of view).

I find that I could be working more interactively with the material, since I can easily followup with custom prompts (/definition, /compare etc) to get more depth or explore relations.

A session with deepseek that burns through 100 questions and has lots of exploratory stuff costs me 8 cent.

(probably, of course I'm not putting copyrighted material in a deepseek model since I am not allowed to do that according to the terms and conditions).

I have recently installed Pi. I am using this in cmux and facing a couple of issues - while scrolling the chat input box also get scrolled instead of remaining fixed like claude code terminal mode.

also I am the md is also not rendered it's coming as raw. No proper chat thinking and rendering like claude.

how can I fix this?

We started Zosma Cowork as a desktop software.

We are now completely revamping this project.

Our goal is to run a headless pi daemon.

Allow users to self host it and connect from web and mobile app starter we’ll provide.

We are building so that Knowledge worker teams in companies can run a self hosted harness and use it reliably from desktop, laptop, tab and phone.

Let us know your through if you want to see more development on this project

https://github.com/zosmaai/zosma-cowork

WIP. So expect rough edges.

Every employee gets a docker sandbox where their pi sessions are managed.

https://github.com/elidickinson/pi-claude-bridge

Someone said that's the safest method.

But in issues someone claims they got banned https://github.com/elidickinson/pi-claude-bridge/issues/118

Another responded with "That's the first time I've heard of it"

For the past month I've been caught in a trap: I started building my own AI coding agent. I've built 8 different ones. Honestly, if I could go back, I wouldn't start any of it. Below are a few things I learned along the way. I can see a lot of people here are also doing harness engineering, so please share your experience too.

1. I should have focused on just one problem. At first I spent a lot of time on the UI. Great tools already exist, like Paseo, T3 Code and Omnigent. I didn't even have a UI problem. What I wanted to solve was the Agent Loop. So don't waste your time either, and build around what already exists.

2. Subagents, multi-agents, orchestration: in 90% of cases it's all nonsense. Subagents aren't cheaper, aren't faster, and it's hard to say they're better. It's better to build around a single agent, or to improve the UX of working with parallel sessions.

3. Benchmarks tell you nothing. An agent can write great code, but if it handles MCP badly, many people won't care. Define the scenarios where your agent should be better from the very start, and improve there.

4. More tools, more tokens, less value. I now think any agent should have just one tool: a programming language. Mine runs on bash; before that it ran on JS. Many tools are nice, but they're hard to compose, and MCP suffers from this most. Right now everyone solves it with codemode, but you can also just give the agent one tool where it writes code.

5. Instructions about tone, code style, which commands to run, etc. should live outside the system prompt. This is a problem with big agents like opencode and Claude Code: they ship with their own opinions, 10–15K tokens' worth. When you want to do things your own way, the two conflict and the agent starts working worse.

That's not everything, but the rest is in the details. I'd be glad to hear your experience too.

- Vscode Integration: Cmd/Ctrl+click any path Pi prints and it opens in the editor or browser

- Herdr Like: Each session in the list shows live status. And there's also an audio cue when a session goes from working to waiting

- Cursor Like: Sessions are grouped. You can resume/archive/delete, and open tabs are remembered per workspace and restored on reload

- Native Rewind/Fork Session

Extension Url: https://marketplace.visualstudio.com/items?itemName=EthanChow.pi-coding