Legacy Modernization Pod · Forge Modernization
Legacy Migration & Modernization
Rebuild it from evidence, not from memory.
Nobody left knows how the system works, and the documentation never existed. A Legacy Modernization Pod recovers what it actually does, then designs, builds and tests the replacement against that. Four phases, each signed off by a named human. Forge Modernize runs on the AI coding agent you already use.
- phases, analysis to tested rebuild
- 4phases, analysis to tested rebuild
- gates, each closed by a named human
- 4gates, each closed by a named human
- commands, 11 on the critical path
- 20commands, 11 on the critical path
- legacy estates supported
- 3legacy estates supported
The situation
Does this sound familiar?
Two things are usually true at the same time.
Why now
- The framework reached end of life, and security patches stopped with it.
- You cannot hire for the stack, and compliance has started asking.
Why it has not happened yet
- The last person who understood the system has left.
- The documentation describes a version that shipped years ago.
- Every estimate is a guess, because nobody can list the business rules.
The deadline is real and the knowledge is gone. The system has become the only surviving specification of itself.
Who it is for
Is Forge Modernization for you?
It is for a system that has become the only specification of itself. It is not a greenfield tool.
Best for
- A running system nobody left can explain, with documentation that never existed or describes an old version.
- A framework past end-of-life, with the security patches gone and compliance starting to ask.
- Estates where every estimate so far has been a guess, because nobody can list the business rules.
- Owners who want a signed gate before each phase rather than a big-bang cut-over.
Not a fit for
- Greenfield builds with nothing to recover — start with Forge Spec instead.
- A lift-and-shift that keeps the code and only moves the hosting.
- Systems you cannot give us source access to. Recovery reads code, not memories.
- Anyone who wants the rebuild without the analysis. The specification comes first, by design.
Phase 1 output
First, the specification nobody ever wrote.
One subsystem, in Markdown, so it lands in your wiki rather than an inbox.
AS-IS_<screen>.md
Every screen gets one of these.
- 1Layout and transition diagram
- 2Field definitions and validation rules
- 3Tables touched, with a CRUD matrix
- 4Business rules, code values, access control
- 5Unresolved items and migration notes
Read the last section first. It is the one that tells you what we could not work out.
Everything the rebuild does is measured against these documents. That is what makes phases 2 to 4 auditable rather than hopeful.
The migration
From legacy source to a tested rebuild.
Four phases, and nobody leaves one without signing. A gate is a stop, not a notification — work on a phase whose predecessor is unsigned is refused.
Gate G1
Exploration
- In
- Your source, or the documents that survived
- Runs
- The source is parsed into a call graph down to individual branches. Rules are extracted, then attacked by a second pass before anything is written down.
- Out
- BUSINESS_RULES.md
- DATA_CATALOG.md
- AS-IS_<screen>.md
- AI_UNCERTAINTY.md
- er-diagram.md
Signs: Verification lead · architect · business analyst
Gate G2
Design
- In
- The signed specification
- Runs
- A basic and detailed design per module, plus a clickable prototype of every screen your users will touch.
- Out
- BasicDesign.md
- DetailDesign.md
- prototype.html
- IMPLEMENT_PLAN.md
Signs: Solution architect · PM
Gate G3
Coding
- In
- The signed implementation plan
- Runs
- Each work unit is broken down, then implemented into your application repository with evidence recorded per unit.
- Out
- TASKS.md
- source in your repo
- G3_evidence.md
Signs: Engineering lead
Gate G4
Testing
- In
- The rebuilt application
- Runs
- Forge QA generates and runs the tests. Every failure is triaged: is this the migration, or the test?
- Out
- TEST_HANDOFF.md
- test suite in your repo
- G4_evidence.md
Signs: QA · your final acceptance
Two machine checks run before a human sees G1. A run can have every document present and still be refused, because completeness is not the same as quality.
Members only
Who signs which gate
7 roles · G1–G4 · the customer is accountable throughout
Sign in to unlockMembers only
What blocks, and what only advises
3 blocking checks · 1 advisory prompt
Sign in to unlockEvery command, what it does.
Twenty commands. Eleven sit on the critical path — around fourteen invocations per migration, since a gate review runs once per phase. The rest are integrations and utilities the main flow calls for you.
It runs on your own coding agent and makes no model calls of its own. No separate inference bill, and your source never leaves the environment you already trust.
Open the command referenceWhy trust it
Every rule says how sure we are.
Each rule is anchored to the construct it came from, and the anchor survives refactoring. "Where does this come from?" is answered with a location.
- Proven
- Read in the code, and the effect check agreed.
- Carried into design as ground truth.
- Inferred
- The rule is real. Its runtime effect is not independently confirmed.
- Routed to the reviewer who owns that area, by name, before G1 closes.
- Contradicted
- The code does not do what the rule says it does.
- Stops for a preserve-or-fix decision. Never silently corrected, never copied.
Most rules land Inferred, and that is the point. Proven has to be earned twice — once by reading the code, once by a check that the code does what the rule claims.
It finds the bugs you were about to rebuild.
A second pass argues with the first. One half re-checks every citation. The other ignores the claims and asks what the code does that no rule accounts for.
It finds real bugs in the legacy system — deletes that were never scoped, redirects that do not stop execution, calls into functions that no longer exist. You hear about them before they become features of the new system.
We do not issue a report that claims zero defects, because no static analysis of a live system has ever earned that claim.
What we migrate
Three estates, and a path when yours is not one of them.
Mixed estates are the normal case. One subsystem with a design document and four with code only is an ordinary starting position.
PHP
Framework or none. Procedural page-per-file included.
COBOL
Mainframe estates, screens and batch.
.NET
Legacy ASP.NET and VB.NET.
No source we can parse?
The documents-only path is language-independent. Specifications, PDFs, spreadsheets, screenshots — whatever survived feeds the same pipeline and produces the same bundle.
What it gets rebuilt on
Your choice, agreed at scoping. The method does not care about the target.
You get a security position too
A decade-old estate has a decade of accumulated exposure. The same pass that recovers your rules produces a prioritized security read on the legacy system, with the noise adjudicated out.
Questions we get asked
The ones that decide it.
- We have no documentation at all. Is that a blocker?
- It is the usual situation, and the reason this exists. Four out of five systems in a typical estate have code only. Reverse-engineering is the main path here, not the fallback.
- How do we know the AI did not invent a rule?
- Every rule is graded and anchored, and a second pass exists to attack the first. A rule that cannot be evidenced does not get to look like one that can.
- Is this a black box?
- No. Our engineers review what the agent produces, named reviewers are assigned to specific findings rather than whole documents, and your side holds acceptance at every gate.
- Can our team run this after handover?
- Yes. We prove the workflow in staging and hand over a method your team reproduces with standard tooling. The automation that speeds up our own execution stays ours.
Members only
How to audit a bundle, in order
7 steps · what a verification team checks first
Sign in to unlockMembers only
Limitations, stated plainly
6 limits · read as carefully as the capability copy
Sign in to unlockStart
Start with the part that is hardest to fake.
Give us one subsystem. You get its real business rules, its real data model, and an honest list of what we could not determine. That is the same Phase 1 output a full migration runs on.