Reading the analysis
The analysis is what the platform understood about your legacy system. It is not a rewrite plan and it is not a specification yet — it is the evidence everything after it is argued from, and it is worth reading before you accept any of it.
As-Is Architecture
The legacy system's structure as extracted from the code: its components, how they relate, and where the boundaries fall. This is generated, so read it as a reading of the code rather than as a statement of intent. Where it is wrong, it is usually wrong in an informative way — it reflects what the code actually says rather than what the original design intended.
The database
Three surfaces, from different angles:
- DB ER Diagram — the entities and their relationships.
- DB Table Catalog — every table found, with its columns.
- DB Objects — views, procedures and the rest of what lives in the schema.
These come from the code and the schema as found. A table the legacy application never touches can still appear here; a table built by a process outside the codebase may not.
Views
What the legacy application presents to its users, screen by screen. The View Catalog is the inventory; individual views carry the detail. These matter more than they look like they should: a to-be scenario about a screen is anchored to the view it describes, and the implementation agents are told which view they are reproducing.
Modules
The module is the unit of work. Discovery, decision and delivery all happen a module at a time, on one branch, and one agent per role does a whole module's work. This is the single most useful organising idea in the product: if you are wondering why features are grouped the way they are, or why an implementation touched more than you expected, the module is usually the answer.
A module is created by naming it — in Group Features to Module from the features list, or in the
Module field of Discover Features. When the name has no Latin letters, an English name
(optional) field appears beneath it: the module's branch is named from it, so 客戶管理 with the
English name customer management works on module/customer-management-…. Leave it empty and
Repave names the module in English itself within a minute or so. Rename in the module's ⋯
menu edits both names later.
External and internal systems
What the legacy system talks to, and what will happen to each: kept, replaced, or mocked. Discovery files each system in one of two lists:
- External Systems are owned by a third party: an email provider, a card processor, a SaaS service.
- Internal Systems are your organisation's own systems that the legacy app integrates with but that are not part of the code being modernized: core banking, a shared login service, an internal CRM. The architecture draws them inside your organisation's boundary, and implementation reuses the contract or client library the legacy code already has for them. An internal system is either kept or abandoned in the modernized app; replacing it is your own decision, not this migration's.
When the code does not settle who owns a system (a host that only appears as a setting, or a vendor package you may run yourself), discovery does not guess. It asks you in the agent chat, with what it found, and waits for your answer: pick Internal or External and click Send answer, and it files the system where you said. The running-agents list shows the run as Waiting for you until then. If you click Let the agent decide, it files the system where the evidence leans and tells you which way it went.
When the project has Agents can ask you and hear from you turned off, discovery cannot ask while it runs. It files the system under External Systems and asks in a Needs your decision card at the top of both pages instead, where one click on Internal or External settles it. Either way, a later discovery run never reopens your answer. You can also move any system between the two lists from its row; the move takes its scenario references with it, and Undo puts it back.
Linking an internal system to another Repave project
When an internal system's code is itself a Repave project (your app calls an API provider your organisation is modernizing too), the two get linked. Usually you do nothing: discovery links a system when its calls clearly match another project's APIs, and asks you in the agent chat when two projects match equally or the evidence is thin. Answer with the project, or Neither project. For systems found before, click Find linked projects on Internal Systems, or the link icon on one system's row. A link an agent made says why when you expand its row.
It does not matter which project comes first. Repave checks the links again whenever either side changes: when a job finishes in either project, when a system moves into Internal Systems, when someone edits an API, and every ten minutes. A clear match is linked by itself, and its row says Linked automatically with the evidence. An unsure one starts an agent that asks you in the agent chat. Linked systems follow the other project's changes: a new API gives an unmatched call its endpoint, a renamed one updates your citations, and a scenario added later is cited too.
A no covers only the projects it was about. Neither project in the chat, or removing a link, means agents won't link the system to those projects again, but a project created later can still be asked about. A system whose calls your own project's code serves, such as a repository in your own workspace, is part of the app and is never linked: its row says Part of this app, with Delete it.
To link by hand, edit the system and choose the project under Linked Repave project, then which of its APIs apply: its legacy APIs, its modernized API catalog, or both. With both, the as-is work cites the legacy APIs and the to-be work cites the modernized ones, following the other project's own mapping from each legacy API to its replacement. Choosing Not linked removes a link, even to a project you can't open, and agents won't link that system to that project again.
To decide which project a system is, the agent can read every project in this installation: their API catalogs and legacy code, read-only. What it quotes as evidence can show a little of a project you can't open.
Linking does these things:
- Every call names the exact API it uses. Expanding the row lists the APIs your code calls, each with where it calls them; Show all shows the rest of the other project's catalog. When the other project's code serves a call its catalog is missing, the agent adds that API to its catalog, marked Added by your project there. If that project's people delete it, it is not added again.
- A call through another project shows where it ends up. When the other project is itself a gateway or a service that calls on, each API your code calls says where it goes next, such as → Core Banking Platform · Account Balance API, and expanding it shows every hop under Goes on to. Where the path stops, it says why: an internal system there not linked yet, no matching API, or an external system.
- Your scenarios cite its APIs. Repave adds each API to the scenarios whose code makes the call. When no calls were recorded yet, an agent finds them first; the row says so while it works. Calls that still match no API are listed.
- Your agents build against its real contracts. Implementation reads the contracts of the APIs
your code calls, generates the client and the test stubs from them, and reads the other project's address from a
setting named after the system, such as
CORE_BANKING_BASE_URL. - You see what needs attention. The row flags an API the other project is dropping, an API your scenarios cite that is no longer in its catalog, and a link that was lost because the other project was deleted or its owner removed the link.
Linking needs edit access to your project and access to the other one. Once linked, everyone on your project can read the other project's API catalog, and nothing else of it. The other project's API Catalog shows which projects link to it, and its owner can remove a link.
A system marked for mocking gets an explicit mock strategy that implementation agents respect, rather than each agent inventing its own. Renaming or merging a system keeps every scenario reference in step, and deleting one warns you about the references first and cleans them up rather than leaving scenarios pointing at nothing.
The legacy code itself
The Legacy Code Viewer shows the source. You will mostly arrive here from a scenario: a scenario's related files open at the lines they were annotated with, so you land on the code the behaviour was extracted from rather than at the top of a file.
What is extracted, and what is inferred
Worth holding in mind as you read:
- The database catalogs, the view inventory and the file-level structure are extracted. They are what the code contains.
- The architecture, the module grouping and the scenarios are inferred. They are a model's reading of the code, and they are what you are being asked to review.
Requirements-based analysis, where your installation has it enabled, is deliberately kept out of the as-is Gherkin: a requirement is something you want, and the as-is records only what the legacy system does.
Re-running it
Analysis is re-runnable. The common reasons are a codebase that has moved on since it was uploaded, or an analysis that was clearly wrong about something structural. Re-running replaces the analysis, so review anything you have already decided before you do.