Why deleting 11,000 tests sped one AI team up, and keeping 13,000 let another port TypeScript in 3 weeks

Two videos this week give opposite verdicts on large test suites in AI repos. The difference is whether a test locks in old internals or checks outside outputs.

Close-up of an architectural blueprint and technical drawing being measured with metal calipers and a ruler on a desk.
Photo: Unsplash

If you watched two of the biggest engineering videos on YouTube this week, you heard two stories about tests and AI agents that sound like they cannot both be true.

On 5 November, Better Stack (135,688 views) benchmarked tsrs, a new Rust port of the TypeScript compiler. Microsoft spent nearly two years porting TypeScript from JavaScript to Go. One engineer directing a team of Claude Opus 5.5 agents ported Microsoft’s Go compiler into Rust in three weeks, across 793 files and 380,000 lines of code. On a broken core type that triggers 26,054 cascading errors, JavaScript took 13 seconds, Go took 2.2 seconds, and the Rust port finished in 0.5 seconds. The only reason one person could steer agents through a compiler in three weeks was TypeScript’s test suite: more than 13,000 small programs specifying the exact errors the compiler must report.

Four days later, on 9 November, Theo Browne posted Coding Isn’t About Code Anymore (155,794 views in its first day). At [00:38:33], he showed the pull request he was proudest of in T3 Code: deleting 250,000 lines of unit tests in one go. Out of roughly 11,000 deleted tests, his team ever needed four of them back.

So which is it? When AI writes the code, do thousands of tests let one person do two years of engineering in three weeks, or do they slow your agents down until you have to delete half the test folder?

Both happened in the same week, and Theo himself contributed to tsrs over the weekend ([00:32:11]). Looking at the two test suites side by side shows why one set of tests confused AI agents while the other let agents port a compiler, and gives you a ten-minute check you can run on your own last ten pull requests.

What people are saying

Across YouTube and Hacker News, the conversation around coding agents has shifted from “can AI write this function?” to “what is the human engineer’s job now?” In his 9 November video, Theo named the fear directly ([00:04:53]):

“A lot of people seem to have a fear that that feeling of tinkering and finding the right pieces and getting them together the right way is going to be gone, because when you start using AI, a lot of what we have loved about software dev... just isn’t there anymore, and that sucks.”

Then he described what replaced line-by-line coding on his three-person team ([00:01:28], [00:32:52]):

“We’re not really engineers anymore... I’m going to make the argument that our role is gardeners. We shouldn’t be the ones growing the code. We now need to build environments where the code can grow in the right direction, have the right nutrients, have the right support systems... and the likelihood that you can recover it before it becomes a weed and infects your garden is as high as possible.”

At the end of the stream ([00:44:08]), his chat pointed out that engineer Lauren Tan had arrived at the same word independently that week: someone watching the stream of pull requests, noticing the third as Record cast of the week or lint suppressions spreading across the repo.

Why 11,000 tests slowed agents down while 13,000 tests guided them

Most developers who want to keep AI agents from breaking things do one of two things: they either spend all day reviewing diffs line by line, or they ask their agent to write unit tests for every pull request.

Theo’s video shows why asking agents to pile on unit tests backfires.

Earlier in T3 Chat’s life, Theo wrote his own custom sync engine by hand. When Julius and Mark joined full-time, that sync engine became the bottleneck ([00:28:35], [00:29:28]):

“I was the only person who understood it. And as a result, I was blocking my team constantly... I was writing slop before agents were. The setup we had for T3 Chat before we had Convex was a bunch of Theo sync-engine slop... I was an incredibly effective chef when it came to cooking slop.”

Then he connected that to what happens inside an agent-heavy repo ([00:30:17]):

“Where the slop comes from doesn’t matter. Neither does who your team is. Let me reframe this now. Sonnet 4.5 slop was blocking Opus 5.5.”

