Repave IDE

Repave IDE is a full editor in the browser, running against the same workspace the agents use. It is how you do the part of the work that is quicker to do yourself, without leaving the platform or cloning anything.

Opening a session

Open it from a feature, or from Repave IDE on the project. A chooser asks which codebase you want, because there is usually more than one:

• the modernized codebase on its integration branch, or
• a feature worktree — the branch a particular feature is being implemented on.

Picking the wrong one is the common first mistake: edits made on the integration branch are not part of the feature you thought you were editing.

A progress page covers the start-up while the session comes up.

Opened IDEs

Every session open on the project is listed at the top of the Repave IDE page, under Opened IDEs, with who opened it and when. Each one's Stop, Restart and Open in Repave IDE are on its row; the codebase cards below only open.

Each row also shows how much memory the session is using against its limit, in two parts:

• Editor — the IDE itself: the editor, its terminals, and anything run in them, such as the test browser.
• Docker — everything started from the IDE terminal with Docker: the dev stack, test databases.

A bar turns amber at 90% of its limit. When the kernel has had to kill a process because a limit was reached, the row says Out of memory, counts the processes killed since the session started, and names the limit to raise. Both limits are under Container resources in the project's General settings — Repave IDE session for the editor and Docker sandbox for Docker. A new limit applies when the session restarts, so restart it from its row afterwards.

When a feature's workspace cannot be opened, the chooser says why:

• the feature has no approved To-Be Gherkin yet, so there is nothing to open. Approve it first;
• another git checkout is in the feature's worktree folder, so it was left alone. Move it aside and open the feature again;
• the worktree could not be prepared. Opening it again retries, and the reason is in the server log.

What is already set up

A session is not an empty editor.

• The Repave CLI is signed in, and stays signed in for as long as the session runs. You can read the project's scenarios, settings and decisions from the terminal without authenticating.
• Git is configured. You can commit without setting up an identity first; commits the platform writes carry the platform identity.
• Claude Code is available, signed in the way your project settings say, sharing the project's memory, and told which feature the session is for. Codex is available too, with a Repave plugin of its own.
• A browser the developer and the agent share, with a viewer inside the IDE, so you can watch what an agent is looking at.
• Dev mode runs the application, and the preview is reachable from your browser through the platform rather than needing a port open on the host.
• The feature's target-stack prototype, when it has one — it is already in the workspace; see below.
• The feature's .feature file, in a feature session whose To-Be Gherkin is approved. It is written to the project's features path when the worktree has none, and never over a file that is already there, so reopening a session cannot replace your edits. To take a newer version of the scenarios into an existing file, run /repave:feature-file in the session.

The target-stack prototype is in the workspace

When a feature was prototyped on the project's own stack, that prototype is the first work on the feature's branch — so a session on the feature opens with it already in the workspace, as working code in the framework the project is being modernized into. git log shows where its commits end.

Build on it rather than deriving the screen a second time from the design: its routing, its component breakdown and its state shape are the structure the implementation should keep. Where the two disagree on visuals, the active design wins. Claude Code and Codex in the session are told the same.

PROTOTYPE-DUMMY markers mark what the prototype built to demonstrate the screen rather than to work — fixture rows, a button that only shows a toast, a hardcoded list — and name what should replace it. Replace each one with the real thing and delete the marker; the feature cannot be merged while one remains.

The Repave sidebar

A sidebar specific to this product, not to the editor:

• Scenarios — the feature's Gherkin, without switching back to the web app.
• BDD Runs — test runs, with a Trace Viewer tab for looking at what a run actually did in the browser.

Working alongside an agent

You and an agent can be in the same workspace. The practical rules:

• An agent implementing a feature works in that feature's worktree on that feature's branch.
• A reused worktree is kept current with your base branch, so you are not editing against something stale.
• If you implement locally with the developer plugin, the same gates apply as on the platform's own pipeline — including that local implementation is gated on a concluded preflight. The plugin does not get a shortcut the platform does not have.

Session lifetime

A session's home directory outlives its container, so a restart does not lose your shell history, your editor state, or files you left outside the repository. Sessions are reconciled and cleaned up at platform start-up, so a session left running through a restart does not linger as a ghost.

Next: Test runs and reports.