The web IDE

The web 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 View Source Code 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, and sessions can be stopped and restarted from the chooser.

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 — see below.

The target-stack prototype is in the workspace

A feature whose prototype was built on the project's own stack already has working code for that screen, in the framework the project is being modernized into. When the session opens, a read-only copy of it is placed in the workspace at .prototype-reference/<feature-id>/, taken from the project's prototype branch.

Open PROTOTYPE-REFERENCE.md there first. It names the feature, the route the prototype's screen is served at, which design option it was built from, and whether the design has moved since — and it lists the files beside it. The point of the copy is to be reproduced: its routing, its component breakdown and its state shape are the structure the implementation should have, rather than the screen being derived a second time from the design. Where the two disagree on visuals, the active design wins.

Two things to know about the copy:

• PROTOTYPE-DUMMY markers are expected in it. Each one marks something built to demonstrate the screen rather than to work — fixture rows, a button that only shows a toast, a hardcoded list — and names what should replace it. The implementation has to do the real thing; a marker left in the implementation is rejected.
• Nothing you write there reaches anything. The directory is ignored by git and discarded with the worktree, and the prototype branch is never merged. Copy what you need into the real source tree instead of importing from it.

The copy is taken when the session opens. If the prototype is rebuilt or refined while you are working, reopen the session to pick up the new version. A session opened on a module's worktree gets one directory per member feature that has a prototype; a feature without one gets nothing.

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.