Every time an older model or a tired human leaves a clumsy pattern or a redundant edge-case test in the repo, the next agent reads it as the house style and copies it five more times. In T3 Code, unit tests multiplied on top of unit tests until the suite had 11,000 tests locking in old edge cases ([00:38:50]). Worse, slow checks punish agents far harder than they punish humans: if a dev server or test run takes five minutes, an agent misses its five-minute prompt cache TTL ([00:36:58]), burns tokens re-reading context, and stalls every parallel worktree.

Side-by-side comparison card: 11,000 unit tests deleted in T3 Code (250,000 lines cut, locked in old internals, only 4 of 11,000 ever needed again) versus 13,000 compiler tests kept in TypeScript in Rust tsrs (380,000 lines ported in 3 weeks, checked outside outputs, matched all 26,054 errors).
Theo Browne, “Coding Isn’t About Code Anymore” (9 Nov 2026); Better Stack, “TypeScript Got Ported To Rust” (5 Nov 2026).

Why did 13,000 tests work miracles for the Rust TypeScript port while 11,000 tests had to be deleted in T3 Code?

Look at what each test suite actually checked: 1. Tests that check outside outputs (tsrs, Better Stack [00:03:25]): First, Microsoft had already spent two years solving the compiler architecture in Go ([00:03:54]). Second, none of TypeScript’s 13,000 tests cared how a function was written internally. Each test fed a small TypeScript program in at the door and checked the exact error list that came out the other side. 2. Tests that lock in old internals (T3 Code, Theo [00:40:26]): The 250,000 lines of unit tests Theo deleted were inspecting internal implementation details and old edge cases. After deleting them, Theo did not stop testing. Instead, when small pull requests kept bloating T3 Code’s wire protocol above his 5-kilobyte target, he built one 30-second CI check ([00:40:41]) that pipes real Claude and Codex thread events end-to-end and fails if the byte count grows.

That is the real divide in an AI codebase. A check that sets an outside boundary (5 KB on the wire, or 26,054 exact compiler errors) and runs in seconds lets an agent rewrite the internals freely. A unit test that mocks and asserts how yesterday’s agent wired three helper functions together punishes the next model when it tries to simplify the code.

Once Theo, Julius and Mark deleted the internal-wiring tests and put fast boundary checks in place, their three-person team went from 2 to 20 merged pull requests a day to 60 on a slow weekend day and over 400 on active days ([00:43:35]).

Two bar charts: T3 Code merged pull requests per day rose from 2 to 20 a day before cleaning up checks to 60 on slow weekend days and 400+ on active days; TypeScript 380k-line broken core type check dropped from 13.0 seconds in JavaScript to 2.2 seconds in Go and 0.5 seconds in Rust.
Theo Browne (9 Nov 2026); Better Stack benchmark on the TypeScript repository (5 Nov 2026).

What to do instead: four human habits to check this week

You cannot automate the judgment that decides when a test is protecting user behavior and when it is just locking in yesterday’s code. Across the 45-minute video, Theo describes four human habits he uses himself, plus one trap to watch for.

1. Know when to tap out on the feature

When Theo left Twitch (1,500 employees, dedicated platform teams for Browser Clients and GraphQL Edge) to build solo, he noticed a split in his own pull requests ([00:21:40], [00:22:09]):

“I was probably 50/50 split between my time spent doing platform code... to the actual product code. Half the pull requests I was filing as a solo dev did not affect the users at all... Knowing when to tap out on product because the thing is harder than it should be. Give it up for a minute, go back to the platform, make the platform easier to build on top of.”

When an agent struggles on a feature today, the natural human impulse is to send five more prompts forcing it through. The stronger move is noticing that the feature is harder than it should be, stopping the feature thread, and spending the next hour fixing the slow check or tangled module that tripped it.

Stacked bar chart of 10 pull requests: Theo’s solo split is 5 Product pull requests (what users see) and 5 Codebase and checks pull requests (for agents). Below it, an empty dashed bar for Your last 10 PRs.
Theo Browne, “Coding Isn’t About Code Anymore” (9 Nov 2026, 21:40).

