Coding Isn't About Code Anymore
Monday, Nov 9 · 45 min · about 10 min to read
Theo-brain watched all 45 min
Theo argues that with AI agents writing the code, a developer's real job is now 'gardening': shaping the environment (checks, tests, docs, tooling) so agent-written code grows in the right direction, and pulling out sloppy code fast. The lesson for Luis is to spend time removing what slows your agents down, because friction hurts agents more than it ever hurt humans, and agents make the fix cheap.
Skim itMuch of the middle is personal Twitch history; watch the gardening argument and the concrete T3 Code examples near the end.
Parts
Engineers are becoming gardeners
Theo sets up his claim: developers aren't really engineers anymore, and their role is keeping a healthy garden.
The simplest way I can put this is that we're not really engineers anymore. So if we're not engineers, what are we? Are we tech leads? Are we product managers? Are we designers? Are we visionaries? What's our role? I'm going to make the argument that our role is gardeners. The best thing we can do now is maintain a
Losing the Lego feeling, finding a better one
AI takes away the joy of assembling code by hand, but he says the problems on the other side are more fun.
when you come out the other end, the types of problems you'll be solving, the types of tools you'll be assembling, the types of building blocks you'll be building and building with are so much more fun than I've ever had building software before. Like I genuinely am
Twitch: product teams vs platform teams
Feature teams owned their own slice of Twitch, while platform teams kept shared systems scaling; the two had to cooperate.
Twitch. And this meant that a relationship had to be built between the product teams and the platform that the product teams were building on. This
Fix the cause, not the symptom
A colleague answered Theo's bad pull request by fixing the misleading docs and code within 30 minutes.
back to his desk, and within 30 minutes had two PRs up. One getting rid of the junk in the docs that misled me, and the other rewriting all the code in the codebase that confused me. And that's when I realized how important that work was, that if you weren't setting up your
Going solo and the T3 Stack
Alone at his startup Ping, he split his time about half and half between making the codebase easier and building features.
where the time should go. And that I was probably 50/50 split between my time spent doing platform code, making it easier to work on Ping, to the actual product code, making the product itself better.
Blurring product and platform
A fight over storing a simple data blob taught him most developer friction is one conversation away from disappearing.
was the realization that so many of these things, so many of the pieces of friction you encounter as a dev are like one conversation and one small change in the platform away from not needing to happen. And all of this is such a
The last hand-coded overhaul: Convex
Moving T3 Chat to the Convex backend was invisible to users but unblocked his team, the kind of work he loves.
product. What I'm trying to say is I love these overhauls, the ones where no one outside can or should feel a difference, but we know it sets us up to work much more effectively. And then
The economics of gardening
Platform cleanup used to pay off only at big companies; agents now make it cheap and far more valuable.
gardening work was only really worth it if you were shipping at such a scale and the friction was so high that you could justify the insane investment necessary to do it. And this only happened at big
Gardening in practice at T3 Code
A PR he was particularly proud of deleted about half of T3 Code's unit tests, because many were useless and multiplied into more pointless tests.
example of the type of work I'm talking about here, here's a PR that I was particularly proud of. This PR involved me deleting around half of all the unit tests in T3 code because the more I was looking at them and the more I was working in the codebase, the more I realized how many of these tests are useless, and more importantly, how much
Closing
He admits the change is scary but says the work has never been more fun.
it the same. I know that this whole world is changing really fast and that it is scary, but if you find the magic within it, it is also the most fun it's ever been. And if even one of you can
Tap any time to jump the video there.
Key takeaways
The new job is not growing the code yourself. It is building the environment so code grows the right way: the right support and monitoring, so most changes succeed and bad ones are caught before they spread.
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 have the right monitoring and everything else in place that the likelihood the plant
Friction hurts agents far more than people. For Theo, fixing annoyances might lift him from 10 to 12–15 pull requests (proposed code changes) a week. But an agent that waits 5 minutes for a dev server just to test its work is badly stuck.
best case if I could have filed 10 pull requests a week with these things being broken, fixing them could get me up to like 12 to 15 maybe. Your agents get blocked much harder by these things. If it takes 5 minutes to spin up the dev server to even check if the code works or not, your agent is going to be
Slop, meaning low-quality code, spreads faster than weeds. If you stop maintaining the codebase, you soon come back to one made mostly of weeds.
grows faster than weeds do. If you are not constantly maintaining your garden, you will very quickly come back to a garden that is composed primarily of weeds.
The payoff is real: after this upkeep, T3 Code went from about 2 to 20 merged pull requests a day to around 60 on a slow day and 400+ on active days.
This is what happens when you maintain your garden well. We went from pretty consistently like two to 20 PRs merged a day to a bad like weekend day where we're busy being 60 merged and active days being in the 400 plus range. This is because our garden is really healthy.
Code quality is as much about communication and organization as about how good the engineers are. A well-set-up codebase lets an okay contributor and a great one both produce code that is safe to merge.
exactly the opposite, that the quality of the code is as much a communication and like organization problem as it is like the code that you're writing and the quality of the engineers. And ideally, if all goes well
Two skills here are new to you.
Prune useless tests, then trace where they came from New
- What it is
- Delete automated tests that add no value, then when a bad test reappears, ask the agent that wrote it why it did, and fix that root cause.
- Why Theo cares
- Useless tests multiply and breed more pointless edge-case tests. He deleted 250,000 lines in one PR and brought back only four of 11,000 tests, with no regressions the deleted tests would have caught.
- How to try it
- Ask your agent to audit the test suite and list tests that only cover unnecessary edge cases.
- When a pointless test shows up, open the agent thread that added it and ask why it thought the test was a good idea.
- Use that answer to fix what led to it, rather than just deleting the test.
whatsoever. And that's why I was able to delete 250,000 lines of code from the codebase in one PR, and we've had no regressions that any of the deleted tests would have caught. I think of the 11,000 tests, I brought back four of them total. This is a phenomenal example
noticed one, 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
A CI check that measures what you care about
- What it is
- An automatic check on every pull request. Theo's runs real thread data through a simulated pipeline, reports how much data was sent, and flags regressions with red X's.
- Why Theo cares
- Small, innocent-looking changes kept undoing a week of speed work. The check shows the number in every PR, and most importantly tells the agent this metric matters, like a stake a plant grows along.
- How to try it
- Pick one thing you care about, such as how much data a page sends, and ask your agent to build a check that measures it on every PR.
- Have the check post the result in the PR and clearly flag any meaningful regression.
- Let the agent watching your PRs see those flags and fix them.
thread transfer impact tool, which is an action that runs on every PR that has a bunch of real event data from real Codex threads and threads, runs it through a fully simulated end-to-end pipe and checks how much data goes through the pipe. And then it would print it in
changing. But the most important thing, this is really silly, it gives the agent the information this is a thing we care about and it should be optimized for. To
The product–platform pendulum New
- What it is
- Swing between building features and improving the foundation. When a feature is harder than it should be, stop, make the codebase easier to build on, then return to the feature.
- Why Theo cares
- He says learning when to switch sides leveled him up more than almost anything. Now he constantly checks where his agents get stuck to decide what to fix.
- How to try it
- When an agent keeps struggling with a feature, pause it and ask what in the codebase made the task hard.
- Have an agent fix that underlying problem first, then resume the feature.
- Regularly review agent sessions to spot where they get stuck or confused.
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. And then once that is in a good state again, go back and build the feature. That back and forth is what
And I am constantly quadruple checking my agents to see where they're getting stuck, what weeds they're tripping over, what fertilizer they're most confused by, what posts they need to grow
Advice
Treat every bad pull request as a signal. Fix whatever misled the author, such as unclear docs or bad example code, so the next person doesn't repeat it. Skip this and quality erodes fast.
point where it's a whole request that isn't good, that shows an opportunity to improve things, to make it so the next person doesn't make those mistakes. And if you don't take those opportunities as soon as you see them, the quality of everything around you is going to erode
Don't treat tools and platforms as fixed. They are made by ordinary people you can just talk to and work with to get things changed.
things are malleable, all of these things can be changed and improved, all of these things are made by people no more special than you or I. And you can just talk to them about things and work with them on things and get things
Hot takes
If you haven't changed how you code in the last year because of AI tools, you might not have a job in a year or two. Theo says he danced around this for years and was wrong.
His reasoning: Everything has changed, especially how developers work and what their role is.
role is over time because if you haven't changed how you code over the last year as a result of these tools, you might not actually have a job in the next year or two. We are at that point now. I've danced around it for years and I was wrong. Everything has changed and
It doesn't matter whether slop comes from a person or a model. His own hand-built code blocked his team the same way code from an older Claude model (Sonnet 4.5) blocks a newer one (Opus 5.5).
His reasoning: His custom sync engine for T3 Chat kept causing friction and getting in his team's way; what matters is whether code blocks whoever builds on it next.
know about my slop is that my slop was blocking my team. The reality is that where the slop comes from doesn't matter, neither does who your team is. Let me reframe this now. Sun at 4.5 slop was blocking Opus 5.5. You see where
Anyone who says tending the codebase for agents isn't engineering may never have been an engineer.
His reasoning: He has never felt more like he was building a platform than he does now.
against. And if you don't think this is engineering, I don't know if you ever were an engineer. Cuz I've never felt more like I was building a platform than I do today. And it's just so goddamn
How Theo thought about this
He reran the cost-benefit math. At Twitch, rewriting TypeScript tooling to speed up 600–800 engineers wasn't worth it, and one library upgrade took about eight people a month. Now that upgrade is 'one prompt', so he is rewriting TypeScript in Rust just so a three-person team moves slightly faster.
dev servers to start. Now I am rewriting TypeScript in Rust so that a three-person team can move slightly faster. The cost-benefit analysis there
to get the data. And this took a team of like eight people plus a bunch of assistants like a month plus to do. That's one prompt now. And this is what's so cool. Historically,
To explain why he adapted to agents fast, he traced it to his Twitch years. He pointedly left out managing, heavy code review and test coverage. What carried over was the loop of building a platform that good product grows from, and letting product feed back into it.
didn't talk about any of that All I've talked about is this relationship between setting up a platform that good product can grow out of and setting up product to give feedback to the platform so that they can grow together. So what
Sign in to mark what you've watched and keep notes.
Have a question about this one? Ask about this video →
Theo Daily is unofficial and not affiliated with Theo or t3.gg. Written by Claude Opus 5.5 from each video's transcript.
