A 45-minute career story from Twitch to T3 Code that ends at one claim: with agents writing the code, the engineer's job is now tending the garden the code grows in.
Posted
1 weeks ago
Duration
Format
Essay
sincere
Views
246.5K
4.1K likes
57 · 43
Big Idea
The argument in one line.
Once agents write the code, your real job is gardening the codebase: fast checks, clean platforms, and constant weeding, because friction blocks agents far harder than humans and AI slop spreads faster than you can review it.
Who This Is For
Read if. Skip if.
READ IF YOU ARE…
A working developer who already uses coding agents daily and is unsure what part of the job is still yours.
A tech lead whose team merges agent-written PRs and is watching test counts, lint suppressions and CI times quietly creep upward.
An engineer who loved the Lego-building craft of writing code and is grieving it, looking for the part of the work that still feels like engineering.
A solo founder or small-team builder deciding whether to spend time on product features or on the tooling and platform underneath them.
Anyone who came up on product teams and never understood why platform teams obsessed over docs, type-check times and CI.
SKIP IF…
You want a hands-on tutorial; this is a career story and a mental model, with only two concrete PR examples near the end.
You are looking for evidence that AI coding is overhyped; the argument assumes agents already write most of the code.
You work alone on tiny scripts with no CI, tests or shared codebase to maintain.
TL;DR
The full version, fast.
Writing code is no longer the engineer's job; tending the environment code grows in is. Drawing on years at Twitch straddling product and platform teams, then running T3 Chat and T3 Code, the argument is that platform work (fast type checks, clean docs, strict CI, sane tests) used to pay off only at huge scale, but agents make it nearly free to do and far more valuable. Slow dev servers, slow CI and bad examples block agents harder than they ever blocked humans, and agent slop multiplies faster than weeds. The fix is to stake the plants: add cheap CI checks that tell agents what matters, delete low-signal code aggressively, and trace every bad pattern back to its root. The payoff is throughput that jumps from roughly 20 merged PRs a day to 400 or more.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Sets the stakes for developers trying to ship with AI and states the thesis: our role is now gardeners.
01:42 – 02:52
02 · Sponsor: CodeRabbit Secure
Ad read on AI-era security scanning for every PR and deep scans of existing code.
02:52 – 05:59
03 · The fear of losing the craft
Admits the Lego-building joy of assembling primitives disappears with AI, then promises the problems on the other side are more fun.
05:59 – 16:44
04 · Product versus platform at Twitch
How Twitch split feature teams from platform teams, and how one engineer fixing the docs that misled a bad PR taught the lesson: fix the cause, not the symptom.
16:44 – 22:05
05 · Going solo and the T3 Stack
Leaving Twitch meant no platform teams, so a lightweight stack replaced them, and half of all PRs became platform work users never saw.
22:05 – 25:49
06 · The pendulum and the JSON blob
Swinging between platform and product, and the story of a weeks-long fight over storing a JSON blob that one conversation with the GraphQL team resolved.
25:49 – 29:28
07 · The last hand-coded overhaul
A month-long, 25,000-line migration of T3 Chat from a custom sync engine to Convex that users barely noticed but that unblocked the team.
29:28 – 31:16
08 · Slop before agents
The custom sync engine was human slop blocking teammates, the same way weaker-model slop now blocks stronger models.
31:16 – 36:19
09 · Gardening is the job
Defines gardening: build the environment so code grows the right way. A month-long Apollo migration is now one prompt, so platform work pays off at any scale.
36:19 – 38:10
10 · Friction blocks agents harder
Slow dev servers, CI and releases cripple agents and waste tokens, and slop grows faster than weeds.
38:10 – 43:00
11 · Gardening in practice
Deleting 11,000 low-signal tests with no regressions, tracing bad tests back to agent threads, and a thread-transfer CI check that acts as a stake.
43:00 – 45:21
12 · The payoff and sign-off
Merged PRs per day jump into the hundreds, a parallel post argues every team needs a gardener, and a closing invitation to find the fun again.
Atomic Insights
Lines worth screenshotting.
If your workflow hasn't changed in the last year because of coding agents, your job is at real risk in the next one or two.
The engineer's role is shifting from growing the code to building the environment where agent-written code grows in the right direction.
Every bad pull request is evidence that the platform, docs or examples steered someone wrong, so fix the cause instead of the symptom.
As a solo developer, roughly half of all useful PRs can be platform work that users never see but that makes the other half far easier to land.
Many pieces of developer friction are one conversation and one small platform change away from disappearing entirely.
Slop is not new to AI: a human's hand-rolled sync engine can block a team exactly the way a weaker model's output blocks a stronger one.
A migration that once took eight engineers a month and a shared spreadsheet of broken files is now a single prompt.
Platform gardening used to be justified only at big-company scale; agents have collapsed its cost enough that a three-person team can rewrite a type checker.
A five-minute dev server start that mildly annoyed humans can block an agent completely and also burn tokens by missing cache windows.
Slow CI caps how many agents you can run in parallel, and a scary release pipeline caps how often you merge.
Slop grows faster than weeds: leave a codebase untended for a short while and agent output will overrun it.
Deleting about 11,000 low-signal tests and 250,000 lines in one PR caused zero regressions; only four tests were worth restoring.
When an agent adds a bad pattern, ask that agent's own thread why it did it and fix the root cause in your guidance files.
A CI check that prints a metric on every PR acts like a garden stake: it tells reviewers, babysitting agents and contributors what to optimize.
Teams that never separated platform from product are now stuck with product engineers doing platform work they don't understand, and they can't keep up.
A well-tended agent codebase can move from about 20 merged PRs a day to more than 400 on active days.
Takeaway
Tend the codebase so agents can build
WHAT TO LEARN
Agents now write most of the code, so the leverage moved to the platform underneath: fast feedback, clear guidance, strict checks, and relentless weeding of slop before it spreads.
01We're not engineers anymore
Writing code by hand is losing its value; what still compounds is shaping the environment, docs and checks that every contributor, human or agent, builds inside.
04Product versus platform at Twitch
Treat each bad pull request as a symptom: find the doc, example or tool that misled the author and fix it so nobody repeats the mistake.
05Going solo and the T3 Stack
Budget real time for platform work even on a tiny team; half your PRs improving tooling can make the other half dramatically easier to land.
06The pendulum and the JSON blob
Swing deliberately between product and platform: when a feature feels harder than it should, stop, fix the foundation, then go back to building.
A lot of friction disappears after one direct conversation with whoever owns the system, so describe the problem to them rather than guessing what they'll allow.
08Slop before agents
Slop is about effect, not authorship; any code that only one person understands and that slows everyone else is a weed worth removing.
09Gardening is the job
Large mechanical migrations that once needed a team and a spreadsheet are now a single agent prompt, so platform improvements pay off at any team size.
10Friction blocks agents harder
Measure slow dev servers, CI and releases as agent blockers; they stall automated work completely and waste tokens by missing cache windows.
11Gardening in practice
Delete low-signal code and tests aggressively; one PR removing 11,000 tests and 250,000 lines caused no regressions and made CI faster.
When an agent produces a bad pattern, ask its own thread why, then fix the root cause in guidance files like AGENTS.md.
Add cheap CI checks that print the metrics you care about on every PR; they steer agents and reviewers the way a stake steers a plant.
Glossary
Terms worth knowing.
Platform team
An engineering team that owns shared infrastructure such as the main repo, build tooling, APIs or databases, so feature teams can build on top without each reinventing it.
Product team
A feature-focused engineering team that owns one user-facing surface end to end, such as chat or a creator dashboard, including its client, backend and data.
Slop
Low-quality code that technically works but makes a codebase harder to understand and change, whether written by a rushed human or by an AI model.
Sync engine
Software that keeps the same data consistent across a server and multiple client devices in real time, so a change on a phone appears on a laptop.
Convex
A hosted backend platform that combines a database, API layer and client SDK with built-in real-time sync, now open source.
tRPC
A TypeScript library that lets a frontend call backend functions directly with full type safety, without writing a separate API contract like GraphQL or OpenAPI.
T3 Stack
A popular TypeScript web starter that combines Next.js, tRPC, Prisma and Tailwind for end-to-end type safety from database to browser.
GraphQL edge
The single public-facing GraphQL API that client apps call, which then fans requests out to many smaller internal services owned by different teams.
Cache TTL
Time to live: how long a model provider keeps a prompt cached. Waiting longer than the TTL between agent steps means paying full price to reprocess context.
AGENTS.md
A plain-text instructions file in a repository that coding agents read to learn the project's conventions, rules and things to avoid.
Babysitting agent
An AI agent assigned to watch a pull request, read CI results and review feedback, and push fixes until checks pass.
44:07linkLauren (@potato) post: every team needs a gardener
Quotables
Lines you could clip.
01:18
“The simplest way I can put this is that we're not really engineers anymore.”
bold thesis, no setup needed→ TikTok hook↗ Tweet quote
30:11
“My slop was blocking my team. Sonnet 4.5 slop was blocking Opus 5.5.”
self-own that flips into the core argument in two lines→ IG reel cold open↗ Tweet quote
35:43
“This took a team of like eight people plus a bunch of assistants, like a month plus to do. That's one prompt now.”
concrete before/after with a hard number→ TikTok hook↗ Tweet quote
37:50
“Slop 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.”
“If you don't think this is engineering, I don't know if you ever were an engineer.”
confrontational one-liner that answers the critics→ IG reel cold open↗ Tweet quote
38:36
“I was able to delete 250,000 lines of code from the code base in one PR, and we've had no regressions that any of the deleted tests would have caught.”
shocking number with a clean payoff→ TikTok hook↗ Tweet quote
The Script
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
17px
metaphoranalogystory
I've been spending a lot more time talking to engineers outside of my little bubble in San Francisco recently. It's a combination of the events I've been going to, the courses I've been helping with, and all sorts of other things. I've been having a lot more of these conversations about what it means to code with AI and what even is an engineer today.
I've been thinking about this a lot and I've been kind of wanting to do a video on it for a while, but I'll be real with you guys. I know what my comment section looks like and I know how much a lot of you will hate this video. So honestly, I'm not doing it for those people.
I'm probably just going to ignore the comments on this one entirely because I fear what they're going to look like. But I'm not making this video for the people who are going to be leaving the nasty comments that Theo's not a real engineer. He's just a JavaScript dev that thinks AI is so smart.
It probably is smarter than him. This video is just, we can ignore those people. This video is for developers who are actually trying to ship, take advantage of these technologies, and figure out what their 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 most importantly, the way that we work and what our roles are has changed. It's changed on a really deep fundamental level.
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 healthy garden.
This is going to take a lot of explanation, and I'm going to do my best to explain it. But if I am wrong about this whole engineers are becoming gardeners thing, then I guess I'm just an influencer. And I'm not a very good influencer if I don't take a quick break for today's sponsor.
I don't know if you guys have noticed, but it seems like a lot of stuff is being hacked recently. That's because as good as AI is at writing code, it's also pretty good at writing exploits and finding these types of things. There's a problem though.
The models we use every day don't have the capability to really scan and tell us what could be insecure about our code, but they're more than happy to write insecure code. That's why we need to be actively monitoring every change as it goes in, understanding the blast radius of the changes that we're making, and also ideally, give us the ability to deep scan our work to find things that might have been missed from the past.
Wouldn't it be nice if there was someone who could do that? Good news, today's sponsor is CodeRabbit, and their new CodeRabbit Secure product is here for just this. They can do deep scans to find things that you might have missed in the past, and they can scan every PR as they come in, making sure they are as secure as possible.
Back in my day, an exploit being discovered wouldn't be exploited for two or more years relatively often. Now, as soon as the patch is live on the repo, we see people exploiting it immediately. Best thing you can do to prevent this is to make your code secure before it even goes out.
When you start shipping faster, it's much easier to let things slip through the cracks. That's what Code Rabbit Secure is here to help prevent. Understanding the reachability, exploitability, and the blast radius of every change has never been more important.
You can get started now with 14 days free at soydev .link slash coderabbit. This is one of those videos that's going to have a lot of layers to it and get a little bit chaotic. So sorry in advance to you and also to my poor editor who's going to have to figure out how to turn this into a somewhat cohesive video.
I already see people in my chat. who are concerned that this is going to be a sad video, and I really don't want it to be that. I'm going to start backwards here a bit, because I want people to stop being scared of this part and instead be excited about this one.
So let's fixate first on this bit, the idea of engineers. I don't know about y 'all, but the thing I love about engineering is the feeling of finding the right pieces, assembling them the right way. and creating something that is really meaningful and impactful i love the lego building block aspect of things and most importantly i love how you can change the size of the blocks so to speak like with legos you always have those same low level building blocks unlike with legos where you just have these single blocks you are assembling in different ways in engineering you have different levels of primitives the building blocks could be the actual silicon in the chip or you can abstract higher and be living in software writing assembly or you can abstract higher to a language like c or you can start using runtimes or packages or other tools you can build your code in a way where the lines are composable or the functions are composable or the modules are composable the flexibility in where you break things apart and the dynamic nature of how we can assemble them together
is just so fucking fun. I love it. That's why I love writing software.
That's why I love building. That's why I love all of the stuff that we've been doing forever. And what I have been scared of is losing that.
And I know a lot of people seem to have a fear that that feeling of like tinkering and finding the right pieces, getting them together the right way is going to be gone. Because when you start using AI, it is. A lot of what we have loved about software dev, when you start going down this rabbit hole, just isn't there anymore.
and that sucks but the good news that i hope you can get out of this video is that when you get through it 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 just unable like 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. It's just so fun and rewarding. And I'm not doing this out of fear or FOMO or worry that I'll be left behind.
I'm doing this because I love it right now. So if you're coming in here fearing what's happening, I hope you can open your mind a little bit and just hone down that fear slightly because I felt it a bit too. I am lucky that my career is not just software dev, so I was able to get through it faster because I didn't feel like my world was crumbling.
It just felt like one of my hobbies was. But then I found a deeper love for it on the other side. Let me now explain how I got here.
I don't know how to make this video in any way other than it being really personal. So I think I'm just gonna do that. I think the best place to explain why I think this way starts back with my time at Twitch.
For those who don't know, I was working at Twitch from 2017 to 2021. I hopped around teams a decent bit when I was there, but I want to focus on a specific cross section here, which is roughly from 2019 to 2021. There's a couple reasons I want to focus on this area, but the simplest way to put it is from 2017 to 2018, I did pretty well.
From 18 to 19, I almost got fired because I just... did not like the things I was working on when the team I joined for at Twitch folded and the exec who pulled me into Twitch retired. I was just not happy.
The main reason I survived this window where I was this unhappy was because my new manager, who I got thrown under with a team shakeup internally, had taken a liking to me, knew I was a decent -ish and still not great, but like motivated. He was a front -end guy. I was a deep systems back -end guy, mostly doing video infrastructure and Elixir.
And I had to move to a different video team, the VOD team, and work in Go and was just miserable. He saw how miserable I was. He pulled me aside and told me I should go try out this new React TypeScript thing that we were starting to use more internally.
I didn't like it much at first, but it made some sense. But then hooks happened, which was when React added more functional programming patterns. And I got...
for lack of a non -pun way of describing it hooked quite quickly because i was already a huge functional programming nerd due to elixir and the mental model for hooks clicked so much better for me and i went from feeling like i didn't belong when i joined in 2017 to like mid 2017 mid 2018 being like oh i understand where everything is in my head i know how all these parts come together i understand the system i can change anything in the system and know what will happen.
And that feeling was the first time I had that, like a thing that mattered. I understood the outside and inside of, and I could reason about how things would behave when changes were made. I did not get that same intuition, especially as I was joining a team that already had a gigantic code base in a language I was not familiar with.
And they were building in a way I was not used to at all. I was really struggling to get that same grasp around the VOD platform code. So React hooks happened.
And at the same time, Twitch was starting to move away from the old decrepit Ember plus Rails code base for the site and towards a Go plus GraphQL plus React TypeScript code base. That was a huge shift for me. And I got to be there when the thing started to be made.
and i got to be the person advocating for this new way of building that i got to like see a bit earlier than others did like why it was valuable because most of the people who were part of this huge rewrite had been writing react code for five years had been writing web code for 10 years and i had just moved to web code like a few weeks prior with a bunch of weird niche functional programming experience and i was just so genuinely excited that they pulled me under their wing for the team running the like core web product.
I should give a little bit of background on like how teams are structured at Twitch. Most of the teams are feature teams. So right now I'm live and I have a bunch of people in chat.
The chat team is a team. So it's a team that is chat. Their job is running all of the chat related things.
Then there's a team that is the creator dashboard. The creator dashboard is the view that I was just in here where I can see everything going on in my stream on Twitch. Then one of my personal favorites is the mod tools team.
This is the team that built a lot of the moderation platform stuff that we used at Twitch to allow mods to keep our chat safe. Things like the mod view platform that I built and talked about a bunch of other videos. These are just like, funny enough, the three teams I was on for like core product in my time at Twitch.
And all of these teams are focused on like one specific surface area that they own all of. So the mod tools team owns the back ended infra, the database. the client the web code and all of the things people interface with the chat team owns the back end the protocols the way that messages go to and from the chat and of course like all of the back end and infraside as well as all of like the emoji stuff and the important like features built into teeth or the chat inside of twitch creator dashboard is as you expect very similar but this is one of the two main types of product and eng teams at twitch there's a very hard separation between them i'll call this side product i'm going to call the other side platforms because while mod tools chat and creator dashboard they owned their portions of the website and their portions of the back and their portions of the database we still needed a team to make sure the apis didn't fall over and could scale the way twitch did and it's not the responsibility of each product team to make sure that every single thing they do scales and plugs in perfectly with everything else
That would just be insane. If every single team had to build their own scalable infra for every single thing, it would be hell. So we ended up also with teams like Browser Clients.
Browser Clients was the team that managed the repo for the website, the repo for the Electron app when that was still being maintained, the repo for all of the different web product stuff that we had at Twitch, like the smaller mobile site that we were pushing in other countries at the time. Then we had the GraphQL Edge team.
We referred to the GraphQL API as the Edge because it was just the front -facing thing that the user APIs would interface with. Like when you're doing things on Twitch, the GraphQL Edge is what hits. And then we would federate out to the smaller services the different teams owned.
And of course, there's like the data database platforms team, the video infrastructure platform team. There were different teams for the different platforms within 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 ended up being one of my favorite parts of working at a company like Twitch is that I got to spend most of my time on product. I was never at any point formally on a platform team.
But if you ask the platform teams, they would possibly say otherwise, depending on who you're talking to, because I spent so much time hanging out with the platform teams. For example, with browser clients, the guys who ran the repo for the Twitch site, I was the only non... browser clients or platform team member that was in their weekly planning meetings because i just cared a lot about the platform this all started because of a conversation i had early on when i was working on the site and i was reading through the docs for this new twitch rewrite and react and i was trying my best to take what i learned from the docs and apply it to my code and i made a pr that was not very good and i remember a guy named derek jumped on it and like came over to my desk and asked me just questions on like why i wrote it this way and i showed him the pages and the docs that led me there and the examples in the code base that i was referencing he thanked me for that said it was super super helpful ran 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 code base that confused me and that's when i realized how important that work was that if you weren't
setting up your team for success, then that would just constantly be lowering the bar. And every time something even gets to the point where it's a pull 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 so fast.
And this is the first time I'd really seen that in action. i like this framing from twitch chat thank you thales hopefully i pronounced that right do not fix the symptom fix the cause exactly and i ended up really loving this there was a combination of other fun things like when i was on the safety platform slash safety tooling team internally not for mod tools yet but for internal safety stuff we were kind of running our own like clone of the twitch infrastructure so that it was easy to hop between the internal tools and external tools without having your mind get all like screwed up because everything was so different but our repo was smaller and only had like 300 users instead of the like millions that the core twitch site had so i was able to experiment with ideas that we weren't sure were ready yet for the main twitch repo and then bring them to the browser clients team being like yo we dog fooded these four ideas these two kind of worked this one seems worth it we should figure out how to do this in the main twitch site and they loved that so much like to this day a lot of my friends from twitch are still just people from the browser clients team
I absolutely love that team. They offered multiple times to let me switch to their team, but I just liked building product too much to do it. I love building things people actually use and play with and interact with that make their lives better in some small way.
And I don't like the platform side unless it's making a product better. And I don't like the product side unless the platform is good and also honestly in continuing to improve as well. And it's this relationship between making product that solves real problems for people.
and building platforms that allow those products to grow and succeed that made this relationship just so fun and enticing for me so huge shout out to the browser clients team in particular at twitch for really flipping how i think about engineering it was one of the like the moments in my life that formed the way i work now and i have been thinking back on this moment a lot recently because i've been trying to figure out why i was able to make the move to working with agents so quickly i already see the comment below this video the reason theo could make the move so fast because he was writing shitty javascript slop so he doesn't care about the quality of the code i hope that what i'm describing here shows 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 in the world an okay engineer and a phenomenal engineer can both write good enough code to merge where it will not degrade the quality of your code base before we go to this next section i want to call out a few of the things i didn't say at any point so far i did not talk about becoming a manager i did not talk about super intense code review processes i did not talk about building a bunch of guard rails into unit tests to prevent things from going certain ways i didn't talk about code coverage and 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 happened next? What happened next is that I quit my job at Twitch.
And this was a big forcing function for how I worked, both because I'm now out of a job, but also just because it changed why I cared. Not just what I cared about, but more importantly, the why. because a lot of the reasons i would care about the platform the way i did before is that it would set up my co -workers to do better things it would set up other teams to make better product and i got to evolve everyone around me by making these changes everything i had done at twitch was trying to make it easier for all of us to ship good stuff it was not necessarily focused on faster although that was a nice consequence of things i was regularly pulled in to try and get timelines back on track when roadmaps started to get blown up but i really just wanted to focus on like building the platform out so it was easy to do the right thing and there was no examples of how to do the wrong thing but then i went from working at a company with 1500 employees to a company with one me and my priorities necessarily had to shift because when i started ping it was just me
And now I don't have a platform client team to rely on for making sure our webpack bundle works properly across all the different ways it can be used. I don't have a backend video infrastructure and platform team. I don't have a GraphQL edge distribution team.
I didn't have the teams who owned these things anymore. And my first instinct was to try and replicate the things those teams did and to try and build out all of the stuff I love. And I was spinning up GraphQL backends with Elixir powering them and spinning up crazy, complex client bundles where i was going through and manually managing the way the bundles were split and stuff like that i was able to make a product that kind of worked but i ended up just doing all of the jobs of all of these different people that no longer were my co -workers and i realized that i had to change the way i was thinking about these things i still wanted to set up everything in my code base for success so that the right thing was easy and the wrong thing was hard but i had to make all of the things faster and easier to do and less work to maintain And then a thing happened that the people who have been here for a while have heard of.
T3 Stack. The T3 Stack happened because I needed the confidence of the platforms I was used to without the friction that was necessary to build them. And I created this set of tools that, to be clear, I didn't really create the tools.
My innovation here wasn't particularly innovative. I took three sets of tools people were using well. and assembled them into one and it was next .js typescript client with next .js as the server alongside of course react on the client i brought in tailwind because i started finally like tailwind around this point the more important pieces were how the front and back end worked together though the back end was using prisma for the database because it was full sac type safety from the database to the back end and then i used a new tool called trpc that i'd fallen in love with They made it easy to define functions on the back end and TypeScript and then call them on the front end without having to define a bunch of contracts between the two.
You still got a contract out of it, but the contract was TypeScript. It wasn't another language like GraphQL or another weird standard like OpenAPI or something. And this was the thing that blew me up initially on YouTube.
When I started telling people about my stack, because I made this before I'd even started doing YouTube videos, and my first video was actually just me streaming, trying to explain it to people I'd met on Twitter when I was a nobody. And yes, chat, you remembered correctly. I learned TRPC because Tanner Lindsley gave it to me as homework because he saw Fred Schott, the creator of Astro, and Ryan Carniato, the creator of SolidJS, were following me on Twitter.
So when I requested to join one of his Twitter spaces back in the day, he let me up. We talked about some weird proposals I had for making it easier to make these contracts between backend and frontend. He brought up TRPC.
I went and explored it and fell in love immediately. Alex, the main creator, maintainer of TRPC is still a good friend. This is the community that we got Julius from, who is now the T3 code guy.
So much happened because of this T3 stack moment. And that moment happened because I loved how good it felt to have a platform you understood and could build on top of confidently. And most of T3 stack came out of my product.
I was building the best stack I could within Ping to make the Ping product as easy and able to be maintained as possible. While I also was doing my YouTube channel and was also doing all of the fundraising for what became T3 Tools, which is now T3 Code and T3 Chat, getting into Y Combinator, doing all the business side there, doing all the sales, marketing, and everything.
I couldn't be spending 10 to 15 hours a day coding like I wanted to. So I was putting all this effort in to make sure that when I did have time to code, it was very clear 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 this sounds insane when you think about it that like half the pull requests i was filing as a solo dev did not affect the users at all they did not see any difference from half the pull requests i was filing and merging but those pull requests made it so the other half were way easier to land and that was The back and forth, the pendulum swing between the two that I've been doing my whole career since.
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. And then once that is in a good state again, go back and build the feature. That back and forth is what leveled me up more than almost anything in my career is learning when and how to tap out of one side and go to the other and to not treat them as different.
like roles or teams or things that you can only do one of but to blur the lines more and this is why i was able to like make all the friends i made at twitch because i was the platform team's favorite product guy and the product people loved me because i was their connection to the platform and i cannot tell you how many times i was getting blocked in a product meeting because the other engineers or some team leader someone was convinced there was no way that the graphql edge team would let us do this thing that was obviously the right call so i would hop on a quick meeting with the guy running that team tony and say hey i'm probably not the right person for this because i'm not the back -end engineer on my team but the back -end engineers are convinced that this weird recursive data structure we need for the layout of the dashboard and here funny enough like because everything here is mobile and can be like built like nested the best way to encode this is just a json blob
And my team was insisting that the GraphQL team would not let us just put a JSON blob in the GraphQL API and that we had to make this super complex node system to fetch them all as a flat array and then reconstruct it into the dynamic layout. I knew this was wrong and stupid. I couldn't convince my team.
So I went to my friend who ran the other team, the GraphQL Edge team. And I explained the situation to him. I didn't tell him what the options were.
I just told him what the problem was. to which he responded, like he interrupted me to say, why don't you just store the JSON blob? I asked him if there's any reason not to.
He thought about it for a second, said, no, that seems like the right call here. Like, okay, how do I convince my team that this is the right call? He said, I don't know.
None of them ever hit me up. And then he vented to me. He ended up using the rest of the call to vent to me about how frustrating it is to be on platforms in GraphQL land and to feel like nobody on the other side, like no one from product cares at all about what he's doing.
And he's just stuck saying no one shitty PRs all day. And he was so thankful to have somebody from the front end teams on the product side, hit him up for a call that we ended up chatting all the time. And to this day, Tony is still a very good friend.
He runs a lot of the platform for Netflix. Now, if I recall, love Tony fucking death, but like, these are the conversations that shaped who I am now 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 shit. is such a waste of our time like i put more time into those conversations trying to just get a json blob stored than i spent just building the dashboard itself it was insane i was going mad those were the moments that shaped me the most and one of the things i was really thankful about when i left is that i could just do the thing on both sides i could constantly be refining both ends when i was working on teams like the creator dashboard Every conversation was one around which cost us the least internal political bullshit.
Is it better for us to invent our own node graph system in order to represent some pretty basic data? Or is it worse to have a conversation with this team that might say no, lose the time and have to do it this way anyways? Some of this was internal politics, but a lot of this was just the platform and the way it worked and the lack of understanding one side had of the other.
This is why I got so deep in like blurring the lines between them. And I think that's the biggest part of why I have had so much fun now. Fast forward a whole bunch into the future.
I want to talk about, instead of the start of something, I want to talk about the end of something. I want to talk about my last big hand -coated overhaul. The last time, probably for the rest of my life, where I sat down and rebuilt something by hand.
And the few times I tried to have agents help, they just couldn't do it. So I gave up and did it all myself. I see people in chat already guessing what it is.
I'm curious if any of y 'all remember what it is. Someone already got it. It was T3 chat convex.
I went from super skeptical about convex because at the time, to me, seemed like a closed source alternative to the T3 stack that I didn't love. Since then, convex has become both open source and way more mature than anything I had built for this type of stuff. It is a combination of a backend, a database, an API layer, a SDK for the client and the server.
Talking about Convex a lot in my videos. Definitely search Convex. You'll find a ton of them.
Still how I love to build most like full stack services when I'm building things. Absolutely love Convex. Up until I was ready to use Convex and T3 chat, I was building my own sync engine by hand and it was horrible.
It worked, but maintaining it was hell. The T3 chat port from... My custom sync engine to Convex was one of the hairiest and most difficult overhauls I've ever done.
And for the most part, when I finally could merge that like 25 plus thousand line of code PR where I shifted everything over, most people didn't feel a difference beyond like if they were using it on their phone and their computer at the same time, it was more likely to keep things in sync. This is probably the most I've worked on one big underlying tech change in my life.
I spent a whole month because I started the month with COVID, funny enough. And I got the news at the end of the month that I had to have my hand reconstructed. So I knew this was gonna be my last time like sitting and coding for a while.
So I spent the whole month on this. And it had its rough edges. We ended up at the time being one of the biggest Convex customers.
So it caused a lot of like... not outages but like weird edges breaking for certain things we were doing a lot of that other customers weren't all got smoothed out really quick by them but god damn this was so much work and it was so much fun and none of our users could possibly have really noticed the difference until it was done and then it was shipped and then after is when we really got to start doing the fun The reason I did this overhaul wasn't because I was tired of maintaining the custom sync code, although I was.
It wasn't because the database costs for how I was doing things were absurd, because they were. It was because at this point in time, we had scaled up the team a bit. I had pulled Julius full time.
I had Mark constantly putting up the fires I was creating. And I was the only person who could touch. the back end code for the database stuff because it was the right ish platform for what we needed at the time.
But I was the only person who understood it. And as a result, I was blocking my team constantly and it was really fragile and breaking all the time to the move to convex fixed that and allowed me to not be able to code for a few months because of my hand and still continue iterating on top of T3 chat and shipping and improving the 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 feeling seeing and experiencing the increased movement that i and my teammates get on the product side once this stuff lands the thing that was exciting about this overhaul was watching how many more prs mark and julius were putting up and landing as a result of how much easier they could move around in the code base hopefully you can kind of see where we're going now 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. And it was constantly causing friction. It was getting in the way of my team.
It just wasn't good. I was an incredibly effective chef when it came to cooking slop. Even at the time, I wouldn't have defended how it was implemented.
I would just defend why it was implemented. And this is why, as chat pointed out, I had the five videos of me switching the database in T3 chat. It was a great opportunity for me to try out different things, learn stuff, and build a scalable platform at an absurd pace while also having to run my channel and my company all at the same time.
And it was such a fun era. I loved every moment of it. But the important thing to 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.
Sonnet 4 .5 slop was blocking Opus 5 .5. You see where we're going now. all of the time and effort I was spending on the right side of this line, doing this platform work, setting up my team and setting up myself to be more successful building.
That was always one of the things I loved doing, but I loved it both because it's fun, but also because I would see the impact it had on the other side. It would take a long time to see that impact. It would take even longer to do the changes in the first place.
But it was very satisfying work that really made me feel like an engineer. This work has gotten 10 times more important than it's ever been. I remember one of the first cool conversations I ever had where I felt like I should not be allowed to do this was when I was tweeting back when I had like 50 followers about TypeScript stuff we were doing at Twitch because our TypeScript times for checks had gotten to like 15 to 20 minutes.
And our like... npm run dev command time was it like the three to five minute mark just to start working on a project at a given time like on a random day and i was so desperate to fix this that i just randomly replied to a certain person on the typescript team daniel rosenwasser on twitter asking for some info on some stuff he was talking about on twitter about performance for typescript he dm me we chatted And I got to intro him to the browser clients team and somehow be the one to broker this meeting between the platform team at Twitch and the TypeScript team at TypeScript.
When I was 21 years old and felt like I didn't belong anywhere yet, that was the like, oh shit, all of these 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 changed. And to this day, like when I just put out TS Rust, the TypeScript team hit me up and we did a great talk. And I got to chat with Helzberg, the creator of TypeScript, about the language that changed my life.
And it's just so fucking cool. And this is the stuff I love. And the reason I bring up the TS Rust thing is because all of the shit that got me where I am now and that I loved then matters more and is making more cool opportunities.
The same mindset that led to me replying to Rosenwasser on Twitter. to get this meeting between the browser clients team at Twitch and the TypeScript team is the mindset that led to me building TS Rust. And the best way I can describe this mindset is gardening.
I use gardening as the analogy here because I want to emphasize that 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 have the right monitoring and everything else in place. that the likelihood the plant grows successfully is as high as possible, and the likelihood that you can recover it before it becomes a weed and infects your garden is as high as possible too.
I know this because I was already doing it. The time I was spending trying to improve the type checks at Twitch were to make it so everybody could work on the code base more easily, and check things faster, work on things more confidently, and just grow. And just a few months ago when I was working on T3 code, i was seeing how much time was spent in rci and how much ram and cpu was spent on my machines type checking the code even with the typescript go rewrite t3 code is just a massive project and it took a lot of cpu time to check previously when you end up in those scenarios the amount of effort it would take to make things better was so high and the amount of value that people would get was so low that it was rarely worth it for example when i was at twitch working on this giant repo We could have rewritten TypeScript in Go then.
We had a bunch of incredible Go engineers at Twitch. We absolutely could have dedicated like 20 people to rewriting TypeScript in Go before the TypeScript team even thought to do it. But that would have been an absurd undertaking that would not have been worth our effort or time to unblock a measly 600 to 800 front -end engineers from having to wait as long for their 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... was just like, it was really difficult, but we still would do it.
I remember one of the changes we made in order to like more heavily adopt hooks in the code base, we had to move from Apollo GraphQL 2 to 3 on the client. This resulted in a bunch of legacy stuff that Apollo had removed that we were using heavily across Twitch. So what we ended up doing is we made one shared PR with the move to Apollo 3.
We took every single TypeScript file that was broken as a result, put them in a Google Sheet. and then would go through the sheet and had volunteers take chunks of this sheet that was sorted alphabetically and assign them to ourselves and it was our job to manually go through each of these files and fix the type errors and then test and make sure that the code actually worked this was for thousands of files across this gigantic code base we literally had an excel spreadsheet well google sheet that we would share to figure out who owned what to get all of this through because that's what it took to make a change to our GraphQL client connection.
This is the one package that lets us define the GraphQL syntax 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 fucking prompt now.
And this is what's so cool. Historically, 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 companies that were architected correctly to split between platforms and product. There's a lot of companies that are fucked right now because they didn't separate product and platforms properly. And now the product engines are stuck doing platform work.
They don't understand well enough and they just cannot keep up or move fast enough. But the calculus is very different now. i've been hinting at the fact that agents make it way easier to do these types of changes to make these types of wins that's just one side of the equation the other side is arguably even more interesting all of the things i've talked about here that were blocking me or slowing me and my teammates down were annoying but they would like maybe like 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 five minutes to spin up the dev server to even check if the code works or not, your agent is going to be blocked insanely deeply by that.
Hell, if you're using five -minute TTLs, you're also going to be wasting a ton of tokens because you're not going to be hitting cache reads when you wait that long to validate a change. If your CI is too slow or it takes too much RAM and CPU to use, you become heavily limited by how much you can parallelize the work. if your release pipeline is too slow and you're scared of doing a release because it might take too long or worse there's something bad in it then the next release to fix it takes even longer then you're not going to be hitting merge as much the constant maintenance of the platform has never been more important because not doing this blocks your agents even harder than it blocked us and all the work that you can possibly do to trim these pieces of friction to kill these weeds, to get these problems out of your fucking garden is so important.
And there's one really big reason why that I've been dancing around. Slop 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.
This is the problem that is destroying so many things. And this is what our job actually is going to be. We have to spend a ton of time making sure we're putting the right fertilizer in the garden.
We have to spend a lot of time making sure that once the plants start to sprout, that we put the right post up and wrap the right material around the plant so that it keeps growing vertically and doesn't fall over and break in a terrible way. And you have to be removing the weeds as soon as you notice them appearing. Just to give an 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 code base the more i realized how many of these tests are useless and more importantly how much the useless tests multiply and result in more and more unnecessary edge cases being tested for no good reason whatsoever and that's why i was able to delete 250 000 lines of code from the code base 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 of gardening this is the type of thing that is our job now i just got a fantastic follow -up question how are we preventing it from happening again by monitoring it we can put a lot of things and we made some guidance changes to the repo to the agents md and things like that to steer agents away from making bad tests But even just deleting all of the slop, killing all the weeds is enough to help a lot.
But there were still bad tests popping up here and there. So whenever one of us 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 give us to go to the root of the problem, whatever stem this weed grew from and kill that. And this is just like...
One of the types of examples of the gardening I'm talking about. If we scroll through the PR, we'll see a few others. This one in particular is one I'm really fond of.
I was getting tired of the performance regressions I was seeing in the wire protocol for how we get data from your server on your machine where everything is running over to the client on your phone or the computer that has all of the data that you're actually interfacing with. I had put a ton of time into making this as efficient as possible so that it would be as little as like, five kilobytes to load even a big thread i had put a ton of work into this but it kept regressing after a week of improving the performance here subtle small prs didn't seem like they were going to cause problems here did so i built the 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 cloud 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 every PR and flag a bunch of big red X's when anything caused a meaningful regression whatsoever.
This worked incredibly well for a bunch of reasons. It puts feedback in the PR that a babysitting agent will notice and address. It gives the developers and the reviewers clear feedback on whether or not this is getting regressed or not.
And if these metrics we care about are 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 go back to the garden analogy, this is like the wood stake you put in next to a plant. So the plant will grow in that direction.
I put a wood stake in with this action. This CI tool, this one additional check that actually takes like almost no time. I think it takes under 45 seconds to run.
It might be 30. This one small check I added to our CI has been an incredibly useful wooden post in the garden. guiding the plants to grow up the right way and away from the weeds and the other things i don't want them near in the garden do you know how much fun it was to do this work by the way i know i'm a bit of a nerd about this protocol stuff but i really like representations of data and finding the right set of data to send to and from like different platforms product feature whatever it's just so fun and that side of my brain has never been so valuable the vast majority of my work for t3 chat after like month two was unblocking my team and by improving the platform so everyone else could build the features that our users needed.
Now I'm doing that with and for agents. I am building up the best possible code base to contribute to that might have some parts that are tedious. It might have some checks that are strict, but it is the best goddamn garden I've ever been lucky enough to see, much less work in.
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 against. And if you don't think this is engineering, I don't know if you ever were an engineer. Because I've never felt more like I was building a platform than I do today.
And it's just so goddamn fun. Even if you don't love this type of maintenance and platform work, i think you'll love what happens on the other side because that was the magic that made me go from enjoying doing this for the sake of doing it to almost feeling bad for any second i'm not spending doing this because i've seen how much impact it has this is pr's merged per day over time since t3 code started and my face is covering these vertical lines because of how vertical they are 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. This is what happens when you make a good garden. Don't tell me fucking potato stumbled on the same goddamn analogy as me.
Why do I learn this now? I didn't even see this post. I would have liked it if I saw it.
Thank you, chat. Goddamn. Apparently.
I'm not as unique as I like to think. I don't think I'm that unique, but Lauren and I are too aligned recently. It's dangerous.
Anyways, she seems to fully agree. Every team needs a gardener. Someone quietly watching the stream of PRs flowing in the code base, noticing the smells.
The third is record this week. The lint suppression's creeping like ivy across your carefully planted garden. Steady hand tending the weeds that would engulf it in slop if left unchecked.
Yep. If I go any longer, this video is going to literally go on forever, so I think I am going to stop it here. Let me know if you enjoyed this, and if you can, fight the obnoxious commenters, because I know they're going to be obnoxious for this one.
And if you did like this enough, let me know if I should do more things like this. because I would love to talk more about the techniques I've been using to maintain my garden and make my code bases pleasant to work in. Some of them are working great.
Some of them I don't know if they are yet or not, but it's just a really fun time to be trying to build these ways. I've never enjoyed my work more than I do today, and I hope some of what I shared here will help you enjoy 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 now see the magic where you might have missed it before, then this was worth all the shitty comments I'm about to see. Until next time, peace nerds.
The Hook
The bait, then the rug-pull.
The opening is a dare: change how you code or lose the job within two years, and accept that you are no longer an engineer but a gardener. What follows is less a hot take than a long origin story, built to prove that the boring platform work engineers used to skip is now the whole job.
Frameworks
Named ideas worth stealing.
32:38model
Engineer as Gardener
Fertilizer: docs, examples and guidance files that feed good code
Stakes: CI checks and metrics that tell code which way to grow
Weeding: delete slop and low-signal code as soon as it appears
Root-cause: trace each weed to the stem it grew from and kill that
You no longer grow the code. You build the environment so agent-written code grows in the right direction and bad growth is caught before it spreads.
Steal forframing how a team reviews and maintains agent-written code
22:05concept
Product and Platform Pendulum
Ship features until the work gets harder than it should be, then tap out, improve the platform, and return to product. Treat them as one job, not two roles.
Steal fordeciding when to stop building features and fix tooling
14:00concept
Fix the cause, not the symptom
Every bad PR is a signal that docs, examples or tooling misled the author. Fix those so the next person, or agent, cannot make the same mistake.
Steal forcode review policy for agent-generated PRs
36:19list
Friction multiplies for agents
Slow dev server start blocks every validation step
Long waits miss prompt-cache TTLs and burn tokens
Heavy CI limits how many agents can run in parallel
Slow or risky releases reduce how often you merge
Friction that cost humans a few PRs a week stalls agents completely, so platform speed now caps total output.
Steal forauditing a repo before scaling up agent usage
CTA Breakdown
How they asked for the click.
VERBAL ASK
44:25subscribe
“Let me know if you enjoyed this... let me know if I should do more things like this, because I would love to talk more about the techniques I've been using to maintain my garden.”
Soft comment ask framed as a request for a follow-up video on specific gardening techniques; no product pitch beyond the earlier sponsor.
Add Modern Creator as a preferred source and Google shows you more of our breakdowns in Search, Top Stories, and AI Overviews. It only changes what you see, and you can undo it in your Google settings anytime.
Add to Preferred SourcesOpens your Google source preferences with us pre-loaded. Tick the box and you're done.
Theo spends forty minutes inside Anthropic's own Fable 5.1 prompting guide, rebuilding his habits around effort levels, finishing the whole task, and trusting the model's defaults instead of babysitting them.
A developer who shipped 89 merged PRs in 24 hours breaks down Claude Fable 5.1's pricing, benchmarks and real-world coding behavior against Fable 5 and GPT-5.6 Sol.
Boris Cherny said coding is solved. Matt Pocock called it VC-funded bullshit. Theo argues they're both right, because they're using the word coding to mean two different things.
How a three-model review council, a score out of 10, and 18 hours of agent runtime turned a mid-looking open source app into one that beats Claude Code and Codex on design.