Running the legacy desktop app
When the legacy system is a Windows desktop app, Repave can run it, and an agent can check a scenario against the real app instead of you doing it by hand. Two checks are available on a feature's scenarios:
- Verify on legacy app, on an As-Is scenario. The agent performs the scenario on the legacy app and tells you whether it holds.
- Compare with legacy app, on a To-Be scenario. The agent performs the scenario on the new app and on the legacy app, and tells you where they differ.
Both checks show you the screens the agent saw and the database rows each app changed, so you can judge the agent's verdict yourself. Neither replaces your review: they save you doing the first pass by hand.
An agent can set up 32-bit Windows apps, such as those built with VB6 or Delphi. When your app needs more than that, a 64-bit build for instance, you can build its environment yourself and give Repave the image: see Use your own image. .NET apps have not been tried yet.
The screen is 1920×1080 at 125% unless you choose another Screen size, with ClearType and Windows 10's colours, so the app looks much as it does on a Windows PC. Microsoft's own fonts are not included; your own image can add them.
Set up the legacy app
Open Tools → Legacy App in the project's sidebar.
- Drop the app as a
.zip. It can be the folder the app is installed in, its installer, or both. Include the runtime installers the app needs, such as the VB6 runtime or MDAC, and any build or configuration meant for your test environment. - Paste the database connection string the app uses. Repave only reads the database through it, so a read-only login is enough. It must be a SQL Server login: Windows authentication cannot be used.
- Choose the Screen size the app runs at: one of the common sizes, or Custom… with a width and height from 640 × 480 to 3840 × 2160. It starts at 1920 × 1080.
- Optionally, write Instructions for agents: anything an agent should know to use the app, such as a window to close first or a company to pick at sign-in, up to 4,000 characters. Every agent that drives the app reads them before its first action on it.
- Click Set up legacy app.
An agent then installs the app, starts it and works out how to start it again. The page shows its steps and its latest screen while it works; this usually takes 5 to 15 minutes, and you can leave the page.
The agent asks you only for what it cannot decide or find itself:
- Which program is the app, when the zip holds several and it cannot tell which one users start. Each choice comes with what the agent saw it do.
- A test login, when the app's main screens are behind a login. If the app's own files name a default login, the agent offers it, and you can accept it in one click or give another.
- A missing file, such as a control the app needs that is not in the zip. Add that one file; you do not upload the zip again.
When the app is ready, the page shows its first screen, how it starts, and how many tables the connection can see. Replace app sets up a new upload, with the current screen size and instructions for agents filled in; checks keep using the current app until the new one is ready.
Edit changes the app's settings without setting it up again: the program to start, the screen size, the test login, the connection string, the instructions for agents, and for your own image, the image's name (to move to a new tag, for example). The password and the connection string start blank, and leaving them blank keeps the ones Repave has.
- A new test login, screen size or instructions are saved as they are, and apply from the app's next start or the next agent. The screenshot on the page stays as it was taken.
- A new connection string is saved once Repave can connect with it.
- A new program or image is checked first: Repave starts it and waits for its first window, as it does for a new image. Checks keep running the app as it was until that check passes. If it fails, the program and image stay as they were (anything else you changed in the same edit is kept), the page says why your change wasn't applied, and Edit opens with what you tried, so you can correct it. If a new image's registry asks for a login, give it, or choose Keep the current app to drop the change.
Every check starts the app from a clean copy of what setup built, so nothing one check does on the app's own machine carries into the next.
Use your own image
Some apps need more than an agent can do on its own: a 64-bit build, drivers or runtimes you install yourself, your own configuration tool, a login only you know. For those, build the app's environment once, however suits you, and give Repave the image. Checks then use it exactly as they use an agent-built one.
Build it from Repave's legacy desktop image. That image holds the screen tools agents drive the app with, so an image built on anything else cannot be checked. Either write a Dockerfile:
FROM repave-legacy-desktop:<your Repave version>
# A 64-bit app needs a 64-bit Wine prefix; a 32-bit app can keep the image's own.
ENV WINEARCH=win64 WINEPREFIX=/home/app/.wine64
RUN (Xvfb :99 -screen 0 1920x1080x24 >/dev/null 2>&1 &) && sleep 2 \
&& wineboot -i && wine regedit /S 'Z:\opt\ld\windows-look.reg' && wineserver -w; rm -f /tmp/.X99-lock
COPY --chown=app:app my-app/ /home/app/.wine64/drive_c/MyApp/
or start a container from repave-legacy-desktop, install and configure the app in it by hand, and
save it with docker commit. The windows-look.reg line gives a new prefix the same Windows-like
screen as Repave's own.
Give it to Repave. On Tools → Legacy App, choose Use my own image, then:
- Give the image: its name, either a tag on the Repave server (
my-legacy-app:2026-10) or a registry reference (registry.example.com/team/my-legacy-app:2026-10). A name with no registry is looked up on the Repave server only; a Docker Hub image starts withdocker.io/. Or click Choose file… and upload the filedocker savewrote (.taror.tar.gz, up to 50 GB). - Give the program to start, as a Windows path such as
C:\MyApp\MyApp.exe. It starts in its own folder. - Paste the database connection string, as for an agent's setup.
- If the app asks for a login, give a test login. The password may be empty.
- Choose the Screen size, and optionally write Instructions for agents, as for an agent's
setup. The screen size given here wins over an
LD_SCREENset in the image. - Click Use this image.
Repave then gets the image, checks it was built on Repave's legacy desktop image, connects to the database, starts the program and takes a screenshot of its first window. No agent is involved, so look at that screenshot on the card: it should be your app's first screen, not an error. If the registry needs a login, Repave asks for one and uses it for that pull only. An uploaded file is deleted once it is loaded.
If the image cannot be used, the card says why: no image by that name, an image not built on Repave's image, a program that is not in the image, or one that exits or opens no window. Use another image brings the form back with what you gave before.
An app whose database runs on the Repave server itself can reach it at host.docker.internal.
Verify a scenario
On a feature's As-Is scenarios, open a scenario's ⋮ menu and click Verify on legacy app. The check starts at once. The agent uses the app as a person would: it clicks, double-clicks, types, presses keys, and drags one item onto another. A badge on the scenario shows its progress and then its result:
| Badge | Means |
|---|---|
| Legacy: Passed | Every step held, on screen and in the data. |
| Legacy: Failed | A step did not hold. The report names it and shows what happened instead. |
| Needs review | The agent could not decide, for example because the scenario does not say whether what it saw is acceptable. It says why. |
| Legacy check couldn't run | The check never reached a verdict, for example because the app crashed. The reason and the fix are shown. |
Click the badge to open the run: each step with the screenshot it was judged from, the rows inserted, updated or deleted, the tables the agent checked, and anything it could not check. Click a step to see its screenshot, and click the screenshot to see it full size, with Previous and Next through the steps.
Verify every scenario of a feature
To check a whole feature, open the feature's actions menu (beside Refine) and click Verify on legacy app, then Verify in the dialog. One agent run, in one copy of the app, checks the feature's As-Is scenarios, instead of a separate run for each.
- Instructions for the agent (optional): tell it what to focus on or what is known not to work, for example "check the price rules first; the test login cannot open Administration". It orders or narrows the work, and cannot add scenarios the check was not given.
- Once some scenarios have a result, the dialog also asks which to verify, as a module's does: Everything that hasn't passed, Only scenarios not verified yet or All scenarios, from the start.
The menu item reads Verifying… and cannot be clicked again while the run goes, and each scenario shows its Verifying on legacy app badge. As the agent finishes a scenario it reports it, and that scenario's badge turns into its result straight away, with the same run and suggested changes as a single-scenario check. Clicking a scenario that has not been reached yet says it is being verified as part of the feature's check.
The agent chooses what to drive. It reads the whole feature and the code first, walks the scenarios that share screens together, and drives every high-value scenario (the main path, each rule and validation, each data change, message and screen), the main path first. It leaves out only a scenario another one it drives already shows, or one something it tried blocks. It works through them however long that takes, and changes data through the app's own screens as a scenario needs.
- A scenario it leaves out shows Legacy: Not verified, with the agent's reason on the badge and in its run, for example that another scenario walks the same path, or that a menu is not available to the test login. One problem that blocks several scenarios is recorded once for all of them. Verify again in the run checks that scenario on its own.
- A scenario that already had a result keeps it when the agent leaves it out: it never takes on the result of the scenario that covered it.
- Every other scenario ends with a result. One the agent neither reported nor left out, and every one left when the app stops or the run is cancelled, shows Legacy check couldn't run with the reason; what was already reported stays, and a scenario can be verified again on its own.
- A result the agent wrote in a form Repave cannot read ends only that scenario, and the reason names the field that is wrong in a line. The agent is shown the form, and is told which field to fix when it reports.
- If the agent made no report that could be recorded for any scenario and left none out, the feature check ends in an error instead of completing, and says whether the reports were missing or could not be read.
- The scenarios share one session of the app. If it crashes, the scenarios after it can't run.
- The item is not shown to viewers or on a project with no legacy app. It is disabled, with the reason, until the legacy app is ready or when the feature has no As-Is scenarios, and it cannot start while any of the feature's scenarios is already being verified.
Verify every scenario of a module
To check a whole module, open the module's actions menu (⋯ beside its name) and click Verify on legacy app, or click the same button at the top of the module's Legacy Screens tab, then Verify in the dialog, which takes the same optional instructions for the agent as a feature's. One agent run, in one copy of the app, takes every member feature that has As-Is scenarios, one after another, and the scenarios of each, choosing what to drive in each member as a feature's check does. It works like a feature's check, for every member at once:
-
The first time, it checks every scenario. Once some scenarios have a result, you choose which to check: Everything that hasn't passed (the default: the failed ones and those not verified yet), Only scenarios not verified yet, or All scenarios, from the start. Each choice says how many scenarios it checks, and a choice that would check the same scenarios as another is not shown. When every scenario passed, or every one failed, you are asked whether to check them all again. Scenarios left out keep the result they have. "Failed" includes Needs review, and a check that couldn't run, or a scenario the agent left out with no earlier result, counts as not verified yet.
-
Each scenario gets its own result, run and suggested changes, on its feature's page, as soon as the agent reports it or leaves it out. The screens it keeps appear on its feature's and the module's Legacy Screens tab within seconds, without a reload, and a scenario not reached yet says it is being verified as part of the module's check.
-
While the run goes, the menu item reads Verifying… and the tab's button is hidden.
-
A scenario the agent neither reported nor left out, and every one left when the app stops or the run is cancelled, shows Legacy check couldn't run with the reason; what was already reported stays. A member none of whose scenarios was reported or left out ends in an error, and so does the module's check when nothing at all could be recorded.
-
Members without As-Is scenarios are left out. The item and the button are disabled, with the reason, until the legacy app is ready or when no member has As-Is scenarios, and a check cannot start while any scenario of a member is already being verified: the message names the feature and the scenario. Viewers see neither.
-
The run's cost shows in the module's AI usage.
Suggested changes
The legacy app is the reference for the As-Is. When the agent sees that the As-Is does not describe what the app did (a caption worded differently, a field that turned out to be optional), the run suggests changes, whatever its verdict. A change can be to:
- the scenario it verified, or another As-Is scenario in the same feature that makes the same claim;
- the feature's Rule descriptions and Backgrounds;
- a To-Be scenario written from a scenario it changes.
While a run has suggestions you haven't decided on, its badge says so, for example Legacy: Failed · 3 to review. Open the run: Suggested changes comes first. Each change shows what the agent saw, with a link to the step's screenshot, and the lines it would change. Click Accept or Reject on each, or Accept all. An accepted change is an ordinary edit to the feature: it keeps the scenario's id, so the To-Be stays linked to it, and accepting a To-Be change withdraws the approval of that scenario only.
- Closing the run loses nothing. Its badge, and the Checks list on the Legacy App page, open it again.
- If someone edits a scenario after the run, its change can no longer be accepted, and says so. Verify again for a new suggestion.
- Verifying the same scenario again replaces the earlier run's undecided suggestions with the new run's.
- Viewers see the suggestions, but only editors can accept or reject them.
Legacy screens
Repave keeps the legacy app's screens, so its real labels, fields and data are not lost after the check. They belong to the feature, and each says which of its As-Is scenarios it shows.
- A feature's or module's check keeps its screens. The agent keeps each distinct screen and state it sees once (a form, a grid with data, each dialog and message), with a caption and the scenarios it shows. A screen kept with a caption the feature already has replaces the older one, so checking the feature again does not pile up copies.
- A single scenario's check keeps the screen it judged each step from, and its final screen. For each As-Is scenario, those of its latest Verify that reached a verdict are offered, unless that Verify kept screens of its own. A newer Verify replaces them, and a check that couldn't run does not.
- On the feature page, the Legacy Screens tab shows them in one grid: the kept screens first, then the step screenshots. Each shows its caption, the scenarios it shows, and who kept it or when it was verified. Click a screen to see it full size, and step through the grid with Previous and Next.
- On a module's page, the same tab shows one grid under each feature's name.
- Other agents can add screens. An agent that looks at the legacy app while it works can keep a screen of the feature in the same way, marked "Kept by" the agent and the time. Only screens an agent chose to keep are stored: a feature keeps its newest 60, and an agent keeps at most 20 of a feature in one run.
- UI prototyping uses them. When Repave designs a feature's prototype, the agent exports these screens, opens the ones for each scenario it builds, and makes the prototype like-for-like with them: the same layout, controls, labels, columns, dialogs, icons and states, and puts the page where the legacy app puts it in the menus, from the path the Verify recorded. Where the To-Be scenarios drop or change a screen they win, the application shell wins for the page chrome, and a Figma design wins over everything it covers. The project's design system sets fonts, colours and spacing only: it never turns an icon toolbar into text buttons or changes a screen's layout. The agent is asked to say in its final message which screens it changed and which it could not match.
- A second agent checks the prototype against them. After a feature with legacy screens is built — as stories, or on your target stack — another agent opens each state's legacy screen next to the prototype. A difference nobody asked for goes back to the builder to fix, up to the project's fix attempts, and the feature's Stories (or Prototype) view then says either "Checked against the legacy screens — the stories match" or which differences remain. It always runs when a feature has legacy screens; there is nothing to turn on.
- Want a new design instead? Say so in the instructions. Write it in the instructions box when you generate or adjust the prototype — "reimagine the toolbar as a side panel", or "a new design for this screen" — and the check accepts the new look for that part. Instructions are remembered, so a later "fix the button colour" does not undo the redesign. When the check cannot tell what you meant, it asks you once whether that part should match the legacy screen or keep the new design, and follows your answer from then on.
The tab appears once the project has a legacy app. Setting the app up again keeps the screenshots of earlier setups too, and the application shell's design can refer to them.
Side by side
The feature page's Side by side tab puts one legacy screen next to one story. A dropdown at the top picks the scenario, with Previous and Next arrows beside it. Beside the legacy screen, the arrows step through the screens of the As-Is scenarios that scenario traces to: the Verify's screens, then every kept screen that shows one of them. The right half is the scenario's story, started the way the Preview tab starts it, with the same Adjust and Accessibility buttons above it; the legacy screen starts level with the story's app. A scenario with no traced legacy screens or no story says so. Maximize fills the window with the two halves, and Restore puts it back. The tab appears under the same rule as Legacy Screens: the project has a legacy app. While Adjust or Accessibility is open, the story half takes two thirds of the width, so the story stays readable beside the panel.
A module's page has the same Side by side tab, over every member: the dropdown lists every member's To-Be scenarios under the member's name, and Next walks on from one member's last scenario to the next member's first. Each story is its feature's, as that feature's own page shows it, so Adjust and Accessibility work on that feature: what you send from Adjust goes to that feature's agent.
Filter by status
Above the list on both tabs, a row of buttons narrows it to one status: All, Passed, Needs review, Failed and Not verified, each with its count. Only the statuses something on the tab has are offered, and the row is hidden when everything has the same one.
- On Legacy Screens, the buttons count screens. A screen takes the worst status of the scenarios it shows, each its latest Verify's verdict or Not verified; a screen that shows no scenario is Not verified. On a module's page, a feature with no screen of the chosen status is left out, heading and all.
- On Side by side, a To-Be scenario takes the worst status of the As-Is scenarios it traces to: Failed, then Needs review, then Not verified. It is Passed only when every one of them passed. The dropdown and the Previous and Next arrows go through only the scenarios of the chosen status.
- The choice is remembered for the feature or module, and both tabs share it. Pick Failed on Legacy Screens, open Side by side, and the failed scenarios are already there beside their stories. If no scenario has the remembered status any more, for example after a re-verify passed the last failed one, the tab shows All. Your choice comes back once a scenario has that status again.
Compare with the new app
On a feature's To-Be scenarios, once the feature is implemented, open a scenario's ⋮ menu and click Compare with legacy app. The agent runs the scenario on the new app, in its Implementation Preview, and the As-Is behaviour it came from on the legacy app.
The result is Matches legacy or Differs from legacy, with the differences listed first and both apps' final screens and database changes side by side. Columns that are expected to differ, such as generated keys and timestamps, are ignored, and the report lists every column it ignored.
Test data on a shared database
Checks act through the app, so they write to the database the app uses, as a tester would.
- Values already taken. When a scenario creates a record whose ID only has to be new and that ID is already taken (often by an earlier check), the agent uses an unused one and says so in the report. When the scenario is about that exact value, the agent keeps it, or reports Needs review if it is in the way.
- Records a Compare needs on both apps. When a scenario needs a record that exists on only one side, the agent creates it on the other side for the run and removes it afterwards. On the legacy side it can do this only if the connection string's login can write.
- What is left behind. Every report lists the rows the check created or changed, under Left in the UAT database, so you can clean up.
Checks do not wait for one another. Each starts its own copy of the app, so several can run on a project at once. They all use the same UAT database, so each agent checks that a value is free just before it saves it, and picks another value, noting it in the report, if another run took it first.
Other agents can use the legacy app
Verify and Compare are not the only agents that can look at the legacy app. Once the project's legacy app is ready, every agent that uses tools can start its own copy of the app when it needs to see what the app does, and drive it with the same tools. So feature analysis, To-Be generation, prototyping, implementation, code review and testing can look at what the legacy app does instead of working only from its code. There is nothing to switch on.
- An agent's copy starts the first time the agent uses it, which takes about a minute, and is removed when the agent's run ends. An agent that never needs the app starts nothing.
- Agents may save, change and delete records in the app when their task needs it. Every run uses the same UAT database, so each agent lists the rows it left behind in its output.
- An agent never asks you to approve what it does on the legacy app: clicking, typing (signing in with the test login included), its setup commands, and queries on the database the connection names all go ahead without an approval in the agent chat. Its other actions are checked as before.
- A copy that runs for a feature can keep screens under that feature's scenarios; see Legacy screens.
- To have feature discovery start from the app, use Discover with legacy app in the Discover features dialog, and to have a refinement check a feature against it, tick Verify against the legacy app in the Refine dialog; see As-Is. Both are offered whenever the legacy app is ready.
- If the app will not start, the agent is told why and carries on from the code. The exceptions are Discover with legacy app and Verify against the legacy app in the Refine dialog, which start the app before they begin, and fail and say why if they cannot.
- Agents cannot use the legacy app on installations that run agents on Kubernetes.
Run it yourself
Once the legacy app is ready, Run app on Tools → Legacy App starts your own copy of it, and the card shows its screen live. Click it, type in it and use it as you would on a Windows PC.
- The app starts the first time you use it, which can take a few minutes; the card says Starting the legacy app… until then.
- Everything you do on the screen reaches the app: clicks, double-clicks and right-clicks, dragging, hovering (so tooltips show), the mouse wheel, typing, and keys with Ctrl, Alt or Shift. Keys go to the app while the screen has focus, including Tab.
- Maximize shows the app over the whole window. Restart gives you a fresh app, after asking. Stop removes it now, after asking; the card then shows Run app again.
- If the app could not start, the card says why, and Retry tries again.
- Each person has their own copy. Yours keeps running while you move around Repave, and is removed 15 minutes after nobody watched it and the assistant last used it.
- You need edit access to the project, because the app writes to the same test database agents use: see Test data on a shared database. It is not available on installations that run agents on Kubernetes.
With the project assistant
The project assistant uses your copy of the app: the one Run app shows. Ask it to open the app, or to try something in it, and the screen appears at the top of the assistant's panel, live.
- You can click and type on the screen there too while the assistant works. You and the assistant share one app, so take turns: an action from one can land in the middle of the other's.
- The screen grows with the panel's Split screen and Maximize, and Minimize folds it to one line. Restart and Stop work as on the Legacy App page.
- If you stop the app, the assistant starts it again the next time it needs it.
- Unlike other agents, the assistant does not remove the app when it finishes: it stays for you until you stop it or leave it unused for 15 minutes.
Use it in the Repave IDE
In a Repave IDE session on a project whose legacy app is ready, Claude Code and Codex can drive the app with the same tools as agents, and you can watch it and drive it yourself in the Legacy App panel.
- Open the panel with Repave: Open Legacy App in the Command Palette. It also opens by itself when Claude Code or Codex first uses the app.
- The app starts the first time it is used, which can take a few minutes, and the panel says Starting the legacy app… until then. It is removed when the session stops.
- Click, scroll and type on the screen as you would on a Windows PC. Keys go to the app while the screen has focus, including Tab.
- You, Claude Code and Codex share one app: what one does, the others see. Take turns, so an action does not land in the middle of the other's.
- Restart gives you a fresh app, after asking, if it gets stuck. If the app could not start, the panel says why, and Retry tries again.
- You need edit access to the project. The app writes to the same test database agents use: see Test data on a shared database.
All checks
Tools → Legacy App also lists every check in the project, newest first, with its result, its feature and scenario. Click a result to open the run.