Getting started

A friend just handed you stash - a small self-hosted read-it-later service they put together over a few weekends. FastAPI, SQLite, a background worker that fetches every URL you save, strips the nav and ads out of the page, stores the readable text, and indexes it for full-text search. It has tags, a tiny web UI, a CLI. It works. It’s also lightly documented, and you’ve already heard the confession that comes with every handoff like this: the readability extractor mangles some sites, the fetch worker has no rate-limiting or retry, and full-text search misses accented characters. One rough spot in particular is small enough to be your warm-up ticket - the dates on saved articles parse inconsistently, so your reading queue sorts some entries into the wrong place.

Before you start

macOS or Linux (Windows via WSL2)
Node.js >= 22.19.0 (node --version to check)
An API key for at least one provider (Anthropic, OpenAI, OpenRouter)
Basic terminal fluency
Git fundamentals
Estimated time: 4-5 hours

Before you touch any of that, you’re going to meet the tool you’ll be doing it with, and it is not going to behave the way you expect.

The variable isn’t the model

Every agent you’ve likely used - Claude Code, Codex, whatever’s wired into your editor - ships with a big system prompt, a curated toolbox, and a permission gate standing between the model and your disk. Pi ships with almost none of that. Four tools. A system prompt short enough to read in the time it takes to open your terminal. No subagents, no MCP, no plan mode, no to-do list, and - this is the part that should give you pause - no permission prompts. Out of the box, Pi can read, write, and run anything on your machine the moment you give it an instruction.

That’s not an oversight. Pi’s whole bet, stated plainly by the person who built it, is that frontier models are already extensively trained on exactly the moves a coding agent makes - reading files, editing them, running a shell command - so a harness doesn’t need to re-teach any of that in a bloated prompt. What a harness does need to do, on this bet, is get out of the way and let you build the parts you actually want. The scaffolding other agents bake in - guardrails, subagents, planning modes - Pi treats as optional extensions you add back deliberately, once you’ve felt the need for them. Which means, for the whole first module, you’re going to feel the absence of guardrails before you build any.

This is the idea the whole course keeps coming back to: the model is the same frontier model you’d get anywhere else. What changes the outcome is the harness wrapped around it - what it can see, what it’s told, what’s allowed to run unattended. Same model, radically different harness, radically different day-to-day experience. Here’s that idea in miniature, on a task that has nothing to do with stash yet:

Pi’s version of “your context” isn’t rules and MCP servers mounted for you - for now, it’s closer to the bare run on the left. You’re about to spend this module building toward the right side, by hand, on stash.

The hour we’ll follow

We’ll go from nothing installed to that feed-date bug fixed and committed, in four moves:

Install it and see the surfaces Pi actually runs on - Install Pi and see the surfaces
Authenticate with your own key, and understand a real restriction before it costs you an afternoon - Bring your own key
Watch one turn of the loop - the whole mechanism Pi runs on, and what’s missing from it - Understand one turn of the loop
Hand it the feed-date bug and watch that loop close on a real fix in stash - Ship your first fix

None of it is hard, and that’s sort of the point. The habits this hour asks you to build - reading the loop closely, knowing exactly what has filesystem and shell access and when - matter more with Pi than with almost any other agent you’ve used, because here nothing is stopping the model from acting except your own understanding of what you just told it to do.