LanesLanes
Use cases/Lanes Desktop/Keep the agent, the diff and the code in one window

Keep the agent, the diff and the code in one window

The board, real terminals, a git client, the Monaco editor and a SQLite browser in one app. Reviewing what an agent wrote stops meaning a switch to a separate IDE.

An agent finishes a task and the reading starts. You leave the terminal for the editor to see what changed, open a git client to stage it, and go looking for the database to check what actually got written. The agent did the work in seconds and you spend the next ten minutes assembling the tools to check it.

Lanes is built the other way round. The agents sit inside the development environment rather than beside it, so the session, the diff, the file tree and the data are panels in one window.

How Lanes does it

  • A real editor, not a diff viewer. Monaco, the editor behind VS Code, with a file tree, syntax highlighting and Markdown preview. You can fix the one line the agent got wrong without opening anything else.
  • A git client, not just a diff. Review, commit, publish and switch branches from the app, with inline diffs and a history you can undo from. See git integration.
  • The database, next to the code. The SQLite browser finds your project's databases by itself and runs read-only SQL, so "did that migration do what it said" is a query rather than an errand.
  • Live terminals. One real PTY per session running the official CLI, in plan or implement mode, with live status on the card.
  • The board is the project. Issues move through Planning, Implementation, Review and Done, dependencies block and unblock automatically, and projects switch with tabs.
  • Commands where your hands are. Quick commands on Cmd+Alt+1-9, injected into the agent's session or run as a shell command.

The workflow

Start a session on an issue and let it run. When it reports back, everything you need to judge it is already in the window: the terminal that produced the change, the inline diff beside it, the file open in the editor, and the project's database a click away.

Corrections go wherever they are cheapest. Type a follow-up into the session when the agent should redo it, or edit the file yourself when it is one line and you are already looking at it. Both land in the same worktree, and the git panel shows the result either way.

Reviewing in the same place you ran the agent is what keeps a fleet reviewable. Five sessions is five diffs to read, and a context switch per diff is what turns that into an afternoon.

Set it up

Install Lanes and open it:

Bash
brew install --cask lanes-sh/lanes/lanes && open -a Lanes

Then:

  1. Add a project. Point Lanes at the folder where your repos live.
  2. Create an issue and start a session. Cmd+N for the issue, then Plan or Implement.
  3. Open the panels while it runs. The file browser, the git view and the database browser all read the session's own worktree.

The quick start walks through the whole first run in about two minutes.

The editor, the git client and the database browser are not there to replace your IDE at what it is best at. They are there so that checking an agent's work, which is now most of the work, happens without leaving the place the agent ran.

Further reading

Get Lanes Desktop or read about sessions.