# Making My Website Build Faster with Oxlint, TypeScript 7, and One Test Fixture

Created: 2026-11-17

6 min read

Next.js

Vercel

TypeScript

Oxlint

Vitest

Tooling

Meta

## Table of Contents

* [September: Oxlint and TypeScript 7](#september-oxlint-and-typescript-7)
* [Moving the lint rules to native Oxlint](#moving-the-lint-rules-to-native-oxlint)
* [Why that also unlocked TypeScript 7](#why-that-also-unlocked-typescript-7)
* [November: the fixture I had left behind](#november-the-fixture-i-had-left-behind)

Earlier this year, I wrote about [making this website's build 40% faster](/blog/making-my-websites-build-40-percent-faster-without-touching-the-code). Most of those improvements came from newer framework and runtime versions and a faster build machine. I also spent some of the gains on things I wanted the website to do, like generating more content at build time.

I have continued adding to the site since then. Recently, I opened the deployment dashboard again after leaving it alone for a while, and noticed another clear drop in build times. It was sitting halfway through a period labelled “Next.js 16.2.0.”

The label was out of date. The website had moved on to Next.js 16.3 and 16.4, but I had not added the newer milestones. Matching the deployment history to the commits pointed to two changes: the Oxlint and TypeScript 7 migration on September 29, and a Vitest fixture cleanup on November 13.

Around those boundaries, the average went from roughly 84 to 51 seconds, then from 43 to 35 seconds. This time, the interesting part was what the tools and tests were doing with the hardware I already had.

Here is how those changes fit into the build history. The timings run from build start until the deployment is ready, including checkout and deployment overhead.

![Dashboard overview of 469 successful deployments from July 3 to November 17, showing the Next.js 16.2 milestone group, stable 16.3, Oxlint and TypeScript 7, Next.js 16.4.2, and the Vitest fixture cleanup](/_next/image?url=%2F_next%2Fstatic%2Fimmutable%2Fmedia%2Fbuild-time-overview-16-2-to-16-4.0oag4s685npsx.png&w=3840&q=75)

469 successful deployments from July to November 2026\. Each bar is one build, including the slower runs.

The website moved to stable 16.3 on August 4 and adopted 16.4.2 on October 21\. The September tooling change happened while the site was on 16.3\. The fixture cleanup came after the move to 16.4\. The framework labels mark stable production upgrades; prerelease versions and development previews can differ from the group's label.

## [September: Oxlint and TypeScript 7](#september-oxlint-and-typescript-7)

The first change was replacing ESLint, `eslint-config-next`, and `typescript-eslint` with [Oxlint](https://oxc.rs/docs/guide/usage/linter), then upgrading to TypeScript 7.0.2.

![Dashboard bar chart of 60 successful deployments around September 29, with the first 30 averaging about 84 seconds and the following 30 averaging about 51 seconds](/_next/image?url=%2F_next%2Fstatic%2Fimmutable%2Fmedia%2Foxlint-typescript-7-build-times.3609rsbj45zne.png&w=3840&q=75)

30 deployments before and 30 after the September 29 migration to Oxlint and TypeScript 7.

Across that window, the mean fell from **84.45 to 50.96 seconds**, about **40%**. The median also fell, from 84.55 to 52.65 seconds.

These are consecutive historical deployments, including previews. Some migration previews already contained the changes before the production merge. The window shows the transition, with the normal variation in source revisions and cache state, rather than isolating either tool's contribution.

### [Moving the lint rules to native Oxlint](#moving-the-lint-rules-to-native-oxlint)

Oxlint is part of [Oxc, a toolchain written in Rust](https://oxc.rs/docs/guide/what-is-oxc.html). For this migration, the useful change was running the selected lint rules natively and removing the JavaScript plugin dependencies they replaced.

I did that in stages. The first Oxlint configuration still used JavaScript compatibility plugins for React, Hooks, and Next.js. That let me change the runner while checking the existing policy. I then replaced those plugins with native rules and removed the ESLint packages.

I reviewed the rules individually and documented the differences. The final policy has 29 executable test cases: small valid and invalid programs that run through the real linter. Warnings still fail CI through `oxlint --deny-warnings`.

That matters to me. A faster lint command is useful when I can still explain what it checks.

### [Why that also unlocked TypeScript 7](#why-that-also-unlocked-typescript-7)

[TypeScript 7 moved the compiler to Go](https://devblogs.microsoft.com/typescript/announcing-typescript-7-0/). It runs as native code and can do work such as parsing and type checking in parallel. That gives the compiler more ways to use a machine with several CPU cores.

There was a compatibility issue in my old setup: the installed `typescript-eslint` depended on TypeScript's JavaScript compiler API. TypeScript 7.0 did not ship that API. Microsoft documented a way to retain TypeScript 6 alongside 7 for tools that needed it, but moving this site's lint policy to native Oxlint rules removed that dependency.

I could use TypeScript 7 directly and keep `tsc --noEmit` as a separate check. Next.js used the project-local compiler CLI for its own TypeScript stage. The type checks stayed in the build.

The historical logs make the improvement more concrete. A cached production build before the migration and the first migrated production build both used a 30-core, 60 GB Turbo build machine:

| Measurement from the build logs    | September 28 | September 29 |
| ---------------------------------- | ------------ | ------------ |
| Lint command to the next stage     | 10.38s       | 0.23s        |
| Next.js TypeScript stage           | 10.7s        | 1.385s       |
| Next.js compilation                | 9.4s         | 16.7s        |
| Build start until deployment ready | 73.761s      | 56.422s      |

Lint and type checking became much cheaper in those runs. Compilation took longer. The same PR also updated Next.js from 16.3.6 to 16.3.7, pnpm, Vitest, and other dependencies, so I cannot assign the entire improvement to Oxlint or TypeScript individually.

## [November: the fixture I had left behind](#november-the-fixture-i-had-left-behind)

The second change was connected to the first one in a slightly annoying way. I had removed the JavaScript compatibility plugins, but one of their setup requirements was still in the tests.

The lint-policy suite creates a temporary project containing its small example programs and the lint configuration. During the first migration stage, that project needed a symlink to the repository's `node_modules` directory so the compatibility plugins could resolve their packages.

Once the rules were native, the fixture only needed its source files, configuration, and the Oxlint executable. The test already invoked the executable through an absolute path. The dependency link had become unnecessary, but I had left it there.

This was the line I removed:

TypeScript

Copy

```ts
symlinkSync(resolve('node_modules'), join(directory, 'node_modules'), process.platform === 'win32' ? 'junction' : 'dir');
```

That link made dependency discovery expensive inside a fixture intended to test a few small programs. In two Vercel previews, removing it reduced the lint-policy suite's reported time from **9.753 to 0.159 seconds**. All 29 policy cases still ran.

I have [written up the test changes in more detail](/blog/faster-vitest-tests-and-smaller-google-imports). The deployment history now gives that work its own milestone too:

![Dashboard bar chart of 40 successful deployments around the November 13 test changes, with the first 20 averaging about 43 seconds and the following 20 averaging about 35 seconds](/_next/image?url=%2F_next%2Fstatic%2Fimmutable%2Fmedia%2Fvitest-fixture-build-times.3i2sh3vc3t1_m.png&w=3840&q=75)

20 deployments before and 20 after the November 13 test changes.

The mean across those windows fell from **43.37 to 34.74 seconds**, about **20%**. The November change also tuned Vitest and moved an initial Telegram module import into test collection, so the graph covers the combined change.

The order of the work affected the worker setting I chose. With the old fixture, eight Vitest workers beat sixteen in the first comparison. After removing the dependency link, sixteen became faster on the Vercel machine. That is what I kept. Per-file isolation stayed enabled because disabling it caused existing tests to fail.

In the separate production comparison from the test post, the full unit stage went from 12.14 to 4.01 seconds for the same 1,407 tests across 154 files. Time from build start until the deployment was ready went from 37.9 to 30.3 seconds. Those are two individual cached runs; they are a different comparison from the 20-build windows above.

The build still runs lint, all unit tests, and TypeScript checks on the same machine. The September migration had already made that fixture symlink unnecessary. It took me another six weeks to remove it.