How a mission works
Phanpy is an open-source Mastodon app, and our example project. Its mission, "Pick up where you left off", has completed all thirteen stages: from the problem, all the way to checking that what shipped actually worked.
As you scroll, the live app follows you through each stage. Each step says what the pilot and their agent did, and what they decided. Every stage runs its own skill, from feature-understand to feature-validate. Click into the app to read the full documents.
The documents read just like a real team's. But Phanpy hasn't actually shipped this feature, so the release and its numbers are made up.
Understand the problem
Every mission starts with the problem. You tell your agent what hurts, and who it hurts, then you gather the evidence together: eight readers' own words from Phanpy's GitHub, and how Home behaves today.
It writes the Problem: who loses their place, when, and what's been tried before. No solutions yet.
Decide it's worth it
Is this worth building, out of everything you could build? Your agent drafts the case, and asks for what only you know, like how many readers it reaches.
It writes the Bet: a hypothesis, a metric, a score of reach × impact × confidence, a two-day appetite, and the riskiest assumption, with a cheap way to test it. The team said Go, as long as a one-day test showed other apps wouldn't move the reader's saved place.
Agree what it must do
Next, you agree what has to be true for the people with the problem. Your agent only asks what the Problem and the Bet left open.
It writes the Requirements: goals, non-goals, constraints, and nine user stories. Each one says what a reader needs, not how to build it.
Open up the options
Design starts wide. You and your agent look at how other apps solve it, and which principles matter, so you choose from real options instead of the first idea.
It writes the Options: four directions, compared against the stories in one table, and a shortlist of two. It doesn't pick a winner. That's your call.
Choose one direction
Now you choose, but only after trying them. The team tried a working prototype of one direction in two browsers, and walked through the other as sketches.
It writes the Solution: which direction won and why, what was turned down, and what each try taught the team.
Make it clickable
The winning direction becomes a prototype you can click. Your agent builds it from Phanpy's own components, and you shape it together until it feels right. It's built to be thrown away, so it skips the rigour the build will need. That's what makes it quick to change.
It writes the Prototype record: the prototype itself, where each story lives in it, which components it reuses or changes, and what the build's tests have to cover.
Shape the architecture
Before writing any code, you agree how to build it. Your agent reads the project's architecture and draws the change on top, so you review modules and wires, not lines of code.
It writes the Architecture: the change, what your agent decided without you, what's still open, and the risks. The pilot read it here, and answered the one open question in their agent.
Plan the build
Your agent breaks the design into steps it can check. It only asks you about choices that change the plan, like which part to build first.
It writes the Plan: three slices, each checked by an agent that didn't build it, and acceptance criteria for all nine stories. You read the short version. Your agent gets the long one, with every file and test.
Build it
Now the code has to last. Your agent builds in rounds. Before each new round starts, a different agent checks the last one. The pilot joined once, for ten minutes, to judge the first slice by taste, and asked for one message to change.
It writes the Build Report: every step and its test, three changes from the Plan (one was the pilot's), and the project's architecture brought up to date.
Prove it works
Before anything ships, your agent proves every story works. It reruns the tests, walks the build side by side with the prototype, and tries it on two real devices. It found one bug, and fixed it.
It writes the Verify Report: all nine stories proven, what no check could reach, and what's left for the pilot to try. It also flagged a risk: another app can move the reader's place.
Polish it
Now you use it for real. Your agent sets it up, stays quiet while you click around, and writes down what you say. Then it reviews the product through six lenses, from accessibility to copy.
It writes the Polish Report: six findings, worst first. Five were fixed, and one was handed to an owner. Then the feature ships.
Sharpen how you work
With the feature shipped, you look back at how the mission went. Every snag your agent noted along the way is fixed where it started, or handed to an owner.
It writes the Retrospective. One fix went into the Plan skill itself, so every future Plan checks how outside services behave at their edges. Your process gets sharper with every mission. Validate is booked for 30 days after release.
Check it worked
Thirty days later: did it work? Your agent gathers the evidence against the Bet. Four of the five requests were resolved. You and your team decide the verdict.
It writes the Validation: the result against the target, the verdict, and what the team learned about betting. The one unresolved case becomes a candidate for the next mission.

Your turn
That's a whole mission. From the problem, through prototypes and architecture, to the build, and a check that it worked. Your missions will work the same way, and you make the call at every stage.
To start one, open your agent in the repository you're working on, and ask:
Start a Pathfinder mission to build <the feature you want>.Not connected yet? See Connect your agent.