# From idea to merged PR

Follow one feature from an idea on the board through a workflow, a spec, a session and its gates to a merged pull request.

Northwind wants shoppers to keep their cart when they switch devices. Lena, the PM, has the idea. Dan, a developer,
builds it. Adam, the team lead, approves at the gates. This page follows the feature from a card on the board to a
merged pull request, and links the guide for each step.

Before you start:

- Your org's plan needs the **Board**, **Workflows** and task **Documents**. EasyCode staff can pause runs and
  documents with the [`runs`](/reference/kill-switches-and-modules#runs) and [`documents`](/reference/kill-switches-and-modules#documents) kill switches; the board still works.
- Sessions run on your machine, in the desktop app, with your own harness login. See
  [Desktop app](/setup/desktop-app) and [Harnesses](/setup/harnesses).
- The product needs a repo connected through the GitHub App. See [Products and repos](/setup/products-and-repos).

## Who does what?

| Person | Role      | Does                                                      |
| ------ | --------- | --------------------------------------------------------- |
| Lena   | PM        | Writes the task and reviews the spec                      |
| Dan    | Developer | Runs the workflow in a session and opens the pull request |
| Adam   | Lead      | Approves the spec and the change at the gates             |

## Walk it through

### Publish the workflow once

Someone who may publish to the library opens **Workflows**, then **Start a workflow**. They pick **Ship a feature**
and press **Use template**. The canvas opens with its steps: Shape the idea, Write the spec, Approve the spec, Plan the
work, Split into tasks, Build a milestone, Run the gate, Review the change, Approve the change and Open the pull
request.

They shape it if they want, then press **Publish**. A member who doesn't approve library changes sees **Propose
change** instead, and an approver reviews it first. See [Workflows, gates and the board](/guides/workflows-and-the-board).

### Put the idea on the board

Lena opens the **Board** and presses **New task**. She gives it a **Title**, such as "Keep the cart across devices",
picks the **Product** and writes a short **Description**. If the idea lives in Jira or Linear, **Link a ticket** ties
it to the task. See [Jira and Linear](/setup/jira-and-linear).

### Write the spec together

On the task's **Documents**, Lena presses **New document** and picks the **Spec** kind. It starts with _Summary_,
_Acceptance criteria_ and _Out of scope_. The team edits it at the same time and comments on blocks.

When it reads well, Lena presses **Request a review** and names reviewers. Each one presses **Mark v2 reviewed** (the
number is the version) or **Ask for changes** with what needs to change. See
[Write a spec with your team](/guides/write-a-spec).

### Start the run

Dan opens the task and presses **Run workflow**. He picks **Ship a feature** and fills in its inputs. On the web, the
run is made and waits for a session: **Open in desktop** takes him there. In the desktop app, he chooses the harness
in the new-session composer and the session starts. The task moves to **In progress**.

See [Start a session](/guides/start-a-session).

### Approve the spec

The agent shapes the idea and writes the spec into the task's Spec document. Then the run stops at **Approve the
spec**. Adam opens the run, then **Open the gate**. He reads the spec beside the gate and presses **Approve**, or
**Request changes** with "what needs to change", which sends the run back to the spec step. **Reject** stops the run.

If the change has UI and your product uses a design system, this gate can also hold a design check. See
[From design to build](/scenarios/design-to-build).

### Build, check and review

The agent plans the work, splits it into tasks and builds a milestone. **Run the gate** runs your repo's own check
command; when it fails, the run goes back to the build, up to three times. A reviewer agent then reviews the change.

Dan follows along in the session. The run page lists each step and its state, and **Open the session** jumps to it.

### Approve the change

**Approve the change** shows the diff, so the branch must be committed and pushed first. Adam reads it and presses
**Approve** with the commit's short sha on the button, so he approves exactly what he read. **Request changes** sends the run
back to the build. **Reject** stops the run.

### Open the pull request

The last step opens the pull request. Dan can also do it by hand from the session's
git actions: **Commit**, **Commit & push**, **Push**, then **Create PR**. Once it exists, the button reads **View PR**
with its number.

### Merge, and watch the board

The board follows the pull request on its own:

- An open pull request moves the task to **In review**.
- A merged one moves it to **Done**.
- A pull request closed without a merge moves it back to **In progress**.

If someone merges before a gate on the run's path passed, the task's activity says "merged with an unpassed gate".

## What if someone else picks it up?

Dan can go on leave mid-run. A teammate opens the session and continues it as a fork, in the same harness or another
one. See [Pick up a teammate's session](/guides/pick-up-a-session).

## Related

- [Workflows, gates and the board](/guides/workflows-and-the-board)
- [From acceptance criteria to QA sign-off](/scenarios/acceptance-criteria-to-qa)
- [From invite to merged PR](/walkthroughs/invite-to-merged-pr)
