TypeScript 7.0 Is Here and It's Built in Go — Your MERN Stack Migration Guide

---

TypeScript 7.0 shipped in July 2026, and the headline is simple: it's the Go rewrite the team promised, and the speed numbers are wild. We're talking Slack cutting their CI type-checking time from 7.5 minutes down to 1.25 minutes. VS Code's build got 11.9x faster. This isn't incremental — it's a different tool now. If you're still on TypeScript 6 and wondering whether it's worth the upgrade, let's walk through what actually changed, what breaks, and what your Node.js and React code needs to look like on the other side.

---

What TypeScript 7.0 Actually Is

The entire TypeScript compiler has been rewritten in Go. Same type system, same behavior, completely different runtime. Microsoft ported the codebase as a direct translation — "maintaining the structure and logic of the original" — so your TypeScript code doesn't change. What changes is how fast it gets checked.

The new binary is tsgo. During migration you can keep calling tsc through the compatibility shim that ships with TS7, but under the hood you're now running a native binary instead of a Node.js process. That's where the speed comes from — Go's real threads, compiled to native code, no V8 warm-up overhead.

Real-world build time improvements:

Project	Before (TS6)	After (TS7)	Speedup
VS Code	~47s	~4s	11.9x
Sentry	~32s	~3.6s	8.9x
Playwright	~24s	~2.8s	8.7x
Slack (CI full check)	7.5 min	1.25 min	6x

Memory usage is also down 6–26% depending on the project. Editor responsiveness is noticeably different — opening a file with errors in VS Code dropped from 17.5 seconds to 1.3 seconds.

The new parallelism flags are --checkers (type-checking workers, defaults to 4) and --builders (for project references). You don't have to configure these to get the speedup — they kick in automatically.

---

What Breaks Going from TS6 to TS7

The compiler is faster, but it also finished cleaning house. A few things that worked in TypeScript 6 simply don't exist anymore.

1. assert Keyword for Imports Is Gone

This was deprecated back in TypeScript 5.3. TS7 removes it entirely. If you're loading JSON config files or schemas in your Express app with the old syntax, update it:

// TS6 — this throws in TS7
import schema from './validators/user.schema.json' assert { type: 'json' };

// TS7 — correct syntax
import schema from './validators/user.schema.json' with { type: 'json' };

2. Three tsconfig Options Are Removed

If any of these are in your compilerOptions, remove them or you'll get an error on startup:

• importsNotUsedAsValues → replace with verbatimModuleSyntax

• preserveValueImports → same, replace with verbatimModuleSyntax

• noImplicitUseStrict → just remove it, modules are strict by default now

{
  "compilerOptions": {
    // Remove these:
    // "importsNotUsedAsValues": "error",
    // "preserveValueImports": true,
    // "noImplicitUseStrict": false,
    
    // Add this if you were using either of the first two:
    "verbatimModuleSyntax": true
  }
}

verbatimModuleSyntax is the cleaner replacement — it enforces that type-only imports use import type, which is better for tree-shaking and bundler compatibility anyway.

3. this Aliasing and Prototype Reassignment Patterns Break

These are less common in modern MERN codebases but worth a scan. If you have older code that captures this into a variable (the pre-arrow-function pattern) or reassigns MyClass.prototype, the type inference for those patterns is removed. Arrow functions fix the this issue in basically every case.

4. Node.js Without a Build Step: Add erasableSyntaxOnly

If you're running TypeScript directly on Node (via --experimental-strip-types or a similar loader) — which is increasingly common for Express apps and scripts — Node 24.12+, 25.2+, and 26 removed the flags that allowed TypeScript enums and namespaces to run. Add this to your tsconfig:

{
  "compilerOptions": {
    "erasableSyntaxOnly": true
  }
}

This makes your editor surface the issue at edit time rather than at runtime. Enums get replaced with const objects, namespaces get converted to regular modules.

---

A TypeScript 7.0 tsconfig.json for Express/Node.js

Here's a clean config that works with TS7 and a Node.js backend, with no deprecated options:

{
  "compilerOptions": {
    "target": "es2022",
    "module": "commonjs",
    "moduleResolution": "node16",
    "strict": true,
    "types": ["node"],
    "verbatimModuleSyntax": true,
    "erasableSyntaxOnly": true,
    "outDir": "./dist",
    "rootDir": "./src",
    "esModuleInterop": true,
    "skipLibCheck": true
  },
  "include": ["src/**/*"]
}

And for the React side (Vite):

{
  "compilerOptions": {
    "target": "es2022",
    "module": "esnext",
    "moduleResolution": "bundler",
    "strict": true,
    "jsx": "react-jsx",
    "types": ["vite/client"],
    "verbatimModuleSyntax": true
  },
  "include": ["src/**/*"]
}

The key changes from TS6 configs: verbatimModuleSyntax is in, the three removed options are gone, and erasableSyntaxOnly is added on the Node side.

---

One Catch: Embedded Frameworks Aren't Ready Yet

Here's the important asterisk. If your project uses Vue, Svelte, Astro, MDX, or Angular — frameworks that embed TypeScript inside their own compilers — you can't fully switch to TS7 yet. Those tools still rely on TypeScript's programmatic API, which doesn't exist in 7.0. It's coming in TypeScript 7.1, but for now those frameworks are pinned to TS6.

The practical move if you're in a mixed codebase: keep TS6 for the framework part, and you can still use tsgo for standalone TypeScript files and pure Node.js services. Install both via npm aliases:

npm install --save-dev typescript@6 tsgo@7

Then let your bundler use TS6's API while tsgo handles direct compilation of backend code.

If you're on a straight MERN stack with no Vue/Svelte/Astro in the mix, you're clear to upgrade everything now.

---

Your TS6 → TS7 Migration Checklist

• [ ] Update: npm install typescript@latest (gets you TS7)

• [ ] Replace assert { type: '...' } → with { type: '...' } across imports

• [ ] Remove from tsconfig: importsNotUsedAsValues, preserveValueImports, noImplicitUseStrict

• [ ] Add "verbatimModuleSyntax": true if you were relying on either of the first two

• [ ] Add "erasableSyntaxOnly": true to Node.js tsconfigs if running without a build step

• [ ] Audit this aliasing patterns and prototype reassignments

• [ ] Run npx tsgo --noEmit and work through any remaining errors

• [ ] Check your framework: Vue/Svelte/Astro users, wait for 7.1

---

It's Worth It

The migration work here is real but finite. A few config lines, a regex-replace on import syntax, and one afternoon of fixing strict mode errors you were ignoring. The payoff is a compiler that feels genuinely fast — for the first time since TypeScript projects started getting large, type-checking stops being the slow part of your feedback loop.

For MERN devs who've been watching Go from the sidelines: the tool you use every day is now built on it. And if you've been curious about picking it up yourself, the fact that Microsoft bet TypeScript's next decade on Go's performance model is a decent signal about where the ecosystem is moving for backend compute.

Worth the upgrade? Yeah, I think so. Run the checklist and let me know in the comments what tripped you up.