r/PiCodingAgent

except for the lack of multimodality lol

Sorry for the silly question, but I am wondering:

Reading the docs, the main requirement is access to Bash and they recommend Git Bash. That's easy, sorted. But when using Windows Terminal do you invoke Pi from PowerShell or Git Bash?

Pi will run from PowerShell (7) but will firstly try to use PowerShell commands and syntax. It will loop over logic a few times before it thinks to use Bash.

So I have been having issues with pi actually knowing how pi works. I got interested in the fact that pi.dev claimed pi actually knows what it is somehow and actually knows what to do with it's structure, creation of extension e.t.c. Although, I have been having issues where I talk with pi and it thinks it's Claude code or simply doesn't know where and what to do, doesn't respect my AGENTS.md and goes rogue. Is that something you may have come across? Is it possible that this happens because I have restructured my file directories differently than most pi.dev setups? Any ideas?

How do Pi users vibe code structurally? I'm used to using GSD with claude code and I dont want to slowly peck away at a project. GSD allowed to be able to group work together and work in a systematic way.

Do Pi users use a framework or something?

I dont want to use [pi-gsd](https://github.com/gsd-build/get-shit-done/discussions/1649), id rather use a tool that is supported by the creator

im certain Pi doesn’t lack ability. But using it on its own to write code will lack structure.

Is there a way to do spec driven development with Pi?

I'm trying out the Codex Pro plan as i migrate away from Github copilot in prep of the changes coming June 1st and I'm noticing some differences.

The key one being codex's version of 5.3-codex seems more hesitant to actually make code changes, it just tells me it's going to begin implementation but then the turn just stops. When i prompt it that it can proceed, it does the same behaviour. If i run the same prompt using github's 5.3-codex, it reads the proper files and then just started editing/writing.

has anyone else experienced these kinds of differences with the same model but different provider?

Ive been using claude code with gsd and would like to do the same with pi, is gsd supported in pi?

• are you using a frontier model (anthropic/openai etc) ?
• does Pi produce better results/lower usage than claude/open code?
• a lot of pi's functionality is tied to the models intelligence. how well does it work with cheaper llms, eg chinese/open source, and local llm's?

switching from expensive cloud plans to a somewhat affordable local llm setup (eg with 16gb vram, I dont mean $4k gpu's) is something a lot of people want to do. with occasional use of a frontier llm of course, they can't be replaced totally yet. Has anyone done this, and does Pi help in this?

Hey guys,

I’ve been theorizing about a different context management paradigm for Pi, and I’ve been building out an extension that implements it. Before I spend a ton of time building features no body cares about, I wanted to get some community validation and feedback on the core concept.

I've personally wanted more control over the agents context and I've been seeing a growing meta where we rely on multiple rounds of review for AI agents. The initial implementation is often expected to just be 'ok,' and then burns tokens through multiple review cycles. I think we can vastly improve the initial implementation right off the bat by fixing context pollution and/or context absence.

The original idea was swiped from Claude Code, where you can set up folder-specific rule files that only load context when certain directories are accessed. I really like their idea, but I think I don't think the Claude team has cared too much about it. That's why Pi has had me so excited, because I can actually control how files get injected and shape the context properly.

So I've built an extension called pi-rules. Which introduces localized rules files and inventory files.

Here's how the paradigm works:

• Rules Files: Allows you to enforce coding conventions and architectural rules specific to different parts of your codebase. It allows you to have far greater control over the agent's context. I want to add more support as time goes on, to where each directory can even have it's own prompt and tool availability.
• Inventory Files: I also added inventory files that contain the basics of how to use each function, and you'll be able to have them load dynamically. So if you have a bunch of shared functions, then they can be loaded into the agents context and should help cut down code duplication during the implementation. They can also help with navigation, because instead of the agent just reading a directory tree and guessing, the inventory file tells the AI exactly what components, hooks, or interfaces are available in that directory, and how to use them.
• Auto-Maintenance & Injection: I also have built in auto maintenance and injection. Whenever you prompt, it automatically injects context based on what you're talking about, and then when the agent makes edits, a Node subprocess (using a semaphore to handle concurrency) updates the inventory files so they never go stale.

Why I think this matters:

• Architectural Control: It allows us to set hard guardrails per directory.
• Workflow Flexibility: You don't have to use this just for in-conversation injection. You could easily plug this localized context into your custom review agents or pipelines.
• Future-proofing for Local/Lower-end models: Frontier models are so good at brute-forcing search and implementation right now that this might just look like a nice token-saver. But if API prices stop getting subsidized, or if you want to run local/cheaper models, an efficient context harness like this is going to be wildly important.
• Context engineering: The whole idea behind Pi is giving us more control, and I'm trying to extend that to the context even more. I want to be able to control a lot more of how the agents are thinking and viewing my codebase.

What's next / Roadmap:

• I want to eventually expose the API of the injection and maintenance so that anyone can build off of this. I also want to build a implementer and reviewer agent that is entirely integrated into this paradigm, but I want leave those as optional so that anyone could build their own.
• I'm going to add way more config this week, so injection/maintenance and everything else can be tuned to different environments.
• Add TUI syntax so you can reference rule files by name instead of @ing all of them. Which should also allow you to easily reference the rules in any plan files, which I feel like would be cool.

I'd love to hear anyone's thoughts and ideas on this! If anyone wants to collaborate on this that'd be awesome.

Here's the npm package I just have a beta version up right now, so it may be a little buggy.

Here's the github

Has anyone tried the pi rust port https://github.com/Dicklesworthstone/pi\_agent\_rust ?
It’s supposed to be an official port of pi to rust.
I can see it has some benefits in extension execution and shell execution and some others. Why nobody is talking about this?

many coding agents support web search tool from scratch, which search tool did you suggest to use with Pi?

I tested the regular brave-search and it seems to be very weak...

At work I get unfettered access to gpt 5.4 and sonnet, so I'm quite used to spawning sub-agents to go crazy on a repo and split up tasks.

At home I am VRAM poor and like to run the models locally for my own enjoyment. Almost every single sub-agent extension/implementation does not account for any of the restrictions imposed by having 10gb of VRAM and a single slot for a KV cache (thats already quantized).

I already work as a developer, so I qwen3.6-35b-a3b tagged teamed a partially vibe-coded fork of an existing sub-agent repository for pi coding agent.

This is really only relevant if you:

• Use pi coding agent as your harness
• Can only run a single LLM at a time with 1 slot via llama.cpp server
• Want to use sub-agents without fully reprocessing your prompts after the sub-agent is done

Repo is here, feel free to use it or fork it idc. I am also interested in how others around here have dealt with sub-agents on a purely local and VRAM constrained setup. I was also planning to add the ability for sub-agents to be spawned with no previous context, and manage the saving and storing the main context via `--slot-save-path` and the `slots` endpoint. But the `.bin` files produced from that are pretty fat lol

Last thing, I've really been enjoying MTP in the main llama.cpp branch and have been getting pretty solid performance from the Apex Qwen variant. Able to run at 175-200k context with q_8 kv. Getting 200-300 pp and 25-40 tps depending on draft hit rates.

Hi, recently my Pi stopped working with OpenCode go/zen models I use - e.g. Big Pickle and V4 Flash Free.

EDIT tl;dr: OpenCode is rate limiting their free models on 3rd party clients.

It gets stuck on Working.... I have to Ctr+C Pi completelly to get out of it. I use my zen/go API key, which is working fine in OpenCode CLI with the models. Other models in Pi (from other providers) are ok.

Any ideas?

Thanks.

I have been noticing a pattern: AI coding assistants (Copilot, Cursor, Claude, etc.) consistently over-generate code. Unused imports, god functions, pass-through wrappers, single-implementor interfaces, files nobody imports — the list goes on. Worse, when the existing codebase is already messy, the AI mimics the garbage and propagates it.

So I am building ai-slop-detector, a tree-sitter-based analysis engine that catches these patterns and nudges AI assistants to fix them mid-session.

How it works:

• Coding Assistants generates code → detector analyzes it → specific feedback sent back → Coding Assistants adjusts
• Uses tree-sitter (no language-specific compilers), so it works across TS/JS/Python/Go/Rust/Java
• Two modes: real-time nudging during generation, and codebase review for auditing existing projects

The second mode is what SAST & DAST tools already cover, real-time nudging is what I am more interested in. I know that LSP integration with most Coding Assistants already exist, but they do not check code quality. LSP only focuses on syntax errors. Please note, I used to maintain PMD in past, so am good with AST walking and tree-sitter is my preference based on past experience. But, I do value your opinions, if you have strong arguments to use something else, please let me know.

What it catches:

• Unused imports/vars/params/exports
• God functions, empty blocks
• Pass-through functions (just delegates with the same args)
• Single-implementor interfaces
• Orphan files, duplicate logic across files
• Unnecessary abstraction layers (the classic Service→Manager→Helper chains)
• ...

Interfaces:

• CLI: detect-slop src/file.ts (works with any coding agent using skills)
• Programmatic API: import { analyze } from 'ai-slop-detector'

I would build a pi extension on top of the programmatic API for myself and maybe(no guarantee) provide skills for other.

The core philosophy: every line must exist for a reason. No speculative code, no "just in case" abstractions, no matching bad patterns from surrounding code.

Still early, would love feedback. Is this something you'd actually integrate into your workflow? What slop patterns annoy you most that I should prioritize? From technical standpoint, do you have any tips?

Will share git repo and keep everyone posted in future.

In the Codex app I can set a speed fast setting to on, which means it will cost more, but run faster. When I am using pi and authenticated against Codex, can I turn this setting on when using a gpt model?

Hey all,

I have a question around subscription usage using pi agent, I know you can't use the Claude subscription but is it the same story for the ChatGPT Codex subscription?

I logged in with my ChatGPT one but it was drawing from my balance, guess that's answer my question really but couldn't find anything about this.

Thanks all