Hidden dependency coupling
In large or multi-repo codebases, modules depend on implicit state and undocumented side effects. Changing a low-level utility can trigger cascading failures across unrelated services.
Pre-launch • Founded September 2026
Modernize legacy codebases without breaking existing behavior.
CodeLoom AI maps repository dependencies, generates characterization tests to lock in current behavior, and migrates legacy code incrementally through small, test-verified pull requests.
Illustrative example — Automated dependency mapping & verification wave
CodeLoom AI is an automated codebase modernization system that migrates legacy software—outdated frameworks, deprecated runtimes, and tangled architectures—to modern architectures while preserving existing behavior. Founded in September 2026 by Vasil Vasilev and currently in pre-launch development, CodeLoom AI is built around a simple engineering rule: behavior preservation comes first. Every code change is verified against characterization tests generated and run against the original codebase before any source file is modified.
01
Map full-repo dependency graphs
02
Lock existing behavior with tests
03
Modernize in audit-ready PRs
Vasil Vasilev
Founder & Lead Systems ArchitectSoftware engineer focused on static program analysis, deterministic verification harnesses, and automated legacy codebase migration.
The Problem
Why legacy migrations stall or introduce regressions
Enterprises spend heavily maintaining brittle, poorly documented legacy software. Manual refactoring takes months and diverts senior engineers from product work.
Undocumented edge-case behavior
Legacy systems encode years of bug fixes and business rules that exist only in production code. Rewriting code without baseline characterization tests silently drops critical behavior.
Unreviewable migration branches
Long-running migration branches accumulate thousands of changed lines and drift from main. Reviewers cannot meaningfully audit massive diffs, delaying merges or letting regressions slip in.
How It Works
Three stages from legacy repository to verified pull request
Watch how CodeLoom AI processes a codebase: mapping structural dependencies first, locking in behavior with characterization tests second, and modernizing incrementally third.
STAGE 01
Map the repository
CodeLoom AI ingests whole codebases—including multi-repo setups—and builds a structural dependency graph from imports, call sites, and shared types. It identifies leaf modules with zero downstream dependents first, ordering the migration plan so the impact of every change is known upfront.
- Parses cross-file and cross-repository dependency edges
- Ranks leaf nodes first for safe, bottom-up migration ordering
- Calculates blast radius before scheduling any transformation
STAGE 02
Lock in current behavior
Before touching a single line of legacy code, CodeLoom AI generates characterization tests (unit and integration) that capture what the code actually does today—including edge cases and error handling—and runs them against the original implementation.
- Generates unit and integration tests from existing execution paths
- Runs test suite against unmodified legacy source to establish baseline
- Freezes behavioral contract prior to any code modification
STAGE 03
Modernize incrementally & repair
AI agents rewrite modules toward the target stack and run the locked characterization tests against every change. If a test fails, the agent inspects the failure, repairs the code, and re-verifies before opening a small, audit-ready pull request that explains what changed, why, and what verified it.
- Transforms legacy syntax and patterns to the target architecture
- Executes automated verify-and-repair loop when a test flags a mismatch
- Produces small, human-reviewable pull requests with verification logs
Why It's Safe
Every change passes a deterministic verification gate
CodeLoom AI never merges unverified code or relies on probabilistic guesses. Behavior is verified against tests written before any code is modified, and humans stay in control of every merge.
Illustrative example — Automated verification gate & repair loop
01
Tests come before changes
Characterization tests are generated and verified against the original legacy code first. No migration diff is evaluated without a pre-existing baseline suite.
02
Every pull request is auditable
Changes are scoped to individual modules rather than sprawling rewrites. Each pull request documents what changed, why the transformation was made, and which tests verified it.
03
Humans review the output
CodeLoom AI produces standard pull requests for your engineering team to inspect, comment on, and approve using your existing code review workflow.
Use Cases
Designed for structural modernization work
CodeLoom AI targets high-effort, repetitive engineering migrations where preserving existing runtime behavior is critical.
Frameworks
Legacy lifecycle → Verified modern module
Framework upgrades
Migrate applications off outdated UI or backend frameworks and deprecated component lifecycles to modern framework versions while keeping route, state, and API contracts intact.
Runtimes & Languages
Deprecated runtime API → Target runtime spec
Runtime migrations
Transition services across major language versions, module systems, or deprecated runtime APIs—replacing legacy async patterns and obsolete standard library calls with tested modern equivalents.
Architecture
Tangled shared state → Isolated domain boundary
Monolith cleanup
Untangle circular dependencies, extract tightly coupled domain modules behind clean interfaces, and standardize internal package boundaries incrementally.
FAQ
Frequently asked questions
Is CodeLoom AI live?
No. CodeLoom AI was founded in September 2026 and is currently in pre-launch development.
When will CodeLoom AI launch?
To be announced. We are focused on building and validating our core mapping, characterization testing, and incremental migration pipeline.
What languages and frameworks will it support?
To be announced. Specific language, framework, and runtime targets will be shared as we approach launch.
How are changes verified?
Before modifying any legacy code, CodeLoom AI generates unit and integration characterization tests and runs them against the original codebase to capture its current behavior. Every subsequent migration change is run against those tests. If a test fails, the system repairs the change and re-runs the suite until the tests pass before generating a pull request.
Who reviews the output?
Your engineering team reviews every change. CodeLoom AI produces small, self-contained pull requests that explain what changed, why it changed, and which characterization tests verified the behavior, so human engineers can audit and approve them before merge.
What does "behavior preservation" mean?
Behavior preservation means the modernized code produces the same observable outputs, side effects, and error handling as the original legacy code for the inputs covered by its characterization test suite. Instead of rewriting features from scratch, CodeLoom AI locks in what the software does today and verifies refactored code against that baseline.
Where is the product hosted and how is codebase data handled?
To be announced. Hosting models, deployment options, and data handling specifications will be documented prior to launch.
Behavior-First Modernization
Map the graph. Lock the behavior. Modernize one verified pull request at a time.
Explore the interactive sandbox demo or inspect the verification architecture to see how CodeLoom AI orders dependencies, generates characterization tests, and verifies incremental changes.