8 Ways @ttsc/lint Transforms TypeScript Linting into a Single, Blazing-Fast Step

Every TypeScript developer knows the drill: run tsc --noEmit to check types, then eslint to enforce code style. Two tools, two parse passes, and a lot of waiting. What if you could merge both checks into one compile, running at 20x speed? That's exactly what @ttsc/lint does—by building linting directly into the next-generation TypeScript compiler written in Go. Here are eight essential facts about how it works, why it's faster, and how you can start using it today.

1. TypeScript's Traditional Two-Step Workflow Is Inefficient

Before we look at the solution, let's examine the problem. In a typical TypeScript project, continuous integration runs tsc --noEmit for type checking and then eslint for style rules. Both tools parse your source code into an Abstract Syntax Tree (AST). That means your source is read twice and parsed twice—a redundant, time-consuming process. The compiler sees only type errors; the linter sees only style violations. If either fails, the build stops. This duplication wastes CPU cycles, especially in large codebases with hundreds of files. The frustration is real: why can't one tool do both jobs?

2. @ttsc/lint Collapses Two Steps into One Compile Pass

@ttsc/lint changes the game by integrating lint rules directly into the TypeScript compiler. When you run ttsc (the TypeScript wrapper provided by the package), it performs type checking and linting in a single pass. Lint violations are reported using the exact same error format as type errors—complete with error codes like TS17397. For example, a prefer-constTS17397: [prefer-const] Use const instead of let. This means your existing CI pipelines that check for tsc errors will automatically catch lint failures too, without any extra configuration. It's one tool, one output, one failure code.

3. Built on typescript-go—10x Faster Than Legacy tsc

The secret sauce behind @ttsc/lint's speed is its foundation: typescript-go, a from-scratch rewrite of the TypeScript compiler in Go. This new compiler is already about 10 times faster than the original JavaScript-based tsc. By building lint on top of this high-performance engine, @ttsc/lint doesn't just merge two steps—it also runs each step faster. The Go runtime's efficiency, combined with optimized memory management, means less waiting for developers and faster feedback in CI.

4. It Reuses the AST—No Extra Parsing Cost

When @ttsc/lint performs linting, it does not re-parse your source code. Instead, it reuses the AST already built by the compiler during type checking. The compiler constructs an AST for every file—that's necessary for type analysis. @ttsc/lint walks that same AST to apply lint rules, adding negligible overhead. This is the core reason for the speed gain: one parse provides data for both checks. Traditional setups parse once for type checking and again for linting, doubling the I/O and CPU work. With @ttsc/lint, that overhead disappears.

5. The Combined Effect: Up to 20x Faster in Theory

Individually, typescript-go offers ~10x speed improvement over legacy tsc. By combining two steps into one, you effectively eliminate the second parse, which often takes 40–60% of the total time in a two-step pipeline. The net result is a theoretical speedup of about 20x. In practice, real-world projects have reported dramatic reductions in CI lint+type-check times—from minutes to seconds. While exact gains depend on project size and complexity, the trend is clear: merging and optimizing can cut build times by an order of magnitude.

6. Compatible with TypeScript v6—Drop In and Go

@ttsc/lint is designed to work with TypeScript v6 (the version that uses typescript-go). You do not need to migrate your entire toolchain. Simply install the package and replace tsc commands with ttsc or use ttsx --noEmit. The tool acts as a drop-in replacement that adds lint capabilities without breaking existing code. No changes to your tsconfig.json or ESLint configuration are required—just run the new command. This makes adoption frictionless, even in large, established projects.

7. Lint Violations Are Treated as Compiler Errors—Same Exit Code

One of the most elegant aspects of @ttsc/lint is that lint violations look exactly like type errors to the compiler. They use the same error code format (TSxxxxx) and produce the same non-zero exit code. This means you can configure your CI to simply run ttsc --noEmit and let it report everything. No separate ESLint step, no custom exit code handling. Furthermore, each lint rule can be set to severity error, warning, or off. Warnings are reported but do not affect the exit code, enabling a gradual rollout strategy—you can start with warnings and later elevate them to errors.

8. Getting Started: Simple Installation and Example

To try @ttsc/lint, visit the GitHub repository and follow the instructions. After installing, run ttsc on a file with both type and lint issues. For instance, the code below has three problems:

var x: number = 3;
let y: number = 4;
const z: string = 5;
console.log(x + y + z);

Running ttsc will output three errors together: a type error (assigning number to string) and two lint violations (no-var and prefer-const). All appear in the same compiler output, saving you time and confusion. The journey to faster, unified linting starts with a single command.

Conclusion

@ttsc/lint represents a significant leap forward for TypeScript tooling. By merging type checking and linting into a single compile pass, built on a 10x faster compiler, it eliminates redundant parsing and cuts build times by up to 20x. The seamless integration—lint errors as standard compile errors, no migration required, gradual rollout with warning levels—makes it a practical choice for any TypeScript project. The days of separate tsc and eslint runs may soon be a thing of the past. Try it today and feel the difference.