2. Ask Derek’s question before you delete bad agent code

When Theo was new to React at Twitch and put up a bad pull request ([00:12:52]), a teammate named Derek did not just leave comments on the diff. Derek walked over to Theo’s desk and asked why he wrote it that way. Theo showed him the outdated doc page and the existing file in the repo he had copied. Within 30 minutes, Derek had two pull requests up deleting the misleading doc and rewriting the bad example ([00:13:11]).

Theo’s team now runs the exact same move on their agents ([00:39:38]):

“Whenever one of us noticed [a bad test], we would ask the person who contributed it to go find the thread where it happened and ask their agent why. What led to you adding this test? Why did you think this test was a good idea? And we would use the info it would give us to go to the root of the problem, whatever stem this weed grew from, and kill that.”

Next time your agent writes a clumsy abstraction or a pointless test, do not just reject it or edit it by hand. Ask the session: “Which file or doc in this repository made you think this was the pattern to follow?” Then delete that source.

3. Replace three internal unit tests with one 30-second boundary check

Look at the last test failure your agent fought with. Did the test fail because the user-facing result or wire payload was wrong, or because an internal function signature moved? If a check takes minutes to run or breaks every time you refactor internals without catching real bugs, it is costing you both cache hits and judgment.

4. Watch the 6 a.m. clock

Early in the video ([00:05:33]), Theo drops a confession that almost every developer working with agents in 2026 will recognise:

“I’ve been going to bed at 6 a.m. at least once or twice a week recently because I get so sucked in to the stuff that I’m building.”

When the building blocks get bigger and every fix unlocks ten more pull requests, stopping gets harder, not easier. Reviewing agent pull requests at 4 a.m. is how bad tests slip into the repo in the first place.

A 10-minute check on your own last 10 pull requests

Open your last ten merged pull requests or agent sessions and count three things:

A 10-minute check on your own last 10 pull requests.
QuestionWhat to count in your last 10 PRsWhat it tells you
1. Features vs. foundationsHow many changed what a user sees, and how many cleaned up the repo, checks, or docs so the next change is easier?If all 10 are features, you are never tapping out to clean up what slows the agent down.
2. Outside outputs vs. old internalsIn the tests added, how many check an end-to-end input/output boundary vs. internal mocks and helper wiring?Internal-wiring tests will force the next agent to copy today’s edge cases.
3. Source file vs. symptomThe last time an agent wrote bad code, did you fix the diff, or did you ask which file in the repo taught it that pattern?Fixing the diff leaves the bad example in the codebase for tomorrow’s session.

How KORTURE.ai approaches it

KORTURE.ai does not clean up your repo, and it does not make your AI better. It measures your own human habits across your sessions with Claude Code, Codex and desktop AI tools: when you tap out of a stuck run vs. keep pushing, what you check before approving, and when late-night sessions start drifting, so you can see your own pattern in your record. It is in research preview at /get.

Watch them if

  • Watch Theo’s [“Coding Isn’t About Code Anymore”](https://www.youtube.com/watch?v=GtJKFhztgdM) (45:21) if you want the full story of how Twitch separated Product and Platform teams ([00:09:26]), his 25,000-line hand-coded Convex migration before hand surgery ([00:26:00]), and the T3 Code PRs where he deleted 250,000 lines of tests ([00:38:33]) and added the 30-second wire-protocol check ([00:40:41]). Sponsor segment (CodeRabbit): 01:48 to 03:05.
  • Watch Better Stack’s [“TypeScript Got Ported To Rust... And It’s 3x Faster Than Go”](https://www.youtube.com/watch?v=Quf05tmWjaQ) (5:19) if you want the side-by-side benchmark numbers across 380,000 lines of TypeScript (01:32) and how the 13,000-program test suite made the 3-week Opus 5.5 port possible (02:53).
All writing