← Guides · 日本語 · Português · 中文

Updated 2026-11-19

On this page
  1. The pattern
  2. Prerequisites
  3. Step 1 — The outcome prompt
  4. Step 2 — Phase one: unblock, don't build
  5. Step 3 — The working loop
  6. Step 4 — Your job as its executive
  7. Steady state
  8. Verify it
  9. Pitfalls
  10. Knowledge check
  11. Sources

Guide 2 — Product-owner Bot

Goal: a Bot that product-manages an entire app surface — files its own tickets, builds them, merges, and reports daily. Level: intermediate · Human load after setup: ~1 message per 6 merged PRs Source deployment: Cognition's Android Bot — shipped the Devin Android app to Google Play open beta in 44 days: 1,134 merged PRs, 344,651 lines of Kotlin, 2,841 screenshot tests, 1,217 tickets. Its human sent 183 messages total (22 days of silence), and 88% of PRs were self-merged. It now owns Android/iOS feature parity. Sources: launch post · Fortune · Russell Kaplan's dogfooding notes

The pattern

One Bot owns a surface — an app, a site, a service — the way a PM owns it: it decides what to build, turns that into tickets, runs a session per ticket, and keeps the surface alive indefinitely. The human acts as the executive it reports to.

Bot ──► files tickets ──► session per ticket ──► PR ──► CI + Devin Review ──► merge
 │                                                                           │
 └──────────── daily report + Needs-you decisions ◄──────────────────────────┘

Prerequisites

Step 1 — The outcome prompt

The real one, verbatim from Cognition:

your job is to product manage the android app. Basically, you're going to
autonomously create the entire thing, but we need to figure out what the
blockers are for you doing that first.

Reconstructed template for your surface:

Your job is to product manage <surface>. You're going to autonomously
<build / keep parity with <reference>>, but first enumerate the blockers
to you doing that — where the code lives, how to build and test it, and
how changes merge — then start working through them.

Note the shape: ownership + autonomy + blockers-first. Don't hand it a backlog; hand it a mandate and make it surface what it needs.

Step 2 — Phase one: unblock, don't build

The Android Bot didn't write code first — it enumerated blockers: repo access, build commands, how to test on a device/emulator, the merge path. Your version of that list:

Let it finish this audit before it files product tickets. Every blocker it resolves here is a stalled session you won't see later.

Step 3 — The working loop

Once unblocked, the steady state is:

  1. Bot files a ticket for the next unit of work it decides on
  2. A child session implements it and opens a PR — small, with proof it works
  3. CI + Devin Review gate the merge
  4. Bot merges (or asks you when judgment is needed — it landed in Needs you)
  5. Daily report lands in Slack — the Android Bot's reports include a screen recording of what changed

Set up the reporting in the Bot's Instructions, not chat:

Every day, post a report in #<channel>: what shipped, what's in flight,
what needs a human. Include a screen recording of visible changes.

Step 4 — Your job as its executive

The 183 messages over 44 days fell into two buckets:

Everything else — tickets, implementation, fixes, self-merges — is the Bot's job. If you're answering implementation questions, you're managing too low. Correct once → it lands in memory → next session inherits it.

Steady state

After the initial build, the same Bot switches to owning the surface:

Verify it

Pitfalls

Knowledge check

  1. Android Bot merged 88% of its own PRs — what made self-merge safe enough to allow? (Verification existed: 2,841 screenshot tests plus review gates; ownership worked because 'done' was machine-checkable.)
  2. Why file tickets instead of just prompting sessions directly? (Tickets create an auditable queue the Bot triages by priority — and the human reviews one queue, not 50 sessions.)
  3. What does '22 days of silence' tell you about the control model? (Escalation-by-exception works only when the Bot's definition of done is verifiable; silence is the feature, not neglect.)

Sources