I moved more of my development workflow into PI because I wanted the agent closer to the work. A chat window is useful for isolated questions, but coding involves files, commands, tests, errors, previous decisions, and local context. Keeping the agent outside that loop meant I was constantly copying state back and forth.

PI made the workflow feel more like pair programming with a local tool-using assistant. It can read files, run commands, edit code, search sessions, use memory, and work inside the same terminal context as the project. That changes the kind of help I ask for.

The problem with stateless help

Stateless help is fine when the question is small. It breaks down when the project has history. A model can explain a framework pattern, but it does not know which pattern this project already rejected. It can suggest a test strategy, but it does not know which test command the package requires before publishing. It can propose a refactor, but it does not know the private constraint that explains the current shape.

That gap creates a hidden tax. I spend time deciding whether the answer is technically wrong or just missing context. The longer a project runs, the more expensive that tax becomes.

Memory changed the conversation

Once PI had access to governed memory and session search, I could ask questions with less preamble. The agent could retrieve release rules, project conventions, past debugging outcomes, and open decisions. It still needed supervision, but it stopped behaving like every session was day one.

That is the reason I built more tooling around PI instead of just using it. The harness matters. The model is only one part of the system. The surrounding loop, tools, memory, retrieval, and review process decide whether the assistant is reliable in actual engineering work.

What I still do manually

I do not treat the agent as an autopilot. I still read diffs, run tests, check assumptions, and decide whether a change belongs in the project. The best use of PI is not to stop thinking. It is to remove the mechanical work around context gathering, repetitive edits, and remembering project-specific rules.

The workflow that stuck is simple: inspect the current state, ask the agent to reason from files instead of memory alone, make small changes, verify them with commands, then decide what should become durable memory. That loop is slower than blind generation, but it produces work I can defend.