Protecting a Growing TypeScript Codebase with Test Code Generation

ExpressoTS is a popular open-source Node.js and TypeScript framework for building scalable server-side applications. It is actively maintained by a small core team alongside a growing open-source community, and is widely used in real production systems.
For open-source projects at this level of adoption, testing is more than an internal engineering concern. Strong test coverage is often treated as a signal of trust, indicating that a project is well-maintained, safe to adopt, and reliable in production.
As ExpressoTS grew into a larger and more complex codebase, maintaining that trust became increasingly critical.

As the codebase expanded, testing didn’t scale at the same pace.
Some areas were well covered, while others became risky to change, not because they were especially complex, but because it wasn’t clear what might break. Coverage metrics existed, but they didn’t clearly reflect where real risk lived.
The maintainers experimented with general-purpose AI tools to generate tests. While the results were usable, the process quickly became a bottleneck. Each test required manual context sharing, adjustment, and review. Improving coverage across the repository would have required weeks of repetitive work.
Testing was possible, but it wasn’t sustainable.
What ExpressoTS needed wasn’t faster test writing. They needed a way to systematically raise the safety level of an existing codebase, protecting core logic without slowing development.

Early was introduced as an IDE-native AI agent for unit test generation.
Instead of generating tests function by function through manual prompts, Early derived its understanding directly from the codebase. Once installed, it automatically worked with ExpressoTS’s existing Jest setup and generated executable unit tests without requiring developers to provide additional context.
Testing shifted from a manual, incremental task to a repository-level process, where dependencies, configuration, and behavior were understood in context.
Today, Early also runs autonomously in CI environments such as GitHub Actions, continuously generating and validating tests at pull-request or full-repository level as the codebase evolves.

Within a few hours, Early generated hundreds of unit tests across the ExpressoTS codebase.
The results were immediately actionable. Failed tests surfaced missing validations, unhandled edge cases, and assumptions that had never been explicitly enforced.
Testing became a discovery process, revealing how the system actually behaved, not just confirming what was already assumed to work.

Using Early, ExpressoTS increased coverage across an existing repository, uncovered real bugs, and strengthened protection around core logic, without slowing development or overwhelming maintainers.
This pattern extends beyond ExpressoTS. Many growing codebases, including teams adopting AI-generated code at enterprise scale, see coverage improve while confidence lags behind. ExpressoTS shows what changes when testing is treated as a protection layer.
That’s when teams stop being afraid to change their code, and start trusting it again.

‍