TypeScript 7’s new Go-based compiler, tsgo, is already breaking popular development tools such as ESLint, ts-jest and ts-morph. The breakage will continue until the compiler’s programmatic API stabilises in the upcoming 7.1 release, meaning teams that rely on these tools should pause any upgrade plans.

What changed in TypeScript 7

The release introduced tsgo, a Go port of the type-checker that the TypeScript team codenamed Project Corsa. By moving the core from JavaScript to Go the compiler can deliver builds up to ten times faster, a headline that attracted early adopters looking to shave minutes off CI pipelines.

Why the tools are failing

Tools that work with TypeScript do not talk to the type-checker directly. They call a set of internal APIs that expose type information, diagnostics and AST traversal. Those APIs were rewritten for tsgo and remain in flux until version 7.1. The result is a cascade of crashes and silent failures:

  • typescript-eslint – npm refuses to install it alongside TypeScript 7; forcing the install makes ESLint throw a TypeError.
  • ts-jest – attempts to call internal methods that no longer exist in the Go version, causing test-file transformation to abort.
  • ts-morph – expects the stable API to walk the code structure; with the current API it may return wrong results or fail without warning.
  • Monorepos – tsgo drops certain generic type parameters, leading to type errors that only appear in large, multi-package projects.

Any workflow that mixes linting, Jest testing or code-analysis with TypeScript 7 will likely see red builds.

Who is affected

  • Front-end teams that run ESLint as part of every pull request.
  • Back-end services that rely on ts-jest for unit testing.
  • Libraries that use ts-morph for code generation or documentation.
  • Organizations with monorepo setups where type inference is already complex.

If your CI pipeline turned red after a TypeScript upgrade, the culprit is probably one of the above.

A safe migration path until 7.1

The simplest way to keep the speed gains without breaking tools is to decouple the fast type-checking step from the actual build:

  1. Pin the main TypeScript version to 6.x – this keeps the stable API that all tools expect.
  2. Add @typescript/native-preview as a dev dependency – the package ships the tsgo binary for quick type-checking in CI.
  3. Run tsgo with --noEmit for fast checks – it validates types but does not produce output files.
  4. Use the classic tsc compiler for real builds – tsc still produces JavaScript and respects the 6.x API.
npm install -D typescript@^6.9
npm install -D @typescript/native-preview

Update your package.json scripts:

{
  "scripts": {
    "typecheck:fast": "tsgo --noEmit",
    "build": "tsc"
  }
}

With this dual setup you retain the ten-fold speed boost in CI while preserving compatibility with ESLint, ts-jest and ts-morph.

When you can upgrade straight to 7.0

If your codebase only ever invokes tsc—no linting, no Jest, no ts-morph—then the unstable API does not affect you. In that narrow scenario you can move to TypeScript 7 immediately and enjoy the performance uplift without additional steps.

What to watch for

  • Version 7.1 – the TypeScript team has signaled that the programmatic API will be frozen in this release. Once it lands, the bridge between tsgo and existing tooling will disappear, allowing a clean upgrade.
  • Tooling updates – keep an eye on new releases of typescript-eslint, ts-jest and ts-morph. They will publish compatible versions shortly after 7.1 ships.
  • CI configuration – remember to replace tsgo --noEmit with a regular tsc call once the API stabilises; the preview package will no longer be needed.

Takeaway: Until the 7.1 API lock-in, stay on TypeScript 6.x for your main compiler, add @typescript/native-preview for fast checks, and keep using tsc for builds. This avoids broken linting and testing while still reaping the performance benefits of the new Go engine.