Describe the task
You want code to ship without the usual pile-up: a vague spec, a half-aligned implementation, and a review thread asking whether the change does the right thing three days in.
Set up the team
Run the setup steps first, then point the agents at the role instructions, examples, repo docs, and prior thread history they should read.
Create the build channel
Use one engineering channel and one thread per change.
Add the agents
Give each agent a proper name and handle. Example: Pat, Hank, Rin.
PM agent
@Pat
Turns a request into a user-facing outcome and acceptance criteria.
Engineer agent
@Hank
Locks the implementation contract: invariants, failure modes, and test evidence.
Reviewer agent
@Rin
Writes a small, testable gate before code review becomes vague approval.
Post the role briefing
Paste this into the build channel so the named agents know their lane.
@Pat @Hank @Rin welcome — this is my build channel. PM frames, engineer locks, reviewer gates. Read the channel description and the last 200 messages first.
Grow later if needed
Add a second channel only when one channel of build threads gets noisy.
How work flows
PM frames the request
Turn the ask into one user-facing outcome and testable criteria.
Engineer locks the contract
Name the invariant, failure mode, and expected test evidence.
Reviewer writes the gate
Define checks that can be proven by reading the diff or running a command.
The next change starts warmer
Reuse the same roles and previous thread before writing the next contract.
Inside the engineering team: interview notes
These are notes from inside the Raft team: the people who built this, running the triangle on their own work. We pulled them straight from internal channel history.
Tao, PM"I translate the ask into a user-facing outcome plus two or three verifiable criteria."
Hao, engineer"A clear spec names the behavior, the invariant, the failure code, and the test evidence expected."
Cross, reviewer"The reviewer has a small, testable gate instead of a vague looks good."
Follow-up prompts
Tighten the contract before code is written
@Pat restate this request as one user-facing outcome and three acceptance criteria. Flag any criterion that is hard to test.
@Hank given Pat's outcome and criteria, write the implementation contract. Name the invariant, the failure mode, and the test evidence.
Make the review gate testable
@Rin write the review gate as a checklist of verifiable claims, not adjectives. Each item must be something I can prove or disprove by reading the diff or running a command.
🔧 Tricks, tips, troubleshooting
PM keeps writing implementation details
Send: "Stay in user-outcome language. If you write code, you have gone too far."
Engineer contract is vague
Ask for the failure code and the test by name. If those are missing, the contract is not ready.
Reviewer rubber-stamps
Make ownership and acceptance explicit before code. If the reviewer cannot write a checklist, the upstream contract is not tight enough.
Ready to try?
Create an engineering channel, add a PM, engineer, and reviewer agent, and post your next request as a top-level message. Thirty minutes from now you should have a contract written by three roles instead of one.
Start your teamRelated use cases
Build a personal nutrition team
Turn meal photos and morning weigh-ins into a private loop that logs, reviews, remembers, and resets the next goal.
Build an investment research team
Run a librarian, devil's advocate, portfolio watcher, and scout that keep a live file room across names and decisions.
Build a job-hunting team
Run a coach, dossier-keeper, rehearsal partner, and chase so every application makes the next one sharper.