Keep parallel agent work visible and bounded

A parallel workspace is not useful because it looks busy. It is useful when each lane has a job, a boundary, a check, and a visible trail. Start by planning the split. Then open the workspace that makes that split easy to supervise.

A parallel workspace is not useful because it looks busy. It is useful when each lane has a job, a boundary, a check, and a visible trail. Start by planning the split. Then open the workspace that makes that split easy to supervise.

Start Fresh For The Task

Do not begin by hunting for the perfect saved layout. Begin with the current phase of work: what needs design, what needs implementation, what needs verification, and what can safely happen at the same time.

A dashboard task, a migration, a game level, and a new project do not need the same shape. Ask for the split that fits the task in front of you.

For a dashboard:

  • one lane designs the data cards
  • one lane checks API shape and sample data
  • one lane writes component tests
  • one lane reviews empty, loading, and error states

For a migration:

  • one lane maps the source schema
  • one lane maps the destination schema
  • one lane writes verification queries
  • one lane drafts rollback notes

Split By Boundaries, Not By Vibes

Each lane needs a job, allowed files, files to avoid, and proof. If two lanes need the same files, they are not parallel yet.

How can we accomplish this task with multiple agents, where they each have their own responsibility, and they each have their own testing, they can work in parallel, usually in the same branch, honestly.

— John Lindquist

Lane Owns Avoids Proof
UI lane src/routes/dashboard/**, component snapshots API contracts, migration files screenshot and component checks
Data lane query helpers, fixtures, schema mapping visual components query tests
Test lane new regression tests production logic except test hooks failing-before / passing-after log
Review lane risk notes, integration checklist code edits written review with blockers

Keep The Agents Visible

Visible work is easier to correct. You can inspect the history, compare outputs, step into one lane, or stop a bad direction before it spreads.

Hidden background work can be useful, but it removes the trail you need when the next run should be better. If the task is risky, keep the lanes where you can watch them.

When I see agents spawn up in background threads, and I don't know what they're doing, and I can't, like, look at some of the history and tool calls and everything. I don't know how it could improve next time.

— John Lindquist

Use A Manager Thread

One thread owns the plan. Other lanes execute bounded work. The manager does not need to do every task. It needs to remember the split, check progress, catch conflicts, and decide when to merge, redirect, or stop.

Manager responsibilities:

  • restate the project goal
  • divide work into lanes
  • assign file boundaries
  • name the verification for each lane
  • tell each lane which other lanes exist
  • check progress before merging ideas
  • stop any lane that crosses its boundary

Copyable Prompt: Parallel Work Plan

We need to plan parallel agent work for this software task.

Task:
[describe the feature, fix, migration, or review]

Current phase:
[planning / implementation / debugging / visual review / verification]

Project facts:
- active areas:
- stable areas to avoid:
- commands/tests available:
- risky files:
- expected output:

Create a parallel work plan.

Return:
1. the smallest useful number of lanes
2. the responsibility of each lane
3. exact file or directory boundaries for each lane
4. what each lane must not touch
5. the verification each lane must run
6. the manager check-in schedule
7. the prompt to initialize each lane

Prefer fewer lanes if file conflicts are likely.
Do not start implementation yet.

Copyable Prompt: Lane Setup

You are Lane [name].

Goal:
[one responsibility]

Allowed files:
[list]

Do not touch:
[list]

Other lanes running:
- [lane]: [scope]
- [lane]: [scope]

Before editing:
- inspect only your allowed area
- restate the files you expect to touch
- name the verification you will run

After editing:
- summarize changes
- list files changed
- run verification
- report any boundary conflicts

Make Progress Legible

Use agents to make proof easier to produce: screenshots, before/after numbers, test logs, release notes, and short visual summaries. The goal is not noise. The goal is reviewable impact.

Before/after performance note:

Before:
Dashboard loaded sample account in 4.8s.

After:
Dashboard loaded sample account in 1.9s.

Proof:
Trace attached, test command included.

Change:
Cached account summary query and removed duplicate fetch.

Visual progress note:

What changed:
Replaced manual export flow with a reviewed batch job.

Why it matters:
Removes three support steps.

Proof:
Screenshot, smoke test, rollback note.

Save The Layout Only After It Repeats

A reusable layout is earned. If the same task shape appears three times with the same lane split, checks, and review surface, turn it into a saved workspace, script, or small helper.

Until then, start fresh and ask for the split.

Source references