Feature AI workflow template: Ship a feature through plans you approved.

The Feature template makes your AI turn a feature request into a scoped initiative, propose the smallest set of child plans, create them once you approve, wait until every child is finished, then verify the whole feature. Integration gaps send it back to execution, never patched inline.

7 steps · 2 approvals · 1 loop back · waits for child tasks

Start free Book a demo

Feature · example runyour AI client

01Capture
02Define Plansyou approve
03Create Plansplanner
04Execute Planswaits on children
05Verifyyou approve
fragment · context-capture06Capture Learnings
07Completeclosing note

task created · workflow attached

example · the steps are this template's real steps

in short

What does the Feature template do?

For product and engineering leads who want features broken down the same way every time, with sign-off before any child work is created.

It is a stored workflow, not a prompt. Your AI client receives one step at a time from ConvOps over MCP, does the work, and advances. The engine holds the run at each of its two approvals until a person says yes.

Ship a dark-mode toggle from spec to verified release
Add CSV export end to end: capture, build phases, review, verify
Build a notification system with sign-off before the plans execute

step by step

How does the Feature workflow run?

7 steps, in this order. Below each one is the instruction your AI receives at that step, exactly as the template stores it.

Capture

Define Plansapproval

Create Plansplanner

Execute Planswaits on children

Verifyapproval

Capture Learnings

Completeclosing note

