> ## Documentation Index
> Fetch the complete documentation index at: https://ade-app.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Create and manage lanes

> Every way to start a lane — a new branch or an existing branch — plus rename, archive, and delete.

Your repo root is always the **primary lane** — it exists from the moment you open the project, and it can't be deleted. Every *other* lane is a git worktree you create for a single task, isolated under `.ade/worktrees/`. You never pick a "lane type"; what varies is **how** you bring the new lane into being.

![The New lane button in the Lanes view](https://mintcdn.com/ade-ac1c6011/Mghbi7-G0yTaUGxT/media/current/lanes.jpg?fit=max\&auto=format\&n=Mghbi7-G0yTaUGxT\&q=85\&s=e5669a6b1bfe74167b72181ef6f9e3af)

Start a new lane from the Lanes view.

## Ways to create a lane

> [card] New worktree off a branch
>
> Branch a fresh worktree from your default branch — or any other branch. The default, and the safest place for agent work.

> [card] Import an existing branch
>
> Pull a branch you already have — local or remote — into a worktree ADE manages.

> [card] Attach an external worktree
>
> Already made a `git worktree` outside ADE? Attach its path and ADE tracks it without ever moving or cleaning it.

## New worktree off a branch

This is the default path. Open the **New lane** dialog, name the task, and choose what to branch from. The dialog opens in **As new branch** mode.

**1. Open New lane**

Click **New lane** in the Lanes view.

**2. Name the task**

Use a short, outcome-shaped name like `fix-auth-redirect` or `add-health-endpoint`. The name becomes the branch and the worktree folder slug. ADE picks an unused accent color for the lane; click the colored dot inside the name field to change it.

**3. Choose the base**

Choose **Start from**: the project default branch, the primary lane branch, or another branch. Under **Bring**, choose pushed commits, local commits, or uncommitted changes. Uncommitted changes are copied, including staged, unstaged, and untracked files; the source stays unchanged.

**4. Create**

Click **Create lane**. ADE runs `git worktree add`, checks the new branch out under `.ade/worktrees/`, and the lane appears in the list.

> [!TIP]
>
> Press **Enter** in the name field to create the lane. **⌘ Enter** (Ctrl+Enter on Windows and Linux) creates it from anywhere in the dialog.

> [!NOTE]
>
> Every branch or lane choice opens an inline popover above the form. The popover has a search field and a list. Each row shows the branch name, its last commit message, author, and age, plus a **current** tag on the checked-out branch and a **PR pill** (`#NNN`, with *draft* added for draft pull requests) when the branch has an open pull request. Search accepts free text plus `pr:open`, `pr:none`, `mine` (or `author:me`), `stale:30d`, and a PR number such as `#812`. Pressing Enter in the search field picks the top row.

### Machine and extras

The two modes sit under the name field, and each has a tooltip that explains it. Two more rows appear as needed:

* **Machine** appears only when more than one machine is connected. **Least loaded** lets ADE pick the least-loaded machine right now; otherwise choose a specific machine. Each one shows its free disk and repo path. Machines without the repository are disabled, and **Connect another machine…** is at the bottom of the list.
* **Extras** holds **Attach Linear issue** and **Use a template**. Attaching an issue shows a card with its identifier, title, and branch name. While an issue is attached, **As existing branch** is unavailable. **Use a template** chooses the lane template that sets up env files, installs, and services, or **No template**; it also links to **Manage templates…** or **Create a template…**.

### Auto-create from a task or Linear issue

You don't have to fill in the dialog by hand. Hand ADE a task — or attach a Linear issue — and it derives the branch name, names the lane, and attaches the issue as context so the agent starts with the right spec.

> [!TIP]
>
> Attaching a Linear issue derives the branch name from the issue identifier and title (`IDENT-title-slug`), or uses Linear's own branch name when it provides one. If that branch already exists locally or on the remote, the issue card warns and **Create lane** stays disabled until you detach the issue, so you don't accidentally collide with existing work.

## Import an existing branch

Have a branch already, local or remote, that you want ADE to manage as a worktree? Choose **As existing branch** in the New lane dialog, pick the branch, and click **Import branch**. ADE creates a managed worktree checked out to that branch, and the lane works on it directly; no new branch is made. The checked-out branch is listed first, then the rest by most recent commit. Picking a branch fills in the lane name if the name is empty or still auto-filled.

> [!NOTE]
>
> The same popover search that backs new worktrees powers import — search by name, filter to your own branches (`mine` or `author:me`), or jump straight to a PR number (`#NNN`). The PR pills come from GitHub and are fail-soft: if the PR lookup errors, the list still works, just without pills.

## Copy uncommitted work

Choose a new branch, select the source branch, and choose **Uncommitted** under **Bring**. ADE copies changes from the folder with that branch checked out and leaves the source untouched.

## Create a lane from a commit

In the **History** tab, the **Create lane here** action on any commit branches a new lane starting from exactly that commit, instead of from a branch head. ADE verifies the ref and uses the resolved commit as the worktree's start point.

## Rename, archive, or delete

Open a lane's manage dialog to change it once work is underway or done.

| Action | Use it when |
| - | - |
| **Rename** | The task name is unclear. This updates ADE's lane metadata. |
| **Recolor** | You want a different accent dot. Colors already used by other active lanes are disabled. |
| **Archive** | The work may matter later but should leave the active list. The worktree stays on disk and **unarchive** brings it back. |
| **Delete** | The lane is done. This tears the lane down — see below. |

### What delete tears down

Delete isn't just `rm -rf`. ADE runs an ordered teardown and shows live progress for each step: it stops the lane's processes, terminals, and file watchers, cleans up lane environment resources, releases the lane's leased port range, removes the git worktree, and only then clears ADE's rows. You can optionally also delete the local branch (and the remote branch). Before you confirm, ADE surfaces a preflight check — dirty files, unpushed commits, running processes, and whether a remote branch exists.

> [!WARNING]
>
> Deleting a managed worktree removes its working directory, including uncommitted changes. ADE warns you about dirty state and unpushed commits first, but commit or push anything you want to keep before you confirm. Once a delete starts it runs to completion — it can't be cancelled.

## Good cleanup habits

* Archive stalled experiments instead of leaving every lane active.
* Delete lanes once their PRs merge and follow-up work is done — this returns the port range to the pool.
* Keep lane names tied to outcomes, not model names.
* Use the History tab to find what happened in a deleted or archived lane.

> [accordion] Manage lanes from the terminal
>
> Every lane action is also available from the `ade` CLI:
>
> ```bash theme={null}
> ade lanes list --text                 # list lanes in the active project
> ade lanes create --name fix-checkout-flow  # branch a new worktree lane
> ade lanes delete <lane-id> --force    # tear down a merged or abandoned lane
> ```
>
> Run `ade lanes --help` to see every command and flag.

> [card] [Lanes overview](https://ade-app.dev/docs/lanes/overview.md)
>
> How lanes isolate work and sync across surfaces.

> [card] [Stacked pull requests](https://ade-app.dev/docs/tools/pull-requests.md)
>
> Review dependent branches with GitHub pull requests.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.