How-To Guides

Draft and approve an Objective

You don't type objectives out by hand. Your agent drafts them from whatever you already have, and you steer the conversation and approve the result. The quality of the objective still decides whether the coding agent delivers cleanly or comes back with a miss, so these steps cover what to check before you approve.

1. 1

   Give your agent the intake

   In Claude Desktop, Claude Code or any connected agent, share what you have: a meeting transcript, a requirements doc, a feature request, a Slack or email thread, a Jira epic. Ask it to draft Planwright objectives. It checks your open initiatives first and files each objective under the closest one, so new work joins the existing plan instead of starting a parallel one. Steer it as it goes: tell it what matters, what's out of scope, and what to split.

   A whole spec works too. The agent can break it into dozens of objectives grouped into initiatives in delivery order, smallest usable version first.

2. 2

   Check the title is an outcome

   The title should describe what changes about the world when the objective is done, not the activity that gets it there. It's the coding agent's primary directive, so it should be specific enough that a senior engineer could start without asking a clarifying question. If the draft reads like a task, ask the agent to restate it as an outcome.

   Not this

   “Implement OAuth”

   “Auth work”

   “Fix the payment flow”

   “API improvements”

   This

   “Add GitHub OAuth so new users can sign in without a password”

   “Replace manual card entry with Stripe Checkout on the upgrade page”

3. 3

   Check the acceptance criteria

   Every objective needs a bullet list of conditions that must all be true before it can reach Done. Each one should be verifiable: a reviewer should be able to answer yes or no without judgment. The coding agent builds to this list and the reviewer checks against it, so the acceptance criteria are the contract. Planwright scores each draft's clarity and flags vague criteria before anyone claims the work.

   Good: “Users can sign in with a GitHub account on any page with a login prompt.” Not: “Auth feels polished.”

4. 4

   Probe the draft with the agent

   Before you approve, ask the agent to think through edge cases, user scenarios the acceptance criteria don't cover, implementation caveats it would want resolved before starting, and anything ambiguous in the title or scope. It will surface gaps you didn't anticipate. Have it update the objective with what you learn.

   This is refinement, not execution. Nobody is working on the objective yet; the agent is helping make the spec precise.

5. 5

   Check the description is a complete briefing

   The description carries what the title doesn't: related files or services, links to external docs, known edge cases, things that must not change. Coding agents don't pick up context from standups or Slack, so the description is their whole briefing. If something from the intake matters, make sure it made it in.

6. 6

   Check it fits a single agent run

   An objective should be completable in one agent session. If it has more than four or five acceptance criteria, or spans several independent areas, it's probably two objectives. Ask the agent to split it into separate objectives, never into sub-tasks: smaller, tighter objectives get cleaner execution and faster acceptance.

7. 7

   Confirm priority, strategic focus and initiative

   The agent proposes these; you correct them. Priority runs from 1 (urgent) to 5 (someday) and sets claim order, with no sprint planning. Strategic focus is BUILD, GROW, TRUST or SCALE, and keeps the portfolio view accurate. The initiative places the objective on the roadmap.

   Agents can't add objectives to an initiative that has a target date on the roadmap. If that's the right home, move it there yourself in the web app.

8. 8

   Approve it

   Drafts land in Proposed or Backlog, depending on your workspace's intake setting. When an objective is right, commit it to the Backlog and schedule it when you want an agent to pick it up. Scheduling is always a human decision: agents draft and build, but they don't decide what gets worked on next.