What do you do with 1.5 million lines of 25-year-old code nobody can maintain?
You start over. And ship it in months.
A leading embedded RTOS vendor was losing developers to its own IDE. We replaced it with a VS Code extension their engineers actually wanted to open.
reverse-engineered
release candidate
dependencies left
The ROI equation just flipped.
Nobody chose this platform; they inherited it. For twenty-five years, replatforming it meant taking on more pain than the debt itself, so the debt won every time it came up for discussion.
Modern architecture and AI-native delivery turn brownfield into modified greenfield: rebuilding the platform nobody wanted to inherit faster, cheaper, and with less disruption than living with it. We cleared it in under nine months.
The Challenge
1.5 million lines across 10,000 files, three legacy languages, and twenty-five years of institutional knowledge living in a handful of heads.
A leading embedded operating system company needed a modern VS Code extension for their flagship real-time operating system, a platform running in aerospace, defense, automotive, and industrial systems. It had to deliver the full embedded development lifecycle (project creation, import, configuration, build, deploy, debug) while integrating deeply with 25+ years of proprietary tooling, undocumented protocols, and complex build systems.
This wasn't a UI reskin. It required reverse-engineering a legacy codebase of 1.5 million lines across 10,000+ files in Java, Python, and TCL, implementing a custom binary protocol from scratch in TypeScript, and replacing Java/TCL build orchestration. A prior internal effort had attempted this work and failed to properly complete it, and stakeholders who knew the legacy system were skeptical it could be delivered on the proposed timeline, let alone by a small team.
It's a familiar problem across large technical organizations: valuable legacy systems that have become too expensive and complex to evolve at the pace the business demands. This project shows how the right engineering expertise, paired with the latest tooling, finally makes the impossible routine.
All three kinds of debt were in play. Technical debt: undocumented protocols and build orchestration no one wanted to touch. Product debt: a modern developer experience promised for years and never delivered. Organizational debt: twenty-five years of institutional knowledge scattered across decompiled source, training decks, and the memories of a handful of engineers.
The Team
The project was delivered by a small, senior team of fractional and full-time members, equivalent to roughly 2.5–3 FTEs, spanning engineering, architecture, UX, and product leadership. The team was bolstered by AI tooling embedded into daily workflows and by client domain experts serving in an advisory capacity.
The Approach
AI as a core team member, not just a code assistant.
We used company-approved secure AI tooling across the entire product lifecycle: not just to write code, but to understand the legacy system, design the architecture, enforce quality, and capture the team's evolving knowledge as deeply technical conversations, investigations, and design decisions unfolded in real time.
Discovery & Planning
AI compressed weeks of reverse-engineering into days: processing customer training materials, analyzing decompiled source, and extracting a structured feature inventory that became the foundation for prioritization. A spec-driven workflow (requirements → design → tasks) kept the team building the right things in the right order.
Development
A Clean Architecture refactoring separated business logic into a reusable SDK, powering the VS Code extension, a CLI tool, and an AI-powered MCP server from one codebase. We encoded the architecture rules and let the pipeline enforce them, and we built a native TypeScript protocol client from scratch, eliminating an entire dependency layer, with 2,000+ automated tests generated and maintained with AI assistance.
Knowledge Capture & Transparency
As technical investigations unfolded, AI captured and organized the team's evolving understanding into structured, searchable records, and synthesized status updates from standups, syncs, and repository metrics, keeping leadership informed without pulling developers out of flow. Communication overhead dropped measurably, while accuracy and timeliness exceeded what's typical at this complexity.
DevOps & Quality
Backlog management and CI/CD pipelines automated the full quality chain (lint, type-check, test, build, package, and publish) on every merge request. Releases ran fully automated, with high pipeline reliability and full changelog visibility, and no manual overhead in between.
The Product
Working software covering the entire embedded lifecycle inside a modern IDE. Engineers create and configure a project across a 300-plus layer build surface, compile against the target toolchain, launch on hardware or a QEMU simulator, then debug and profile a running system, all driven by the native TypeScript protocol client the team built from scratch, with no Java, JRE, or Python bridge underneath. A few of the surfaces engineers work in every day:
The Results
The project kicked off in January 2026. By July, the full embedded development lifecycle was functional: project creation, configuration, build, deploy, and debug across all project types. Client stakeholders confirmed it had graduated from proof-of-concept to full product release candidate, targeting release later in 2026: under nine months, start to finish.
The team solved problems prior internal efforts could not: building a native TypeScript protocol client that eliminated an entire Python dependency layer, and porting Java/TCL build logic without requiring a JRE. The resulting architecture is more flexible and extensible than the system it replaces, despite being built by a fraction of the headcount.
to finish
MCP tools
AI-maintained
extension, CLI & MCP
Because the team's AI-driven workflows maintained documentation and coding standards from day one, the codebase, pipelines, and all product and technical documentation remain up-to-date and accurate for future resources to adopt.
“I wish all my projects had Crux on them. I know you've got it and you make it so easy for me. We've done in a few months what everyone else said would take two to three years and fifteen engineers.”
Why This Matters
The key isn't that AI writes code faster. It's that a team with deep engineering discipline, and awareness of what AI can and can't do well, operates fundamentally differently.
This project demonstrates a working model: a small, senior, AI-augmented team delivering complex enterprise software on an aggressive timeline, while maintaining architectural quality, comprehensive test coverage, and full stakeholder transparency. Encoding institutional knowledge, capturing evolving understanding of complex systems, enforcing standards automatically, and scaling deliberately means 2–3 senior engineers can deliver what traditionally requires a much larger organization, beating aggressive timelines instead of merely meeting them.
Most organizations use AI to live with their debt.
We use AI to remove the constraint entirely.
That is the whole difference. Organizations don't have to choose between maintaining legacy systems they've outgrown and the risk of starting over from scratch. This approach extracts the value accumulated over decades and delivers it in a modern, extensible form, at a fraction of the cost and timeline. Because the business hasn't changed. What's possible has.
This is the kind of work we do.
Tell us which platform is holding you back. We will tell you what it takes to clear the route.