At a glance
Starts from: Visual Basic 6, Delphi, MS-DOS or .NET Framework software and the people who know its rules
Built with: Claude Code, Codex and Grok, agreed in writing before any of them sees your code
Ends with: An event-sourced system on .NET 10, its tests, and a team trained to extend it
First step: Free 1-hour consultation, then a fixed-scope assessment
U.S. delivery: 100% U.S. citizen workforce, U.S.-soil delivery
What to know before you modernize
AI made writing code cheap. Checking it is the hard part.
Claude Code, Codex and Grok will translate a Visual Basic form or a Delphi unit into C# in minutes. The result compiles and often runs. What nobody can tell from reading it is whether it still computes the discount, the credit hold, or the month-end close the way your business does, because those rules were never written down outside the legacy code. A 2026 case study put a number on it. Researchers had Claude Code migrate 12 features of a Visual Basic 6 ERP system to C# on .NET 10 in a single pass, then compared each one with the original. Equivalence averaged 70 percent: 92 percent for the low-complexity features and 47 percent for the high-complexity ones. A team new to AI tools hits this on the first day. A team that has used them for a year hits it too, with more code to check. The bottleneck has moved from typing to knowing what the system must do and proving that it does it. This service is built around that bottleneck.
Automated VB6 conversion vs manual rewrite →
What AI tools can and cannot read in VB6, Delphi and .NET Framework systems
Visual Basic 6, Delphi and .NET Framework source code is text, and the AI tools read it well. The trouble sits around the code. A VB6 application leans on ActiveX controls that shipped as compiled OCX files, often from vendors that no longer exist, and no tool can read rules out of a binary. A Delphi application keeps SQL and event wiring in form files, depends on third-party components that came without source, and often sits on a BDE or Paradox data layer whose quirks the program relies on. A .NET Framework application keeps rules in stored procedures, triggers and WebForms code-behind. MS-DOS programs in QuickBasic or Turbo Pascal assume hardware and timing that no longer exist. In each case the tools translate what they can see and say nothing about what they cannot. The assessment lists those blind spots before the build starts, and the workshops recover the rules behind them from the people who know them.
The workshops come first
Before any tool generates anything, I run Event Storming workshops with the people who do the work: the order desk, the plant floor, accounting, whoever knows why the system behaves as it does. Together we lay out what happens in the business as a timeline of domain events, then the commands that cause them, the policies that react to them, and the rules that must never be broken. From that come the bounded contexts and a context map, the aggregates with their invariants, and a catalog of commands and events. These are the building blocks of domain-driven design. AI tools cannot do this part for you, because the knowledge is in people. It is also the part that makes everything after it fast.
A gap analysis against the system you run today
The workshop says what the business does. The legacy system says what the software does. The two never match exactly. I read the legacy code and data against the model and list every difference: rules the code enforces that nobody mentioned, rules people described that the code does not enforce, and behavior that exists only because of a bug someone learned to work around. The AI tools are useful here early, because they read a large codebase quickly and can point to where a rule lives. You decide, item by item, which behavior the new system keeps. Nothing is carried over or dropped by accident.
What you get from Event Storming →
Every rule becomes a test your people can read
An event-sourced system has a property that suits this work. Each rule can be written as a short scenario: given these events have happened, when this command arrives, then these events are recorded, or the command is refused. A scenario reads close to plain English, so the person who owns the rule can confirm it before any code exists. The scenarios are also executable tests. They are the specification the AI tools build against and the check that runs on every change afterward. Where the legacy system is still running, I replay real cases through both systems and compare the results.
Event Sourcing and CQRS book →
Then the AI tools build it
With the model and the scenarios in place, the build is where the speed comes from. Claude Code, Codex and Grok write the aggregates, the event handlers, the read models and the plumbing against a target architecture I know in detail: event sourcing and CQRS on .NET 10, the subject of my 498-page book. I use more than one tool on purpose. One writes, another reviews, and the places where they disagree get my attention first. I read what they produce, and nothing is accepted until its scenarios pass. The architecture starts from a design I have documented in full and is adjusted to your domain, your data and your operations.
What gets faster, and what does not
The build is the part that gets faster, because the AI tools work from a precise model and a set of tests instead of guessing at intent. Other parts keep their own pace. Workshops depend on when your experts are available. Data migration depends on the state of the data. Running old and new side by side lasts until it has covered a month-end or a season. Cutover happens when you are ready. The schedule I give you separates the two, so you can see which dates depend on me and which depend on your calendar.
One bounded context at a time
The work is scoped and quoted per bounded context. The first one is chosen in the workshop: small enough to finish, important enough to matter, with a clear seam to the rest of the legacy system. It goes into production behind that seam while the old system keeps running everything else. You see a real result early, you learn what the process costs, and you decide about the next context with evidence. A big-bang rewrite asks you to trust a date a year out. This asks you to judge one delivered piece.
Which AI tools see your code, and on what terms
Using these tools means your source code is processed by their vendors: Anthropic for Claude Code, OpenAI for Codex, xAI for Grok. You should know that before you sign, so it goes in the contract. We agree in writing which tools may be used on your code, under which account and data terms, and what is never sent to them, such as production data, credentials and personal information. If your policy rules out one vendor, I work without it. If it rules out all of them, the workshops, the model and the tests are done the same way, and the build is quoted without AI assistance. All work is done in the United States by US citizens.
Compliance and U.S. workforce posture →
Your team learns the process
The engagement ends with your developers able to continue. They sit in on the workshops, so they know where the model came from. They get the scenarios, the prompts, the tool configuration and the review checklists I used, in your repository. I pair with them on the next piece of work until they are extending the system with the same tools and the same checks. If you have no developers, the same material is what you hand to whoever maintains the system next, and I can stay on to do that work.
Start with an assessment
If the legacy system has not been inventoried, the first paid step is the fixed-scope Legacy Software Assessment: a read-only review of the source, database, configuration and logs that ends in written findings and a recommendation. It tells both of us whether this approach fits, which bounded context to start with, and what stands in the way, such as components with no source or data that needs repair first. The fee is quoted after the free 1-hour consultation and is creditable toward the modernization project.
Deliverables
- A context map, a domain model, and command and event catalogs from the Event Storming workshops
- A gap analysis of the legacy system against the model, with a keep or drop decision for each difference
- Business rules written as given-when-then scenarios that your domain experts have reviewed
- An event-sourced system for the agreed bounded context, in production, with its test suite
- A written agreement on which AI tools may process your code and on what terms
- The prompts, tool configuration and review checklists, in your repository
- Hands-on training for your developers on the tools and the process
Common questions
What is AI-assisted legacy modernization?
It is a modernization where AI coding tools such as Claude Code, Codex and Grok write most of the new code, and a domain model built with your people decides what that code must do. Event Storming workshops capture the business rules, each rule becomes an executable test, and the tools build an event-sourced system that has to pass those tests.
Can AI modernize a legacy system on its own?
No. AI tools translate code they can read, but legacy systems carry rules that exist only in compiled components, in data, and in people's heads. A tool cannot know whether its output matches a rule nobody wrote down. Someone has to capture the rules with the people who own them and check the result against them. That is the work I do around the tools.
Does AI-assisted modernization work for VB6 and Delphi applications?
Yes. VB6, Delphi, MS-DOS and .NET Framework source code is text that the AI tools read well. What they cannot read are compiled ActiveX controls, components that came without source, and rules that live in stored procedures, in data, or in people's heads. The assessment lists those blind spots, and the Event Storming workshops recover the rules behind them.
How much faster is AI-assisted modernization?
The build phase is faster, because the tools work from a precise model and a set of tests. I do not publish a multiplier, since it depends on the domain and the state of the legacy code. Workshops, data migration, parallel running and cutover keep their own pace. You get a schedule that shows which dates depend on me and which depend on your calendar.
Will my source code be sent to AI vendors?
Only with your written agreement. Claude Code, Codex and Grok process code on their vendors' systems. Before work starts we agree which tools may be used, under which data terms, and what is never sent, such as production data, credentials and personal information. If your policy excludes one vendor, or all of them, the engagement is planned without those tools.
Why use event sourcing for a system built with AI tools?
It makes the rules testable in a form people can read. A rule is written as given these events, when this command, then these events. A domain expert can confirm a scenario before code exists, and the same scenario runs as a test on every change. Event sourcing also keeps the full history of what happened, which a design that overwrites table rows throws away.
Do you train our developers to use Claude Code and Codex?
Yes. Your developers join the workshops, receive the scenarios, prompts, tool configuration and review checklists in your repository, and pair with me on further work until they can extend the system with the same tools and checks.
What does AI-assisted modernization cost?
Work is scoped and quoted per bounded context, so the first commitment is one delivered piece of the system. The first conversation is a free 1-hour consultation. If the legacy system needs an inventory first, the next step is a fixed-scope assessment whose fee is creditable toward the project.
Sources
- EventStorming, Alberto Brandolini: Origin and notation of the workshop format
- Event Sourcing pattern, Azure Architecture Center: Events as the record of what happened, with replay and audit
- Legacy System Modernization with Coding Agents: A Case Study (Alves, Politowski and Montandon, 2026): Claude Code migrated 12 features of a VB6 ERP system to C# .NET 10 in a single pass: 70% average equivalence, 92% for low-complexity and 47% for high-complexity features
- Claude Code data usage, Anthropic: How Claude Code handles the code it processes
- Data controls in the OpenAI platform: How OpenAI handles data sent through its API
- xAI documentation: The Grok models and API
Not sure where to start?
Start with a fixed-scope Legacy Software Assessment: a read-only review of your application’s source, database, configuration, logs, and architecture, ending in findings with evidence and a written recommendation. Quoted after the free 1-hour consultation; creditable toward a subsequent modernization project.