Back to AI Pods

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.

deliverables/
INDEX.md— start here — every output, by concern
01-understanding/
OVERVIEW.md— modules, data flows, external systems
BUSINESS_RULES.md— one row per rule, with its source line
AI_UNCERTAINTY.md— what we could not determine
REQUIREMENTS.md
MIGRATION_STRATEGY.md— and what not to carry forward
BATCH_WORKFLOWS.md
02-data-model/
DATA_CATALOG.md— entities, field dictionary, CRUD
03-security/
SECURITY_ISSUES.md— adjudicated, not raw scanner noise
04-operations/
DEPLOYMENT.md
LOGGING.md
05-testing/
CHARACTERIZATION.md— the plan for proving parity
TRACEABILITY.md
COVERAGE_GATE.md
06-governance/
REVIEW_CRITERIA.md— what each role must sign
single-page/one per screen
AS-IS_order-entry.md
AS-IS_error-screens.md
wireframes/
navigation-map.html— clickable, pan and zoom
er-diagram.md— declared keys solid, inferred dashed

AS-IS_<screen>.md

Every screen gets one of these.

  1. 1Layout and transition diagram
  2. 2Field definitions and validation rules
  3. 3Tables touched, with a CRUD matrix
  4. 4Business rules, code values, access control
  5. 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 unlock

Members only

What blocks, and what only advises

3 blocking checks · 1 advisory prompt

Sign in to unlock

Every 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 reference

Why 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 unlock

Members only

Limitations, stated plainly

6 limits · read as carefully as the capability copy

Sign in to unlock

Start

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.