--- title: "How I Made a Minimalist Agent Harness Code Like a Senior Engineer" date: 2026-07-12T12:00:00+00:00 author: "poornerd" tags: ["ai", "agents", "pi", "agent-skills"] canonical: https://www.poornerd.com/2026/07/12/how-i-made-minimalist-agent-harness-code-like-senior-engineer.html source: Raw Markdown twin of the HTML article; content is the original source. --- Most agent tools decide for you. They ship a fixed set of commands, a fixed idea of "plan mode," a fixed opinion about sub-agents, and you bend your workflow to fit. [Pi](https://pi.dev) — the new minimalist agent harness behind OpenClaw — goes the other way. It's stripped down on purpose, and the whole pitch is that you adapt it to *you*, not the reverse. That sounded great. Pi isn't a sealed product — if you need a command, a tool, a provider, a workflow, or a UI tweak, you just ask Pi to build it, and it customizes itself on the fly. It ships powerful defaults but deliberately *skips* things like sub-agents and plan mode, on the theory that you'll add them if you actually want them. Customizations bundle as **Pi packages** and ship over npm or git. The catch: I wasn't sure I was ready to build up all that judgment myself, skill by skill. A blank harness is only as good as what you teach it. Then I remembered [agent-skills](https://github.com/addyosmani/agent-skills) — the 77k-star pack of engineering process from Addy Osmani, a senior engineering leader at Google — that I'd already been testing inside Claude Code. Someone had ported it to Pi. So the test wrote itself: take the bare harness, drop in those skills, point it at a model, and see how far it gets. ## The setup Three moving parts. **The harness:** Pi, out of the box, minimal. **The brain:** [`@chankov/agent-skills`](https://pi.dev/packages/@chankov/agent-skills), a Pi port of Addy Osmani's [agent-skills](https://github.com/addyosmani/agent-skills). The original bills itself as *"production-grade engineering skills for AI coding agents,"* and it's cleared **77k stars on GitHub** — Osmani is a senior engineering leader on Google Chrome, so this isn't hobby advice. The skills are organized by phase: idea → spec → plan → implement → test → review → ship. Each one encodes the process a good engineer actually follows instead of just "write the code." ``` install pi.dev/packages/@chankov/agent-skills ``` **The model:** I connected Pi to my [OpenCode Go](https://poornerd.com/posts/2026/06/29/run-claude-code-on-opencode-go-subscription/) subscription and ran everything on `kimi-k2.7-code` at medium effort. ## The test: spec, then build My prompt was specific: a playable snake game in the terminal, styled to look like *The Matrix* — green digital rain falling behind the board. Not "write snake" — I let the skills drive. It ran the spec skill first, asked me a few clarifying questions the way Claude Code does, and only then started writing code. That ordering matters. The spec-first workflow is exactly what stops a model from confidently building the wrong thing. The output was clean Python: a pure game-logic core with no `curses` imports, a separate renderer for terminal I/O, an input handler, and the Matrix rain effect cascading behind the play area. The interesting part was what happened when I asked it to grade its own work. ## Running `/review` I ran the installed `/review` skill on the finished game. What came back wasn't a rubber stamp — a genuine five-axis review (correctness, readability, architecture, security, performance) that caught the things a good reviewer would: a spot where the renderer was quietly mutating game state, a bloated `main()` worth splitting, an unhandled edge case nobody asked about, and a correct *nothing critical* on security instead of invented risk. That's the tell. A weak reviewer pads the list. This one separated what's good from what to fix, ranked it, and knew when to stop. Reading it back, I couldn't tell it apart from a review I'd get out of Claude Code or any of the other agent harnesses I run day to day. ## One note: it just runs The skills asked me clarifying questions like Claude Code — but they never stopped to ask **permission** before acting. Pi read files, wrote code, and ran the review on its own. Honestly, I liked it: no clicking "yes" on every step, it just moved. The clean way to get that speed is to run Pi in a container. Sandbox the workspace, let it go, and autonomy stops being something to worry about — a mistake can't reach anything outside the box. ## Takeaway A minimalist harness plus a best-practice skills package added up to something that specced deliberately, built cleanly, and produced code and reviews I couldn't distinguish from what Claude Code or any other harness I already use hands me. The harness stayed out of the way; the skills supplied the judgment. If you've been curious about Pi, this is the fast way in: install [`@chankov/agent-skills`](https://pi.dev/packages/@chankov/agent-skills), point it at a model, and ask it to review something you wrote. Then decide who the senior engineer in the room actually is.