01
Capture
the agent works
Verify the initiative is well-scoped before any plan work begins.
Required elements:
- A specific, unambiguous title
- A one-line summary of the user-visible outcome
- A clear statement of the problem solved or value delivered
If any element is missing or ambiguous, identify the gap and ask the operator to clarify. Do not advance with an under-specified initiative.
02
Define Plans
waits for your approvalrole · planner
Decompose the initiative into the minimum set of child work items required to ship it. Types are semantic, not structural: most substantial work becomes a plan (which elaborates into phases), but a small, self-contained item can be a direct task or bug child of the initiative with no plan wrapper. Pick the type that matches the work. For each item, produce:
- Title (action-oriented, 5-10 words)
- Type (plan for work that needs its own phases; task/bug for a small, directly executable item)
- Scope (what it includes and what it explicitly excludes)
- Surface area (components, files, or systems it touches)
- Sequencing notes (only if execution order is load-bearing)
Prefer fewer, broader plans over many narrow ones. Present the decomposition to the operator and request approval before creating any child tasks.
no rejection path · the run moves on only when approved
03
Create Plans
the agent worksrole · planner
Create one child task per approved work item, attached to this initiative as the parent, using the type chosen at define-plans:
- type: plan for work that will elaborate into its own phases; type: task or bug for a small, directly executable item
- title and summary: from the approved decomposition
- status: backlog (each child's own workflow takes over from there)
For plans, do not pre-define phases: that is the responsibility of each plan's workflow. Confirm all children were created and linked before advancing.
04
Execute Plans
waits for child tasks
Execution is in progress. This step blocks until every child (plan, task, or bug) reaches a terminal state (completed or cancelled).
If a child stalls or is blocked, address the issue on that child's own workflow: not here. The gate re-evaluates on each advance attempt.
05
Verify
waits for your approvalrole · reviewer
Validate the initiative as a whole. Individual children were verified in isolation; this step confirms they integrate into the outcome the initiative promised.
Report:
- The user-facing path or scenario exercised
- What worked
- What did not work, and which child owns the gap
If gaps remain, reject this step. The workflow returns to execute-plans so the responsible child can be reopened. Do not patch the gap inline here.
Request operator approval before advancing.
rejected → back to Execute Plans
embedded fragment · context-capture · a reusable block the engine runs in place
06
Capture Learnings
the agent works
If anything non-obvious was learned during this task, write it to:
docs/learnings/{YYYY-MM-DD}-{task-slug}.md
The file is a plain Markdown note. Suggested structure:
- What I learned
- Why it was non-obvious
- What I'd do differently next time
If nothing non-obvious came up, skip this step: do not create an empty file.
07
Complete
closes with a note
Initiative shipped. Mark it completed and close out.

where a person decides

Where do you approve in Feature?

Two steps wait for a person. You answer in the chat; the engine records the verdict and the audit row records who gave it.

step 2

Define Plans

The breakdown decides everything downstream. You approve the list of child plans, tasks and bugs before a single one is created.

what you review

Title (action-oriented, 5-10 words)
Type (plan for work that needs its own phases; task/bug for a small, directly executable item)
Scope (what it includes and what it explicitly excludes)
Surface area (components, files, or systems it touches)
Sequencing notes (only if execution order is load-bearing)

no rejection path · approve to continue

step 5

Verify

Each child was verified alone. Here you judge whether they add up to the feature that was promised. Reject it and the run returns to Execute Plans so the owning child can be reopened.

what you review

The user-facing path or scenario exercised
What worked
What did not work, and which child owns the gap

reject → back to Execute Plans

gates the engine checks without you

Execute Plans waits until every child task is completed or cancelled. Each child runs its own workflow.
Complete closes only when your AI leaves a closing note. The note is saved to the task as context, so later work can find why it ended the way it did.

what you need

What do you need to run Feature?

Read from the template's own steps: the tools they call, the files they write, and whether they touch code.

An AI client: Claude Code, Claude (desktop, web, Cowork), OpenAI Codex, ChatGPT, Cursor, OpenCode, or any MCP client, or an isolated run ConvOps starts. Either way the model is yours.
ConvOps: A workspace with Feature installed. It attaches to the initiative task type, so new work of that type starts on it.
Also install: Plan and Phase: this template creates child work that runs on those workflows.
Tools your AI calls: workflow_advance to move between steps.
Where the work lands: Files in your repository: docs/learnings/{YYYY-MM-DD}-{task-slug}.md.
A repository: Yes. Steps read and change code, so run it in a coding client with your repo checked out (Claude Code, Codex, Cursor, OpenCode).
Roles named in steps: planner, reviewer. A hint for clients with subagents; one AI can run every step.

Connect your AI client first, then install Feature from the catalog in the ConvOps app. See how to connect a client

make it yours

How do you customize Feature?

An installed template is a workflow in your workspace. Ask your AI to change it in plain words; the edit lands on the one step that needs it.

Claude Codeexample

new chat

more example prompts

"Add a step before Define Plans that writes a one-page spec to docs/specs/{task-slug}.md."
"Make Create Plans also set a due date on every child it creates."
"Remove the Capture Learnings fragment from this workflow."

the difference

Feature: without a workflow vs with it

Requirements live in a Slack thread; the build starts before anyone agrees on scope
Nobody can reconstruct why a feature shipped the way it did
Each engineer delivers features a different way, with different gaps
The process lives in a prompt, and each run follows it a little differently

questions

Feature template FAQ

What does the Execute Plans step do?

It waits. The step holds until every child of the initiative (plan, task or bug) reaches completed or cancelled. Each child runs its own workflow, and stalls are handled on that child, not here.

Does the Feature template need the Plan and Phase templates?

Yes. The catalog lists Plan and Phase as dependencies, because the child plans it creates run on the Plan workflow and their phases on the Phase workflow. They ship together in the Project Planning and Strategic Delivery kits.

Can a small feature skip plans?

Yes. Define Plans allows a small, self-contained item to become a direct task or bug child of the initiative with no plan wrapper. The step prefers fewer, broader plans over many narrow ones.

Which AI clients can run the Feature template?

Any MCP client connected to ConvOps. Verified clients: Claude Code, Claude (desktop, web, Cowork), OpenAI Codex, ChatGPT, Cursor, OpenCode. Because its steps change code, run it in a coding client with your repository checked out.

Workflows that run next to it

universal

PlanTurn strategic work into reviewed, executable plans. The AI drives through Analyze, Draft, phases, and execution.10 steps · 5 gates

universal

PhaseExecute an implementation phase from ready to verified. The AI drives through Ready, Implement, and Verify.4 steps · 2 gates

engineering

Bug FixResolve bugs from report to verified fix. The AI drives through Intake, Reproduce, Analyze, Fix, and Verify.6 steps · 3 gates

universal

TaskTake any work item from intake to verified completion. The AI drives through Intake, Analyze, Implement, and Verify.6 steps · 3 gates

your next step

Teach it once. Then let it run.

on your ownStart freeConnect your AI tool in one line. Nothing to install.with your teamBook a demoWe show ConvOps on your team's real work.keep readingThe Project Planning kitFeature with the workflows it connects to.