How do you run product management when AI agents do the building?
Agents can build a feature in an afternoon. Knowing what to build, and proving it works, is still product work. Here's the playbook I run Gryz with.
Jacob Cansler · Maker of Gryz
Updated 6 min read
Short answer: Keep one short document per feature that holds the intent, the acceptance criteria, the decisions and the links, and move the feature through eight stages from Discover to Learn. In Gryz that document is the Feature Context Document (the feature doc), and the product playbook gives every agent you use the same stages, gates and template.
What changed for product work
Agents changed how fast code gets written. They didn't change the hard parts of product management:
- Deciding what's worth building. An agent will happily build the wrong thing very well.
- Saying what "done" means. If the acceptance criteria live in a chat, the next agent never sees them.
- Proving it works. An agent that wrote the code and the test can tell you both pass. That's not the same as evidence.
- Keeping the why. Decisions made in one tool get lost when the work moves to another.
Models are becoming commodities. Context isn't. The playbook is how product context survives the trip from the person who shaped the idea to the agent that builds it.
The Feature Context Document
Gryz defines the Feature Context Document: one short document per feature that holds its intent, acceptance criteria, decisions and links, so the next person or agent, in any tool, starts from it instead of a chat. It builds on Rahul Garg's article on feature documents on martinfowler.com, which came first.
A few rules keep it useful:
- It never holds build progress. Progress lives in tasks, pull requests and flags. The feature doc links to them.
- Some sections need the owner's approval. Scope, Non-goals and Acceptance criteria don't change without the person who owns the feature saying yes.
- Decisions are add only. You can add a decision and the reason for it. You don't quietly rewrite one.
- Status and Links are derived. They come from the real work, not from someone's memory of it.
Eight stages, one gate each
Each stage has a goal and one gate: a question, and the output that has to exist before the feature moves on.
| Stage | The gate question | What must exist |
|---|---|---|
| Discover | Who has this problem, and how do we know? | Discovery notes linked from the feature doc |
| Shape | Is it worth doing, and what is in and out? | A feature doc with Why, Scope, Non-goals, Acceptance criteria and Success |
| Design and prototype | Does the design meet every acceptance criterion? | A design or prototype linked from the feature doc |
| Hand off | Can an engineer start from the feature doc link alone? | A build plan, and a parent task with subtasks |
| Build | Is every planned change merged, with its checks passing? | Pull requests linked from the feature doc |
| Verify | Does each acceptance criterion have evidence the builder could not alter? | Check results a person ran or a system recorded |
| Launch | Who can use it now, and how do we roll it back? | A launch note with the rollout and the way back |
| Learn | What did the success measure say on its date? | The measure, read, and a decision about what's next |
Stages can move backward. Going back to Shape because the design showed a gap is a normal move, not a failure.
Two dials
Teams usually argue about speed as if it were one setting. It's two:
- Pace is set per feature, by the person who owns it. A small experiment can move through the stages in a day. A billing change shouldn't.
- Checks are set per change, by rules. A change to sign-in or payments gets its security review whether the feature is moving fast or slow. Moving fast never skips a check.
Who moves the stage
A person moves the stage. An agent says what it would move and why, then asks.
That's how it works in Gryz today:
- You own each Feature. It sits under one of your Projects, with its stage, its feature doc and its next step.
- Only you move it. From the dashboard, or through your own agent after you say yes. Every move is recorded.
- Share the feature doc, not the Project. When you hand off to an engineer, they open the feature doc and see the Feature's title, stage, owner and next step. They don't see the rest of your Project or your task list.
- Their agent can read it too. An engineer working in Cursor asks for the feature doc and starts from it. Their agent can suggest a move. It can't make one. See the playbook tools for what each agent can do.
How to run it
You need Gryz connected to your agent. Then, in Claude, ChatGPT, Cursor or Claude Code:
Use the Gryz product playbook to start a feature for [the problem you want to solve]. File it under my [project name] project.The run-playbook skill checks Gryz for an existing feature doc first, so you don't end up with two. Then it drafts the feature doc from the template, files it into the Project, and creates a parent task. Later, ask:
- "What stage is this feature in, and what's next?"
- "Hand this feature to engineering."
- "Reconcile the feature doc with what we actually shipped."
That last one matters most. At the end of a session or after a merge, the agent reads the real commits, tasks and check results, and:
- Refreshes Status and Links from those records, not from the chat.
- Lists new decisions for you, and adds them when you say yes.
- Only suggests changes to Scope, Non-goals or Acceptance criteria. You approve those.
- Never moves the stage. It tells you what it would move and why.
What's still open
I'd rather say what isn't done than oversell it:
- Evidence the builder can't alter. The playbook asks for it at Verify. In Gryz today, sign-off still relies on check results you link yourself. Recording them straight from the system that ran them isn't built yet.
- One person's Projects. Features live in personal accounts first. Company workspaces get them later, when a team asks.
- No speed claims. I'm measuring whether the feature doc changes what gets built. Until that measurement exists, I won't tell you it makes anyone ship faster.
I run Gryz itself on this playbook, so the gaps above are ones I hit too.
More on this topic: Shared context for AI agents.
FAQ
What is a Feature Context Document? It's one short document per feature that holds the intent, acceptance criteria, decisions and links. Gryz defines it, building on Rahul Garg's article on feature documents. Day to day, call it the feature doc.
Is the feature doc the same as a spec? It's smaller. A spec can go deep on how something is built. The feature doc holds what the feature is for, how you'll know it worked, and links to everything else, including the spec.
Can an AI agent move a feature to the next stage? It can suggest the move and say why. The person who owns the feature decides. In Gryz, only the owner can move a stage.
Does the engineer need access to my whole Project? No. Share the feature doc. They see the Feature's title, stage, owner and next step, and nothing else from the Project.
Which tools does it work with? Any agent connected to Gryz over MCP, including Claude, ChatGPT, Cursor and Claude Code. The stages and template are the same in each.
Is it free? Yes, with a free Gryz account. See pricing.
Related posts
How do you hand off work between people and AI agents?
Your work shouldn't stop when you log off. Here's how to leave a handoff that the next person or agent can pick up cold.
Teams6 min
How do I share context between Claude Code and Cursor?
Connect Claude Code and Cursor to Gryz and they share one context for your repo: decisions, docs, tasks and skills. Here's the prompt to paste.
Developers5 min
How do people and AI agents edit the same document?
Comments on a passage, @mentions, agent suggestions that wait for you, and every save kept as a version. How people and agents share one doc in Gryz.
Documents5 min