Skip to content
Linkdrop
Links

MEGA.dev live Q&A with Theo Browne

Theo Browne answers audience questions about working with coding agents, finishing projects, and sharing agent rules and skills across teams. A MEGA.dev host moderates the session.

videoTheo Browne · hq.mega.dev · Saved Nov 19, 2026

mega course, coding agents, agent skills, software maintainability, claude code

Transcript of the recorded MEGA.dev live Q&A with Theo Browne (Friday, Oct 30 · 89 minutes), Theo Browne. The recording plays in MEGA Student HQ (needs a login).

0:01 Speaker 0: Hi, everyone.

0:04 Speaker 0: The waiting room is shrinking.

0:07 Speaker 0: Hi to you all.

0:10 Speaker 0: Yeah, I can see you guys. Great. Thank you for, mm, having your cameras on. It's always cool to be able to see, uh, everyone, uh, in the meeting.

0:21 Speaker 0: Uh, so welcome to the first, uh, mega, uh, live session today, uh, with, uh, author Theo. Hi, Theo.

0:30 Speaker 1: Howdy, howdy.

0:31 Speaker 0: Um, uh, so, uh, just for your information, guys, uh, today this session will last about 90 minutes, and it's a Q&A format. So, uh, as you hopefully all, uh, have seen and were able to add your questions, uh, right there where, uh, you, you can see on Theo's screen at the Mega Dev channel, uh, you were able to leave questions and vote for the questions that you believe are, uh, most important to be answered today, and Theo will try to tackle as many of them as possible. Uh, I'm not sure, Theo, if, if it's possible to handle all of them, but-

1:07 Speaker 1: Somebody just called out in chat, I think this might be important. Uh, the link that they had in their system for the invite was wrong, and that might be why we had fewer people in the waiting room than we expected.

1:18 Speaker 0: Oh, is that so? Uh, Martina, check, check, uh, check-

1:21 Speaker 2: Yeah.

1:21 Speaker 0: -what might have gone wrong and, uh, try to fix it as, as soon as possible, please.

1:27 Speaker 0: Um, so we'll wait maybe a bit, a bit more to see if more people join. And in case, uh, Theo will be able to handle all those questions, we will be taking questions in from, from here, from chat. Um, but I've seen there were over 20 questions left on Discord, so there's a lot to go through.

1:46 Speaker 0: Um, and in case any questions will be left unanswered, we will do our best to answer them, uh, sort of, uh, in the following days, uh, with Theo's help and see, uh, make sure to, you know, not leave, uh, any question without any sort of reaction on, on our side.

2:07 Speaker 0: So as soon, I guess, we'll sure that-- we'll be sure that, uh, people know how to-- all the people know how to join, we'll be able to just, um, start. Uh, Martina, are you with us? Can you tell us if the,

2:21 Speaker 0: uh-

2:22 Speaker 2: Uh, yeah, and I texted on general again, so maybe, uh, yeah, I think that people are still, uh, joining, so please maybe,

2:31 Speaker 2: uh, wait, uh, uh,

2:34 Speaker 2: a second.

2:35 Speaker 0: Oh, we have, uh, I can see that we, we have more people coming in, about 400 already. That's very cool.

2:44 Speaker 3: I think that someone just posted the wrong link on the chat, but it's not our link. It's not our, like... Yeah, so we'll, we'll, we'll do that on Discord, and I think that we can start because it's not, uh, that we posted it, but, uh, most of people are here.

3:01 Speaker 0: Okay, cool. Then Theo, over to you.

3:06 Speaker 1: Thank you very much. One second, some water, and then we get started.

3:11 Speaker 1: Awesome.

3:12 Speaker 1: This should be fun. I don't get a lot of opportunities to just, like, answer questions and talk about these things. I do see chat noticing a very cool thing that just happened. I got the text from Anthropic this morning actually that the five-hour limits on the 200 dollar plans are now gone, which is huge. So, uh, for those of us who have been token maxing recently, uh, hurrah. That is a, a very, very nice change that is going to probably cost me a lot of money. But yeah, welcome all. It is time to talk about how to take as much advantage of those tokens as you possibly can at your work. I know that my section was mostly focused on, like, the, like, I don't want to say, like, the early stuff because it goes really deep in a way that normally the word early doesn't imply, but I wanted to focus on, like, deeply understanding how the agents work, how they see things, and how to, like, build your own loop in your day-to-day work around working with your agents to, like, constantly be improving your work with them, the way that they work, the way they see the world, the way that they understand your code base, and, like, build this loop into your day-to-day work.

And it seems like people are, uh, resonating with that, which has been really cool to see. So, let's start by diving into the questions that have come out as a result of all of this. Should be a fun set of things. We'll start with the top one here. This is, uh, one that I've been seeing a lot. The general question is, "Agents let me build fast, but I keep starting new stuff before finishing the last thing." Thank you, Diogo, or Diego, for asking this. He works in IT at a trucking company in Mexico, and he's been building an ops platform with agents.

4:46 Speaker 1: Uh, da, da, da, da, da. Orchestrator plane, airplanes and delegates, da, da, da. Honestly, it's not working yet the way he wants it to. Building's the hard part, you can get a lot done fast. Hasn't really landed with all the people who are supposed to use it. Think part is that I don't have that much experience. You always feel like you need to think way ahead so things scale properly later.

5:06 Speaker 1: And I end up implementing the next thing before I've actually set the last one is done. The,

5:13 Speaker 1: the idea of done is a very complex thing in software, and this is not necessarily, like, a new thing with AI. It's just that you can be doing more work at the same time, so having a lot of this work in this 90% complete state is, it is common. What I try to do when I work on things is I come up with, like, I always start with the problem I'm trying to solve. Like, what is the specific thing that I want this to do? And then I will come up with, in my head or even just talking with an agent, what does it look like to build that?

5:46 Speaker 1: And then I trim. I see, I, I now know, like, this is what would complete my goal.

5:53 Speaker 1: What's the smallest version of the thing that could complete my goal?

5:57 Speaker 1: And then I do that, and then I look at it, and I, I think about, like, what is missing? What will I be frustrated with if this goes out this way?

6:07 Speaker 1: And if nothing is severe enough, I'll just ship it like that, wait till I have feedback, and then adjust accordingly. Generally, it's easier to add more small pieces to a thing than it is to take away. So always trying to start with the smallest possible scope and then scoping up as needs demand it tends to be the best way to get through this, like,

6:27 Speaker 1: like, I don't know, but like to get through this hurdle of the, the inherent trap to just doing a new thing over and over again. The other thing I know that, like, I talk about this a bit in my lessons, but, uh, actually I don't think I'll be able to screen share from here easily, but in T3 code, one of the things I've done is I've made the sidebar act more like an inbox. So things stay in the sidebar until you're done with them. And if you get in the mindset of trying to get rid of your, like, threads as quickly as possible, like get the thing merged so you can get the thread gone, it becomes a lot easier to actually complete work.

6:59 Speaker 1: Hopefully that was a good answer.

7:02 Speaker 1: I'll use my Theo sticker to mark things as done.

7:04 Speaker 0: Theo, when going through those questions, I think it's, uh, like, uh, someone in the chat suggested maybe go through the ones that have most upvotes first.

7:13 Speaker 1: I can do that. I was going to go through the top, but let's change the sort order to...

7:19 Speaker 1: Options are recently active or date posted. Thanks, Discord, for-

7:23 Speaker 0: Yeah. [laughs]

7:23 Speaker 1: making it so easy for me.

7:25 Speaker 0: That doesn't help.

7:27 Speaker 1: Not in the slightest, but I'll scroll around and hit the biggest ones quick.

7:32 Speaker 1: So I need to, uh,

7:34 Speaker 1: remote feed my cats so they stop screaming at my door.

7:38 Speaker 1: Somebody can make an AI that keeps my cats from being annoying when I'm in meetings, I will pay you a lot of money.

7:45 Speaker 1: Cool. So the next one we have here is, how do you centralize rules and skills across platforms to be shared with teams?

7:54 Speaker 1: With so many tools, harnesses, and workflows out there today, how can we centrally manage rules and skills that apply only to me versus my team or whole org across all platforms uniformly?

8:05 Speaker 1: There's a lot of different ways to handle this, but I find that, like,

8:10 Speaker 1: people are going to such a, a far extreme here of

8:15 Speaker 1: there's too much, so I want my company to manage everything, or, or the opposite of, like, my employees aren't good enough to do this themselves, so I want to manage it all for them.

8:25 Speaker 1: I think back to, like, my time in enterprise and think about, like, the Chrome-managed instance that I have at Amazon, where, like, Chrome control was controlled by the, like, Amazon provisioning, and how miserable that made me. And then I think to my other jobs I had and how not a single one ever tried to take control of my VS Code. There might be some company-recommended extensions. Like, there's a feature in VS Code where when you open up a repo, it recommends the extensions that that repository thinks would be beneficial when you're working in that project in VS Code.

8:57 Speaker 1: I think that's the, the angle to approach these things with. The,

9:04 Speaker 1: the tools that we use have good solutions built in for a lot of this. Like, you can put skills in a repo, and then those skills will be available to anybody working in that project.

9:15 Speaker 1: You can...

9:17 Speaker 1: You have, like, the AgentMD and CloudMD that are project level, and you have global ones too. I think anything that isn't project-specific probably doesn't belong in a company-wide config. Like, I wouldn't want a new, like, an employee at my company who's starting a new project to be forced to use all of the company's skills and plug-ins and all of those things.

9:40 Speaker 1: I would want to make the case to my employees that this set of things is good and the right one to use, and, like, they should install this plug-in or whatever. But I would want that to be a conversation, not a policy. And I find a lot of companies are struggling to explain this information to their employees or even understand it at the higher levels themselves. So they're looking for a button they can click that just does it for them.

10:02 Speaker 1: There isn't one. This is like, how do we make sure everybody at the company uses the right programming language?

10:07 Speaker 1: You make sure that that's the best language for them to use. Like, you just gotta to work to make sure that the happy path is the path you want people taking.

10:20 Speaker 1: Bouncing, I only have one screen, so bouncing between Discord and the chat and Zoom is going to be a bit tough, but I'll do my best to stay on top of that.

10:28 Speaker 1: Uh,

10:31 Speaker 1: I see a lot of people recommending, like, rule sync tools and things like that.

10:35 Speaker 1: I,

10:37 Speaker 1: I still think your best bet is to simply, like, put the things that matter for the project in the repo and maybe add some, like, guards here and there if specific things are missing. But

10:48 Speaker 1: I wouldn't worry too much about this. I think this is one of those, like, weird early growing pains. Also, like, between Claude, Cursor, GrokBot, Copilot, and whatever else you want, most of these use the same syntax and structure for your rules and skills. So it's not that hard to, like, set things up in two different folders in your repo and have them be persistent for everyone. Also, rules, I think, like, the concept of, like, this is a hard rule that an agent checks for, that belongs in code review more than it belongs in your day-to-day loop. So yeah, hopefully this is a adequate answer for how I think about these things. Let me check the chat here and see how people feel.

11:33 Speaker 1: Oh, you're complaining they can't submit questions anymore, but doesn't seem like too, too much else I can jump on there. So let's hop to another high-ranked one. Here we are. When agents write the code in minutes, what actually replaces traditional QA in your workflow?

11:50 Speaker 1: The... I've only had, like, true traditional QA in, like, a very small percentage of the roles that I've been lucky enough to work.

12:02 Speaker 1: And when I had real dedicated QA, it was awesome, and I got really close with that QA. And what I learned was that, like-

12:11 Speaker 1: The QA is most useful when you have a rough idea of where the edges are in what you build. And the more you build around and plan around those edges, the more you set QA up for success when you, like, give them the document that is, "Here is what we did. Here is where we perceive, like, risk and edge cases and failure points. I would like for you to try these things in these areas and see where it goes."

12:37 Speaker 1: Once you figure that out, you can apply the same thing to your agents. And I've been doing this a lot recently, like setting up some, like, seemingly crazy ways of verifying work. Like, this, this is a really silly example, but it went better than expected. I wanted to try and make a better benchmark for skateboarding with models, because I've finally got to the point now with the Gemini releases recently that my skateboard trick naming bench is saturated, so I figured why not make a skateboard game-making bench? And the way I set this up to see if Opus could make a full skateboarding game is I recorded myself playing a skateboarding game I like. I recorded the control inputs, and I controlled the screen, or recorded the screen.

I then gave both of these to Opus and said, "Here is an end state that I like. This is a game that already exists. I want you to build a game that takes these control inputs and does roughly the same thing. Then I want you to take videos of it, show them to a panel of agents of the original video and mine, and then vote on which one is better and better represents the control inputs, and then keep looping until eventually it thinks ours is better than the original." This is not a traditional QA process at all, and this is not exactly what I think you should do in your work, but it's meant to represent a creative way to validate the things that are being done.

13:59 Speaker 1: I also think validating every single change before it lands is just going to be a, an insane fool's errand at this point. Like, it's a lot better to have a system where you can ship the code 98% sure it's good, and then check 20 things at once that are all in that rough state, because then you'll find the edges, fix them, and then do the release.

14:20 Speaker 1: That has been our strategy with T3 code, for example. We have the nightly builds where we can land things a little more aggressively and then test the hell out of them before we hit the, like, go to stable button. And it's a small thing, but we set up the stable releases, so instead of just cutting whatever the latest commit is, it cuts whatever the latest nightly was as a stable release. So we can still be landing code. We don't have to, like, slow down our velocity when we are, like, cutting a stable release like we had to in the past. Now we just, when we are confident enough in a given release that we're using in nightly, we hit the button and it goes out to stable.

So really thinking through the, the layers where you do your validation verification and making it so that it's not a huge burden per change, rather it is a small burden per set, tends to make it a lot easier to deal with.

15:12 Speaker 1: Next question. Where is engineering headed if models keep improving at this year's pace?

15:20 Speaker 1: Um, going to be real, I think the pace is going to go up at this point. I used to think it was going to curve down. I don't anymore.

15:28 Speaker 1: I,

15:29 Speaker 1: I try to not over-predict the future because everything just changes so fast. And what I've found so far is instead of the models getting better, meaning engineers are less important, I've found that they've become more important because without, like, the, the insight, the diligence, the planning, the understanding of systems and all these pieces, you will die under the weight of the slop. I do think the role of, like, the programmer whose job is primarily to, like, sit there and enter letters on a keyboard to turn the ticket into code to fix a small issue, like, that's over. But engineers, as the people who maintain the repository to make sure humans can get their code in faster, that role has never been stronger.

Like, I spend the majority of my eng time right now polishing the repositories I work in to make it so the people contributing with agents are less likely to run into holes and step on each other's toes when they're working and all those types of things. I think I did a good job focusing in on these things during my section of the course, because I really want to emphasize this idea that, like, we're kind of now in the role of, like, gardening, where we have to set up the garden for success. We can't make the plant grow faster, but we can make it so the plant doesn't die as it grows and that it's healthy as those things happen.

16:54 Speaker 1: I've had to do this for so much of my career. Like, a lot of my role at Twitch was helping maintain the gigantic 800-plus contributor repo and making sure it doesn't collapse under the hundreds of PRs that were being filed a day. And that is the, the window of my career that I feel most reminiscent in the way I do work today, where I have a giant open source project and I spend much more of my time making sure the repo is easy for agents to contribute to successfully than I spend actually implementing things in it myself.

17:25 Speaker 1: Hopefully that was a adequate answer for this. I don't really know how to

17:30 Speaker 1: answer the, like, what is software worth long-term side. Like, these things just change so frequently. I think a lot more about what I'm building and how I build, and there's so much going on there that I'm excited about that it's maintained my, like, focus for a while now.

17:43 Speaker 1: Cool.

17:46 Speaker 1: How do you manage your compute fleet in subscriptions? He, like, or, uh, Shivs wanted to know more about my setup and how I manage across projects along with multiple subscriptions. He currently has a few 200-dollar subs using a load balancer, would be curious to hear about my own setup.

18:01 Speaker 1: For those who are familiar, the compute fleet is referring to the way I work with multiple computers at the same time.

18:08 Speaker 1: I have, I think, 14 machines right now that I am bouncing between at any given time for different types of work. I'm starting to centralize, so there's just, like, the one or two main drivers, and the other machines are controlled by those one or two.

18:22 Speaker 1: The managing of the fleet when you have, like, good AG- ADEs and, like, good tooling isn't too, too tough. I don't know what this is like in other tools, because last time I tried it was really rough. But in T3 code, you just click add, and then the machine is now part of your fleet, and it's very easy to control and send things to. The subs is the hard part though, because most of the subscriptions, in particular the Claude ones, the auth expires either every week or every month depending on your setup, and you have to go re-authenticate it. So connecting to 12 different machines, to SSH into them, to re-auth all of your accounts if you have multiple of them is just obnoxious.

So I highly, highly recommend centralizing that on something else.

18:59 Speaker 1: I see the dashboard that Justin shared here. I have a whole video about my token maxing setup where I talk more in depth about that. But I also have, if I hop to my GitHub for a sec, I have a gist that I wrote that I just linked here that has all of the details on how I do this. And you can actually just take this gist and paste it to your agent and say, "I want to have a setup similar to Theo's here. What do I do?" And it will copy it pretty directly.

19:28 Speaker 1: I don't know how long this era of, like, stacking subscriptions is going to last for, but, uh, it's one of those rare opportunities where the little guys who are willing to put the time in to do this can benefit really greatly. It's like a, a very unfair lever that we have over big companies, where, like, the big companies all have these enterprise deals where they're not going to, like, allow employees to use the subscriptions because that's the deal they signed with Anthropic. There is no terms of service reasons why you can't do this or, like, have multiple accounts. As long as you make sure that proxy is routing to Claude Code, as far as the TOS is concerned, you're good to go.

Obviously, don't hold me accountable if you get accounts banned.

20:05 Speaker 1: It's-- A Claude account's a Claude account. If it gets banned, I just replace it. But obviously, use at your own risk. But if you are at a company that doesn't have a strict policy around how to do accounts, definitely do this. And if you're a boss, a CEO, a exec, or in that level, and there is no company-level reason why your employees can't have personal subscriptions that you just cover for them, you should absolutely do that. I know a lot of companies that just, like, cover their employees, like, like 100 to 500-person companies that just let companies expense their $200 subs, as many as they need. So yeah, take advantage of this rare opportunity while we have it.

20:45 Speaker 1: Any questions about that part from the chat?

20:51 Speaker 1: Bunch of screenshots.

20:57 Speaker 1: And thank you guys for sharing the gist link. I'll drop that in chat as well.

21:01 Speaker 1: Let's hop to next. Ooh, work trees and PR workflow.

21:06 Speaker 1: How do you set up a structure for your work trees, branches, and PRs so you can have multiple agents working in the same project at the same time?

21:13 Speaker 1: I put so much thought into this back in the day. I remember, like, working on alternatives to GitHub and Git itself, trying to find better ways to manage this. We used to have lots of clones of the same project, and to this day, like, my T3 code instances on this particular computer, my laptop, there are four of them, and they're labeled T3 code. Actually, I think the first one's code things. That's what I first called T3 code. Then I have T3 code dash 1, T3 code dash 2, and T3 code dash 3. I think that most of my work happens in the dash 3, but I'm not sure because I haven't thought about any of this in so, so long.

I let my tools and my agents manage all of this for me now. In T3 code, we have work trees built in. They work pretty well. There are lots of different options for how to do and manage that with different tooling.

22:03 Speaker 1: Some people really like having a different cloud instance per thread. I get it. I think that's fine.

22:09 Speaker 1: What I do, again, is just in T3 code, I use the default to create new work tree per thread, and the work trees just spawn when I make the thread. There's a lot of things that can make this frustrating and slow, but a lot of that is, like, repo-specific. Like, I noticed in T3 code that spinning up a new, a work tree, not, not like T3 code, like the app as a user, but T3 code, the repo as a contributor, that new work trees were taking, on macOS, up to, like, 30 seconds to a minute to spin up, create the files, do the Pnpm install, and then get moving. So I put a lot of time into our specific repo to edit the tooling and customize things to trim it down.

So my workflow here is usually

22:51 Speaker 1: set up your tools so that a new work tree is created upon thread creation,

22:55 Speaker 1: and then figure out what the bottlenecks from there are. Like, are your environment variables missing when you make the new work tree? Maybe the database primitive that you use doesn't work well when you have multiple projects trying to connect to it at once, or multiple projects trying to run it at once. Maybe Docker helps a lot in this isolated workflow. Maybe Docker gets in the way in this workflow. Figuring out what those things are and then asking your agent to find ways to improve the environment, not just for you, but for everyone, and then landing those changes in the repo so the next time someone else spins up a work tree, their experience is better too.

Most of these tools, I know Cursor has this, and obviously, of course, T3 Code has this, have the ability to, in the repo, define something that runs upon work tree creation. So in T3 Code, whenever you make a work tree, we have a script that runs that manages your environment variables. It manages the, like, Pnpm install to get all your node modules and everything, and it's set to run async, so it doesn't block the agent from starting to explore and ask questions and work on the code base. It doesn't block until the Pnpm install is done. It just moves. So again, this is one of those, like, move things around until it feels right type things.

24:03 Speaker 1: Just throw them in work trees, see where the holes are, see where the flaws in the workflow are, see what problems you're still running into, and then work backwards from there.

24:17 Speaker 1: Any questions on that part? Oh, thank you, Thomas.

24:23 Speaker 1: Uh, thoughts on trunk-based dev was the follow-up from that. Uh,

24:29 Speaker 1: I don't think in these things. I think about how I mer- how I can get the code merged, and that, that is all that matters to me at this point, is like, what does it take to get the change landed? I don't think about the different mechanisms or, like, complex systems for thinking about the different trees, especially when you're working on code bases with hundreds of people in them. The best system is the one that the most people understand, that they have the fewest questions with or about and problems with. It might not be everyone's favorite. In fact, I think the idea of, like, building your code base around your favorite tools and preferences is over, over now.

25:06 Speaker 1: So yeah, just build in ways that unblock you the best.

25:12 Speaker 1: Uh, I was about to go back to this one, but I saw a good question from FunnyOfA. One of my employees, Gabriel, is in chat. Thank you, Gabriel, for coming by. He asked, "How do you make your workflow stay relevant? There's a lot of talk about how tooling changes constantly and how your needs to constantly benchmark your skills, MCPs, and overall tooling, but how do you benchmark your own workflow?" In other words, how do you make sure that you are setting the agent up for success from the prompt onwards, and that there are cues that you pay attention to so that you might know that maybe your workflow is not the right one, you need to change it?

25:46 Speaker 1: This is another one of those, like, move things around until it feels right type things, where you gotta,

25:52 Speaker 1: you gotta start building an intuition for what is and isn't working. Some of this will come from your own day-to-day work in the projects that you work in. Some of this will come from hanging out in communities where others are doing things, or watching content from creators who are building with these things, or talking to your peers at lunch and dinner and pairing. I've actually been surprised at how much less pair programming I see nowadays when I feel like it's more valuable than ever, because, like, workflow expansion and collaboration is so valuable now. The amount that I learn just by watching Julius for 10 minutes as he tries to land PRs is bigger than what I would learn any amount of time spent in, like, the Anthropic documentation.

Seeing how others use these things and understanding, like, you're not gonna copy your coworker's exact workflow, but there are ideas in there that you can learn from. I try really hard in my videos to, like, steer in this way. I went months without putting up a skills repo, and I only recently caved because I just, I wanted a place to reference them from, not because I want people to install them. I actually went out of my way to not set up a way to install my skills in my repo, because it's meant to be a reference point. It's meant to show some of the ideas of how I work right now so that others can be inspired by that and take parts of those ideas into their own workflows.

The big things to look out for are, like, things being slow or frustrating

27:18 Speaker 1: in ways that, like, are, are blocking you. The, the biggest thing we all have to be working to avoid right now is burnout, preventing the constant signals from all of our tools lighting up with the slot machine nature of how they're designed, trying to take our attention to a million different places at once. And then the worst part, the, the feeling that I hate more than anything right now is I put a lot of work into, like, some changes. I spend days back and forth with my agent. It finally puts up a pull request for these changes. I'm like, "Oh, yay. Finally, this is ready for me to, like, go try." So I do what you are probably all used to doing for things like this.

I find the PR on GitHub. I find the branch. I pull down the branch on my machine. I install the dependencies. I set up the environment. I realize that there's some migration I didn't run that I have to, or the seeded data is bad, so I clean all that up. Finally, after a bit of back and forth, get it running. Maybe it took 15, 20 minutes to, like, get the changes on my machine so I could play with them and see how they work. And then I open it, and the changes don't even launch. Like, like, the, the code is just broken entirely. I have spent 20 minutes getting it so I can check these changes, and then I check them, like, "Oh, my time was wasted.

I shouldn't even be here yet. The agent needs to fix all this." Those moments burn me out so fast that, like, if I have three of those in a row, then I'm gonna code half as much that day, because it's just frustrating for me. I know not everybody has such weak will with their motivation in this way like I do, but I try my hardest to, to avoid those moments. And for me, like, workflow customization isn't just like, how do I make sure the agent can unblock itself in as few tokens as possible? It's more, like, I'm always willing to trade token burn for my own mental health and sanity. So my workflow is largely around, like, how do I make it so by the time this thread is in my view again, by the time this PR is in my inbox again, that the likelihood it pisses me off is as low as possible?

How do I orchestrate my agents, my code bases, and my life to minimize the likelihood I get pissed off when I'm working? And as long as you are working towards that, there may be some differences. Like, I might have a less efficient workflow than you. I might waste more tokens than you. I might have my agents go through crazy verification loops that are entirely unnecessary for a thing that I could have checked in five minutes. But I get to code for 12 hours a day and smile the whole time I'm doing it. And that's what I have always optimized for, because I'm ADHD-riddled and love programming, so I want to have as much fun as possible when I work.

As long as you're having fun with your workflow, it's a good workflow. And if your workflow is not fun or you find yourself spending more time in things that frustrate you, that is the best possible sign it's time to adjust your workflow. And if you see other people doing things that look fun, try them. And if you see other people doing things that don't look fun, don't try them. Just make sure that the work you're doing doesn't burn you out right now, because that will be what destroys you, because the agents don't need to have fun to land code. We do. So make sure you have fun. Let the agents do the boring shit.

30:22 Speaker 1: Hopefully that was an adequate answer. Thank you for the question, Gabriel. It's, uh, always fun to talk about the, the importance of enjoying your work.

30:30 Speaker 1: I saw somebody in chat saying that they're using their laptop less and their iPad a lot more thanks to T3 code. That scares me because I know the current state of our iPad app and like, yeah, it's good, but it's nowhere near as good as I want it to be. Thank you, and please file bug reports. Let us know what we could be doing better with it.

30:46 Speaker 1: Next one I have here is, "How to use AI harnesses effectively in a team?"

30:52 Speaker 1: So how do you share skills, agents, etc., with the team? Again, like, I try to put things that are project-specific in the projects, and then I try to, like, share information with my coworkers to convince them to, like, try these things and be excited about these new flows.

31:08 Speaker 1: I, I think a lot of this has to be, like, on an individual level though. Like, find the person who needs the help and then pair with them. Sit with them, work with them, learn from them, have them learn from you. Collaboration is the thing that will, like, bridge a lot of the gaps that we perceive here, and I think we're all just

31:26 Speaker 1: moving away from pairing and collaboration with humans. And I think that's where a lot of the, I don't want to say fear, because that's not the right word. I think that's where a lot of the,

31:35 Speaker 1: the, like, dissonance right now is coming from, that there is this big gap between how much we work together and how much we're working with agents, and we want to automate the gap between how we work together. We just need to talk to each other. We need to show how we're working with each other more. We need to ask each other to run prompts on each other's systems to get feedback from agents on how we're working on things. Like, just a few days ago, not to call Gabriel as an example, but he and I did some work on the device manager stuff in T3 code that lets you, like, do iOS simulators on Linux from your Mac directly.

And I wanted to make sure that the agents were using those tools properly, because I noticed a few times in some of my runs that the agent would call the wrong tool and get confused and have to, like, do a few more steps. So I asked Gabriel if he was down to hill climb it. He wrote some prompts, went through his history with them, found things the agents were doing wrong with the, uh, device manager, and then sent me and a couple other coworkers a similar prompt to have go through our code base and our, not our code base, but like our histories with the agents on our computer, generate a summary of all the different things that went wrong.

And then I sent him this zip when it was done, and he put that into his, uh, loop and said, "Hey, make sure these things are addressed as well." Created an evaluation out of the failure cases that we all were hitting in different places, different ways, and then ran that in a loop until everything was tidied up so that the eval passed. You gotta

33:01 Speaker 1: think in terms of, like,

33:05 Speaker 1: how do you, how do you find the problems that your coworkers are hitting? How do you see those problems? Ideally through pairing or working with them in a more direct way. And then how can you collect those problems in order to find solutions? And I think that this all goes a lot deeper. Like, I can't remember the last time

33:21 Speaker 1: I wanted to, like, sync skills with my team. Like, this is a thing I really wanted, like, early mid-2025 Cursor era, especially like syncing rules and things. Now, I just want all of us to,

33:33 Speaker 1: to, like, be crafting our workflows, because the, the workflow you build and understand will make you 10 times more effective than the world's best workflow being handed to you without an understanding of how it works. Like,

33:47 Speaker 1: uh, the world's greatest supercar is useless if you don't know how to drive it. I'd much rather have a car I understand, I've customized, and I've made my own. So finding the balance there is tough, but the, the repo skills as a way to prevent bad changes from making it into PR can be useful.

34:02 Speaker 1: Beyond that, yeah. I, I try to think of it similar to, like, my, my rules with, uh, pre-commit hooks. I hate pre-commit hooks, especially when I'm the one writing commits. I'm coming around a bit to them now because I can have the agent run them and fix the things that it notices when they fail. But I try to think around, like,

34:20 Speaker 1: setting up the right guards.

34:23 Speaker 1: Oh, I hear someone.

34:26 Speaker 1: Uh, see how someone is talking. There we go. Sorry about that. Yeah, the, uh,

34:31 Speaker 1: no worries. Happens to the best of us.

34:34 Speaker 1: I try to think in terms of, like, what prevents people from being frustrated without going all the way with, like, frustrating them a different way. Like, I cannot tell you how many times Julius has hit me up pissed off because some small change I made to one of the repo skills was getting in the way of his workflow. So as long as you treat these things as malleable and you're very quick to address things when they get in people's way,

34:55 Speaker 1: you're gonna be fine. Just move things around until they feel right, and don't be scared to change things if they're getting in other people's ways.

35:01 Speaker 1: Also, one other trick, uh, most of the tools that we use, things like Claude Code in particular, you don't just have claude.md.

35:10 Speaker 1: You also have claude.local.md. You can set up a global rule for your gitignore, which I've done, to globally gitignore claude.local.md. By doing that, I now have a second layer of defense in a given repo where if I don't like the rules the company set up or the project set up, I can create this gitignore file that can contradict it and, like, push back on that a bit. And I found that to be a very useful strategy when I don't necessarily love the rules that other people have set things up.

35:44 Speaker 1: Awesome.

35:45 Speaker 1: Next we have, "How do you safely move away from human code review in a large enterprise code base?" Actually gonna change my window layout a tiny bit here so I can actually see the chat as I go, because I would like to be able to do that. This makes me feel better about things. Cool. Hopefully that didn't break the screen share too bad when I did that.

36:06 Speaker 1: Nice.

36:08 Speaker 1: So, uh, how do you safely move away from traditional human code review in large legacy enterprise code bases? This is tough, and I'll be very real here.

36:18 Speaker 1: I haven't worked in a large legacy enterprise code base since agents took over to the point where I would trust them more autonomously.

36:26 Speaker 1: The, the biggest thing you need is safety nets. I've pushed this idea for a while of safety nets versus guardrails. The systems that we all had in place pre-agents- ... did a good job of lowering the likelihood of failures. Like, let's say in a given code base, the chance that a PR has a significant mistake that could regress for users or cause problems was 10%. You then set up linting, type systems, unit tests, end-to-end tests, all these other things, and it knocks it down to a 1% chance. That means that if you're landing 100 changes a day, there's a pretty high likelihood that at least one of them has a problem. So you keep shaving, you improve your code review process, you do all these things, and you get it down to like 0.

5, 0.3, 0.1% chance that when a PR merges, it has some problem. Awesome. As long as you're landing 100 to 500 changes a day, the likelihood that you hit these problems is very low, and you can probably catch them a slightly early, fix them before it causes problems. What happens when you 10X the number of changes? My hot take is that agents are less likely to make a PR with bad code in it than humans are, especially if you're using the modern models and modern tooling. I've seen a much higher percentage of bad PRs from human contributors than I've seen from agents. And you can ask anyone who's worked with me for more than two years, Theo wrote a lot more slop PRs pre-AI than currently.

I was notorious for slop PRs back in the day, and like I-- every code base I worked in, I mandated that we have a do not merge label because I would apply that to half my stuff, because I was moving things around until it felt right, playing with the ideas, seeing how I feel about the work that I'm about to go on. And a strategy I would often put in is I would make a crappy semi-functional version of a change to get a feel for it, to like put it in front of some users pre-release. Like, we wouldn't merge the code. We would use it as a reference point for us to play with and test out the ideas from.

38:34 Speaker 1: Being able to do things like that, to like get a feel for the changes, separate from getting changes landed and having systems in place where like you, your agents, and your team all have this mutual understanding of the difference between, "I am experimenting with this," versus, "I want this landed and shipped to users," and having a good human-driven separation there between those two. Like, what changes do we actually want to land versus explore? Then you need another layer, which is the idea of, what I was saying before, safety nets versus guardrails. Guardrails made a lot of sense when there was a ceiling to how much people were trying to ship in a day. But a 0.

1% failure rate gets really bad at scale.

39:18 Speaker 1: So as things scale up, you have to not try to avoid these failures. You have to embrace them and build systems that are resilient to them. Build deployment pipelines that have good staged processes so that if something goes wrong, you can catch it in that system and roll it back before it affects users. Set up a system for a nightly build or a dev build where all the employees at your company are opted in by default. So when this new change goes live, it only goes live for you guys. You all feel the difference, and if there's nothing wrong, then you can ramp it up to users. I don't think I would be comfortable working on a product right now that doesn't have some concept of ramp up when changes land, because I would have to move so slowly in order to make sure everything is like perfect.

You gotta have a system where you can ship changes without being super paranoid about the breakage. One of the ways to frame this is the, the idea of like the merge button. There's two sides to the merge button. There is before you get there, and there's after you click it. You gotta make both less scary. You need to change your tooling and your systems, your agents, your markdown, your skills, your everything, the way you prompt even, to make it so by the time you get to the merge button, you are high confidence the change is probably good.

40:36 Speaker 1: Then the other side, you need to make it so if the change was bad, that you are not depressed as hell that this thing is going to ruin the code base, that this is gonna like cause real economic negative impact for your business.

40:51 Speaker 1: You gotta

40:52 Speaker 1: lower the, the fear and the failure rate before you get to the merge button, and you have to deal with the possibility that when you click it, something goes wrong. And as long as you de-risk both sides, moving fast gets a lot less scary. And this becomes less about who is reviewing the code and more about what systems are in place for when the bad code lands, because no matter how strict your review processes are, bad code will land. I'd go as far as saying that even like the most strict code review I've been through

41:24 Speaker 1: also was the code bases that had some of the worst code land. And there's obviously like a survivor bias there to an extent, but yeah, it is what it is.

41:33 Speaker 1: Uh,

41:34 Speaker 1: I see that Greg shared in chat a question from Nicole, Nicole AI. Let's see if I can find it here so I can open it there. And if not, I'll just use it from chat. I don't know if it's in this section. It's not.

41:48 Speaker 3: Yeah, I'm not sure it is there, uh, because Nicole, I just asked on Discord and asked to pass to you if possible, but we can do it later.

41:56 Speaker 1: No worries. I'll just read it from chat here then. "Would like to see what Theo's process is for starting a new project. There's plenty of things out there about implementing AI into existing code bases and using packs like PStack, et cetera. Never seen much in-depth process of how to set up a new project for AI parallel building from the start. A spec, a vision doc, what scaffolding? Just tell it to do a thing in a thread in an empty repo?"

42:21 Speaker 1: I'll be real. I usually start with the end one there. I tell the agent what I want. We talk about it a bit. If the thing is complex enough or as we're talking about it, I feel like the agent isn't vibing with me, then I'll say, "Wait, we need to like talk this through." And that's when I'll like pull out the Matt Pocock grilling skill. I would say like the most I use the grilling skill is when I am-

42:44 Speaker 1: starting a, like, new project, to make sure that I'm aligned with my agent.

42:50 Speaker 1: That's a thing I've... How do I even put this?

42:53 Speaker 1: Also, like, like on the topic of, like, things sneaking in, I just got a text from my team. Uh,

43:00 Speaker 1: apparently I hardcoded a date in something to-- that's causing releases to break.

43:06 Speaker 0: That's been, you know, it's food on them.

43:08 Speaker 1: Oh, there's always something.

43:10 Speaker 0: And it's also...

43:12 Speaker 1: What's more?

43:17 Speaker 1: Uh, I missed what you said, Jonas.

43:23 Speaker 1: No worries. Anyways,

43:25 Speaker 1: the, uh, the process starting path for me is really just, like, start with an understanding of what you want and make sure the agent and you both

43:34 Speaker 1: have that understanding.

43:37 Speaker 1: The best way to do this is just, like, go spin up a bunch of weird random projects and see which ones the agent does well in and which ones it doesn't, and pay attention to how the agent is responding when you talk to it and ask it questions. You'll start to build a good sense of what the agent does and doesn't understand and how it can figure things out if you

43:57 Speaker 1: do this a whole bunch. It's also like, like when I start a new project, I'm sure a lot have seen my workflows where when I send a thread off in an existing project, I don't look at the thread until it's done working. I have a setup in D3 Code where threads that are working are hidden by default. When I'm starting a new project, I'm really in the loop for a while usually. Like, I'll just have the one thread open and we'll go back and forth for a while. I'll read the reasoning trace. Sometimes there's a mistake right now. The reasoning traces for Opus make you think the model's stupid, but somehow after thinking three wrong things, it does the right thing.

I don't know if there's, like, distillation attack prevention or something, but the, the experience I've had with new threads and new projects is if you're there and you see what it does and doesn't get, you can start steering it and quickly

44:40 Speaker 1: get it going pretty well. I also have benefited a lot from, like, starting new projects with a single long health thread, and once I'm trying to do enough things at once, that's when I'll start to parallelize. But at the start, up until I hit a certain threshold of, like, I want other people on my team to contribute to this. I want this repo to be up so others can look at it and play with it and work with it. I want to be doing three things at once in it. At that point, I'll leave the health thread, and then I will notice the things that are missing from my health thread, like the context that's been compacted a dozen times but it's still there, that the other threads don't have, and that's when I'll start to shape the repo around those things.

But for-- by default, my project setup is empty repo, new thread, work in that thread until I have a rough shape of what I want, keep working in that thread until I have the thing working. Then once I have a reason to have multiple threads or have a repo with coworkers or all of those things, I just start spinning up more threads. I see what breaks. I start fixing it and adjusting it accordingly. And again, it's like, it's like the zen garden thing. You're just constantly shifting things around to make it work. And the reason that there isn't some, like, how to start a new project using AI content is 'cause by the time somebody's, like, really deep trying to figure it out, they realize it's just malleable.

Just move things around and sh- like, shift back and forth until you have it how you want. So start super simple. Like, it should feel a little dumb how simple your projects start,

46:06 Speaker 1: and then adjust and change as you go. I think the biggest

46:12 Speaker 1: mistake I see people falling into is they go deep into this, like, maintenance-type work, the, like,

46:18 Speaker 1: the config porn, as I often call it, where they're just, like, editing config files and customizing their Vim before they actually start landing code.

46:26 Speaker 1: Start by landing code, then start configuring based on what does and doesn't work. I find that things get so much easier and, like,

46:35 Speaker 1: y- you'll start making progress faster and your understanding of these things will get stronger

46:39 Speaker 1: if you just fix the things that you run into when you run into them. No one will ever predict all the problems you'll hit. Just do it and see what ru- goes wrong.

46:49 Speaker 1: Hopefully that's a good answer. It's a, a weird question to answer because I don't really have an answer for it.

46:59 Speaker 1: Uh, let's go back to Discord, then I'll do some more chat questions.

47:05 Speaker 1: More tips on working in brownfield. How do you best handle polyrepo setups in big organizations?

47:11 Speaker 1: Oof, if somebody finds the answer to this one, I hope you DM it to me because I have been trying for a bit now. The...

47:19 Speaker 1: Yeah. So the problem here

47:22 Speaker 1: is that most tools, most, like, harnesses, most agents, most repos are built around this idea that you have, like, one folder that is the project. A lot of why they work this way is because the labs making the models work this way. They're both, both Anthropic and OpenAI are super monorepo-pilled. All of their code from all of their employees is one single monolithic hellscape of a repo.

47:49 Speaker 1: That allows-- Th- this has resulted in so many weird artifacts in how their systems work. The reason the sidebar in ChatGPT will never be good is 'cause everybody at OpenAI working in the ChatGPT app is working in one repo, OpenAI/OpenAI. That is the code base they all work in. So managing multiple different projects at once in ChatGPT will never be good because the employees working on it will never do it right because they don't work that way. They work in a monorepo. So the harsh and sad reality to this one, and it's not the answer I like, is that the best thing you can do is to shape your code bases to be as familiar to the agents as possible.

So if you have an old brownfield project, I see people not sure what brownfield means. It's the opposite of greenfield. It means a project that's been around for a while. It's-- The grass has died. The greenfield is it's fresh grass. Brownfield is the thing has slowly started to die. Brownfield projects-

48:48 Speaker 1: If they are split up in ways that are hard for a human to understand and they're hard for an agent to understand, it's time to start shifting things around. Do I think the solution here is force all your code bases to be monorepos?

49:01 Speaker 1: No.

49:02 Speaker 1: But I do think there are ways that you can make your projects look more like a, a monorepo when they're not. So setting up a repo on your machine that is just like three Git sub-projects effectively, like just have a higher level Git project you make. Maybe you don't even share with the company you use, have this one you have, and it has the three Git sub-modules for each of the different pieces you work with. And then that root is the project you work with, and you add custom instructions on what the different modules are, what the different expectations in these different modules are, and a system to orchestrate all of these together.

49:39 Speaker 1: That said, it does suck when you don't have one pull request that includes all of the related changes. It is very annoying having to merge things in three different places and time the releases for those three different things.

49:53 Speaker 1: It is very beneficial in all engineering orgs, even pre-AI, to have a system where things merging in one place affect all the places.

50:02 Speaker 1: In some of the biggest companies I know, like, like you think this only works at small scales, no, this is actually necessary at the biggest scales to have systems where you can work this way. I need some water, I'm losing my voice. Sorry about that.

50:20 Speaker 1: Anyways,

50:22 Speaker 1: the, the monorepo way of working, it's, it helps with so many things. It also hurts with so many things too, because Git and GitHub do not handle gigantic single repos great. But if you can move things around until it does work that way, the wins that you can get as a company are huge.

50:42 Speaker 1: And the, the right strategy here varies on, vary based on company. Like, I know some big companies that have taken the time to turn everything into a monorepo to make this easier. I know some big companies where they refuse to do this, so some random engineer got annoyed and rebuilt everything themselves, and now that random engineer's rebuild of everything has become the production version. I know some very big companies that are in the middle of doing that as we speak. So,

51:07 Speaker 1: sadly, there isn't a, a one-stop, how do you deal with lots of repos in one thread solution.

51:14 Speaker 1: You gotta be willing to change how you work in order to benefit the code bases that you're in and the agents that you're working with.

51:23 Speaker 1: I see people linking in chat that Google stores billions of lines of code in their single monorepo. Yep, there's a lot of big companies that work that way.

51:40 Speaker 1: Let's see what we got next.

51:46 Speaker 1: I think I've gone through most of the ones in the double digits here.

51:50 Speaker 1: How do you maintain understanding if PRs are created and merged without human intervention?

51:57 Speaker 1: When working in a team, say it's a small team of like less than five, we still want to maintain shared understanding of how the product grows. We currently try to have a discussion about what's on the horizon, especially for increments that change critical behaviors,

52:10 Speaker 1: and which PRs can be handled without human review. Still struggling a bit on what to do when there is more agent autonomy and what new PRs are created and subsequently reviewed and merged by the agents. I can imagine having some rules and thresholds so that the agent can identify PRs with a bigger impact and will automatically request human review. I'm wondering what's your perspective on this?

52:33 Speaker 1: I,

52:34 Speaker 1: I think I'm a little behind on this part to an extent. Like obviously a lot of my workflow is super futuristic, far ahead, what- whatever.

52:43 Speaker 1: My personal workflow is maybe a step behind here, and I'm figuring this out a bit myself.

52:49 Speaker 1: For me right now,

52:52 Speaker 1: I'd say about half the time when I open the thread, I know if I want this to merge code autonomously or not. Where if it's like, like just yesterday, somebody reported a bad behavior where if you had like a inline code snippet like this, and you had this in the chat and you double-clicked it, it wouldn't select the content of this. It would select just the word, and it should select everything in this little callout.

53:21 Speaker 1: I knew that it should do this. I knew the code change was very simple. I knew what the JavaScript binding for this element would look like.

53:28 Speaker 1: So instead of doing a process where it would file a PR that I go look at, test, and verify, I used my full send skill. Full send is, I trust you to build this to completion and get these changes landed as long as you trust yourself to verify and validate the changes. So the full send skill will use two to three times more tokens than if I just tell it to build it, file a PR, and validate it, because the skill has a higher bar for what it considers good, because the point of the full send skill is to full send. It sends the PR and merges it when it thinks it's ready. And with this change, I knew it was simple enough.

I knew what code it would touch. I knew it would probably be good. So I, I got this feedback on Twitter. I literally just tagged @bot, "Spin this up in T3 code for me, make this change, full send it." And then it landed. And I didn't even notice when the PR merged. I just noticed the difference in the build the next day, and I went and checked, and it was my PR landed. And then other changes I know are going to touch things in ways that I want to take an extra look at, and I have a different skill, full stop, I use when I want the agent to go as far as it can and then stop and let me look.

54:31 Speaker 1: So that for me, I, I know about half the time going in if I want it to merge or I want it to go really far and then stop. Then the other half, it's a conversation between me and the agent. It's exploration. I ask it questions about things. I ask it what it thinks about things. I ask it what the issue is about. Like if somebody DMs me an issue and they're like, "This is pissing me off so much, it's breaking my workflow," and I read, I'm like, "I don't understand what they're even saying here." I'll throw that to the agent, we'll talk a bunch. I'll ask it, like, "ELI5, why does this matter?

Why is this user upset?

55:01 Speaker 1: What do you think the best path is to fix it? What risks do you perceive in this path? What concerns do you have about it? What's the worst case if you were to just go build this and we merge? Like, what's the worst thing you think could happen?" I get an answer, I decide how I feel about that answer, and then I work through that thread accordingly. So how do I stay on top of what the rest of my team is doing here?

55:23 Speaker 1: I hope that they do the same, and if they are landing code that is bad, I sit with them, we chat about it, we adjust each other's workflows, and then it gets better. Like, I just got a bunch of texts from my team about bad code I landed over the last few days, so I'm going to be going through the threads where that happened, adjusting my workflow accordingly, and hopefully preventing that in the future. But the reality is, like, I can't even-- It's not only can I not stay on top of the changes my team makes, I can barely stay on the top of the changes that I'm landing. I forget when I do overhaul sometimes.

Like, I Thanos snapped 75% of our unit tests out of the code base and forgot about it a few days later. I rebuilt the, like, sub-package architecture in a project I'm working on right now and don't fully understand how things are split up at this point. I understand higher level, like how things work through the code base, like how data flows from a user doing a thing to an outcome occurring, but I don't necessarily know which files the code is hitting, which packages are doing which parts. And as soon as I need to or I get confused, I ask the agent, and then it helps me build the understanding.

56:28 Speaker 1: I think a lot of these problems could be solved in that way. Like,

56:32 Speaker 1: a- burn tokens, ask questions, like use tokens to bridge the gaps. If you're struggling to keep up with what changes are landing,

56:41 Speaker 1: set up a script that every day will run through all the changes that landed and summarize them for you. If you don't like the shape of the summary or there's too much text or whatever, adjust it. Then if you're really insane, like I am, create an eval for it. I made an eval for what types of summaries Theo likes by taking a bunch of summaries I didn't like, adjusting them myself, and then taking this set of like 20 giant text outputs that I worked with agents to make formatted the way Theo likes to read. I then took a prompt, I took two real commit hashes, told agents, "Okay, diff these, summarize them." Then I had another set of agents review the summary that happened there, compare it against the ones I like, and then score it one to 10, how likely is Theo to like this based on these other eight that he enjoyed?

57:32 Speaker 1: And then turn that into an eval and adjust the prompt for my summary tool until it got to the point where it summarizes changes in a way I like. And now every day I wake up to a, a message in my Discord Hermes agent that describes all of the things that happened, all the things it thinks I should look at, in a format that I like. Because I set up an eval and a hill climb and burned probably 1,000 dollars in tokens to make it so the agent will summarize changes in a way I like slightly more. Burn tokens to make yourself happier. I know I say this a lot, but like, find ways to u- to waste tokens to do things that obviously no human should do.

They're like so hilariously tedious. We all steer away from tedium because we're engineers, that's how we work.

58:17 Speaker 1: Find ways to tur- to make your work more tedious so that the agents can do the whole thing.

58:24 Speaker 1: And one of those things, of course, is the systems where you review what is going on.

58:30 Speaker 1: I do see something in chat I want to jump on now. Uh, thank you again for the question, MC2. Something I see in chat I want to jump on here is, uh, I keep talking about token maxing, but is there any hope for token optimizing? My wallet's hurting.

58:43 Speaker 1: First thing, if you're the one paying for your tokens, you better not be paying API prices. Take advantage of this incredible opportunity we have right now to get 12,000 dollars of Claude for 200 dollars. The other fun thing here is once you have those subscriptions, they have limits that expire in an amount of time. So start building up ideas or even like have prompts saved or drafts or stashes or whatever tool you use that you'll have ready to go the moment that you check your dashboard, you're like, "Oh shit, I have 30% of my weekly left and it expires in eight hours. What can I burn this on right now?"

59:24 Speaker 1: And once you start doing that, you'll start to see problems in the shape of hill climbs. Like, w- when you get into this habit of, "How do I make sure I burn my whole account before the limit expires?"

59:38 Speaker 1: You'll start to see problems in a different shape. I'm gonna give a real weird analogy here, but hear me out. I'm a skateboarder.

59:45 Speaker 1: I deeply love skateboarding.

59:49 Speaker 1: I forgot the name of the philosopher, he's like a new era, like philosophy, uh, professor, who

59:58 Speaker 1: learned skateboarding to bond with his son,

1:00:03 Speaker 1: and he wrote some incredible pieces around how it changed the way he looks at the world. He never got good. Like, he could jump down like two stairs doing an ollie, so like a very small staircase, he could like jump down slightly. He could ride around, like down the street, on the sidewalk, on the bricks. And he realized after doing it for a while, like the skateboard's a different vehicle to which you traverse the universe,

1:00:30 Speaker 1: and it teaches you to look at the world differently. It doesn't take a long time on a skateboard to start seeing everything around you in a different way. And I'm now at the point, like, there's silly quirks here, like I can look at a staircase and tell you how many stairs are on it in under three seconds. I don't even count. My brain can just autocomplete the number of stairs on a staircase because we care about, a lot about that in skateboarding. And when I'm like walking down the street, I'm thinking about how the, the road feels on my feet and like how cracked it is, how smooth it is, how bouncy it is with my foot.

I look at picnic tables and I like sit at them and I feel the material and imagine how my skateboard would feel on it.

1:01:08 Speaker 1: Everything in the world can look a little different once the skateboard has internalized itself in you. It's almost like a pair of glasses in a way, where everything looks different, and you'll never look at anything around you quite the same way, because you'll think about how it feels to ride your skateboard on it.

1:01:26 Speaker 1: That is what we have to do with our work. We need to get these tokenized glasses on and see problems through the lens of, "How can I waste tokens to make this go away?"

1:01:40 Speaker 1: And it's really hard to do that if you are constantly micromanaging your token budget. And I know the majority of you guys are working at companies that are doing this over API, that are actively trying to not waste too much money on tokens.

1:01:54 Speaker 1: You need to find a way to do both. Even if your company has, like, the crazy Anthropic enterprise API deals, you need to find subsets of your work that you can allow people to use personal subs on. Maybe you have a DevRel team that builds cool demos around your product. Make sure they use personal subs and can abuse tokens for that. Maybe you have a Discord community that you're building custom moderation tools for. Let some of the team use some personal subscriptions and burn a bunch of tokens experimenting with that. Find room in your business, in your team, in your work, in your life, to take advantage of this unique arbitrage opportunity to spend 200 dollars and get 12 grand, and figure out how to use that 12 grand.

1:02:38 Speaker 1: And once you start doing that, you'll find these cool patterns. You'll want to bring them to the workplace. You'll realize the company doesn't want to spend 12 grand a month on your bullshit. By the time they are done saying, "No, we're not doing that," tokens have gotten four times cheaper.

1:02:52 Speaker 1: A given level of intelligence is reached by other models a few days after that level of intelligence is hit. And the crazier thing is that the cost for that level of intelligence goes down by up to 4X a month right now. So the capabilities we are used to right now with Opus 5.5, we can expect to get similar capabilities for a fourth the price in the next few days.

1:03:14 Speaker 1: That is crazy. So even if these prices aren't saying you're trying to, like, minimize your spend, you should be getting used to what it looks like to maximize your token spend, because there will be a point where the tokens are cheap enough that you are a bad engineer if you're not. So find the places you can do it now, even if they are not in, like, the day-to-day traditional major product that you are helping with at your company. Find other places that you can do it. Maybe you set up some crazy test evals. Maybe you, like, for fun, just send the, like, a thread off to go rewrite the project from scratch internally using a personal sub that the company's okay with, if they're okay with it.

Obviously, like, ZDR, data policy, all that, be responsible with it. Figure out where this fits in your company and your work. But take advantage of this opportunity while we have it, because we might not always have it. But hopefully, just judging by all the numbers, by the time this insane subsidization is over, tokens will be so much cheaper for real work that it won't even be that big a deal. So yeah, that's my thought on the budgeting. Also, if you're working at a company that won't let you do any of this, that just straight up will not let you spend more than, like, 500 dollars a month in tokens, they won't let you get subs, they won't let you do any of these things,

1:04:25 Speaker 1: start looking for a different place. Like, I'm gonna be so real. If you are here, if you are hanging out with this awesome community, if you're watching videos like mine in order to keep up, and you are wishing that you could be doing these types of things at work and the company you're at will not let you,

1:04:40 Speaker 1: start with the classic ask forgiveness, not permission. And if that fails, I promise you, yes, the industry is hard to get a job in right now, but if you go to a mid-stage company, even a late-stage company, I know Microsoft, for example, would take you if you show up this way. If you go there and say, "Hey,

1:04:57 Speaker 1: I want to be using agents more for my day-to-day work. Here are all the cool things I've built in my personal projects on the side. I have been trying to get my employer to let me work in a similar way, and they will not let me because they have a strict policy. I'm only allowed to spend 80 dollars in Copilot every month, and that's the only AI they let me use. I want to go somewhere where I can use these tools to better the company and myself and level up the team with me.

1:05:22 Speaker 1: Do-- Will you guys let me burn tokens at your company?"

1:05:25 Speaker 1: Every company you would ever want to work for will say yes to that, and the ones who say no are not where you want to be. I know this sounds terrifying, but if you are here and you are excited by these things and you're in one of those companies that does not let you do the things you're excited about,

1:05:42 Speaker 1: the need for people who are excited about these things is so goddamn high. I cannot tell you how many times I've heard either directly or indirectly that Satya Nadella won't stop talking about agent-native developers, the developers who love working with these tools, who understand them deeply, who are allergic to writing code the traditional way and dealing with low token budgets. They are actively trying to hire for this type of person.

1:06:05 Speaker 1: Be that person. I also know companies like, uh, I know Figma lets people expense personal subs as part of their education budget, and like, lets them use them for whatever, for like, things that aren't touching user data. Like,

1:06:17 Speaker 1: let your employees experiment and try out these awesome things, because your best coworkers, your best employees, whatever level you're at, if they're not allowed to, your best people will leave. And this also goes the other way for you as an individual employee.

1:06:31 Speaker 1: If you are frustrated with these things, you're not going to be surrounded with awesome people because the other awesome people who care about these things have also left.

1:06:40 Speaker 1: The best reason to stay at the company is because you're surrounded with awesome people that you love working with, that you want to have at your wedding someday, or be at the wedding of. And if that's not the team you're on, it's time to start rethinking these things a bit, because we need to be pushing each other right now more than ever. And being on a team or at a company that is not interested in helping you as this all changes

1:07:05 Speaker 1: might set you up for failure for the rest of your career. It's, like, rare that we have moments like this where a couple bad months could set you up for a couple bad years, which could set you up for a bad career, but we are absolutely in that right now. And it is important to surround yourself with an environment that is the most likely to

1:07:25 Speaker 1: excite you, encourage you, push you, and just build the future you want to for yourself. You're not gonna get that at a company that maxes out at 100 dollars a month of Copilot. Hopefully that's a good enough answer to the how do you deal with burning less tokens at work. [chuckles] There's also the much easier answer of ask an agent to go through all of your history on your machine and find all of the things that made tokens get burned for no good reason. Find all the cases where your agent hit an error with a tool and had to try again. Take a couple threads that were really expensive and go through them with a comb with an agent.

Be like, "Why did this thread take so long? Why did it burn so many tokens? What got in the way? What could we do to make this easier in the future?" And

1:08:13 Speaker 1: maintain that zen garden. You might be surprised at how much more efficient you can make certain tasks by doing that type of thing. Find the thing that is costing, making tokens cost too much and making them burn too hard, and adjust them.

1:08:25 Speaker 1: Become the agent or become the advocate for your agent's UX is an absolute banger, Justin. Thank you for dropping that. I love that framing. We are the advocates for our agents. We are the ones fighting our bosses to make our agents as effective as they can be. We are the ones making sure our agents are

1:08:44 Speaker 1: set up for success, that they have access to what they need, that they can do what they should be able to do in order to get the work done.

1:08:52 Speaker 1: We are all... I know for a while people pushed back on the idea that like we're all like people managers becoming agent managers, and that's why people who ran teams were set up for success.

1:09:05 Speaker 1: I,

1:09:06 Speaker 1: I, I think that's become more true now than ever. You gotta... Like, I, I've been managing teams now for, I think I'm now at seven years of being a manager, either direct or indirect, probably closer to eight.

1:09:20 Speaker 1: I have always saw my role as a combination of like cheerleader and umbrella. I am there to hype up the team, to push them, excite them, and set them up for success. And on the other side, I'm the umbrella. I'm the one that keeps the shit from get- like hitting them as they're trying to get their stuff done.

1:09:40 Speaker 1: I,

1:09:42 Speaker 1: I just want my people to feel like they have everything they need to win, and I set up my agents the same way now. And now I set up my team to set up their agents the same way too.

1:09:58 Speaker 1: I saw a fun question in chat here. How am I comfortable with allowing agents to do things on my machine? Isn't it scary?

1:10:05 Speaker 1: Yes and no.

1:10:07 Speaker 1: I find that you slowly ramp up to it as you let them do more and more, especially if you do it with like computer use in a way that's really visible. Like, I

1:10:16 Speaker 1: initially was like... How do I even explain this? The,

1:10:22 Speaker 1: the early days of letting my agent open my browser and click on buttons were terrifying, but it was very slow and you could see what it did. And then I gave it more and more permission. I let it start using things on my computer when I was away. And then as new models would come out, I would test them and try them.

1:10:42 Speaker 1: The, the reality is that like the, the likelihood of an agent doing something really bad and dangerous is directly correlated with the intelligence of the model and the complexity of the task you gave it. If you ask an agent to find the pull request where this thing happened, it's not gonna do anything that dangerous. If you ask it to find the email where this thing happened and it doesn't have a good tool to call your email, and it instead goes to Chrome, opens your inbox, and starts firing things off, that's a little more dangerous. If you ask it to figure out when this transaction happened in your bank, that is more dangerous. And building this intuition for like where is the risk in the things I'm requesting and the things that I'm doing, and what can and can't I trust the agent with?

It's a thing you gotta build over time, similar to like,

1:11:35 Speaker 1: like how, how do you get comfortable merging code if you don't know how it works in the production build? No one actually knows when they hit merge if that code is going to work in prod or not. They can do whatever processes they want. They can test early builds however they want. Nobody knows for sure that when the code lands in the production server that it's actually going to work. You just build up good intuition for likelihoods here, and it's the same thing here with the agents and the safety.

1:12:04 Speaker 1: Once you get a little bit of time in it, or if you just leave auto mode on, which most people should be doing. In fact, I was talking with Boris a few days ago, and he was very upset with me for not using auto mode and using full access in tools like T3 Code, Quad Code, et cetera. Auto mode's gotten really good. It is a bit slower than I would like because it double checks before running commands. But generally speaking,

1:12:27 Speaker 1: the agent knows what is and isn't safe. The agent making the unsafe requests has a goal in mind. It's trying to achieve a thing. Another agent has a different task of checking if the thing it's doing is safe or not. That's what auto mode is. It's an agent that's job isn't get whatever you want done. It is two agents with different jobs. Agent one, the one that you're sending prompts to, is trying to complete the task. Agent two, the one doing the reviewing, is trying to make sure that Anthropic doesn't get in trouble because the agent did something sketchy on your machine. These agents have different goals, and they compete, and through the competition, they keep you safe.

1:13:00 Speaker 1: I think if you just turn on auto mode and you ask progressively scarier things to the agent, you'll be surprised at how safe it acts. If anything, they are overly precautious. I am making changes as we speak to a lot of my global guidance because my agents are so scared to delete things or edit things in progress that they just clone everything always. And I have hundreds of clones of things on my machine because my agents are paranoid. So you'll realize pretty quick the problem's almost the opposite.

1:13:28 Speaker 1: Your agents are going to be too precautious, and you're going to want to tone it down after a bit.

1:13:39 Speaker 1: Let's look for more questions in chat that got a lot of hearts. Chat's moving fast. Thank you guys all.

1:13:49 Speaker 1: Somebody asked about interviews right now. Would I say that companies that are still doing traditional FAANG-style interviews are behind the times? Is that a red flag for a company?

1:13:58 Speaker 1: I would say that doing FAANG-style interviews five years ago was a sign the company was behind the times. I have never liked the traditional FAANG interview process. Again, to like talk about the ideas I had before of like, it's my job to set my team up for success. It's the same with interviews. Since my job as the manager and the team lead is to make it so my team is as likely as possible to succeed in their work,

1:14:23 Speaker 1: why would my interview not be the same? Why are interviews set up to basically be a bunch of gotchas, to like trick the potential hire into doing things wrong so you can be like, "Ha ha, you got that wrong. I'm smarter than you." And your reward for me being smarter than you is that I don't have a good employee and you don't have my job. Like, it just, it punishes everyone involved. It's so stupid. You should be setting up your interviewees the way that you would want to set up one of your coworkers to work on something. You should set them up... So like, one of the things I would do is I would send out a packet ahead of the interview, ideally a few weeks ahead, that has different options for how to conduct the interview.

The first option is, of course, the classic LeetCode, because people are familiar with that. I don't want somebody who trained for LeetCode to feel like they're screwed because they spent all this time preparing for a LeetCode interview and they show up to a project architecture interview. So I give that as an option, even though I don't personally think it's a great way to measure engineering capability.

1:15:17 Speaker 1: Option two is I will come up with a real task and a real-ish code base that we can work through together,

1:15:26 Speaker 1: and I give an example of what this would look like with a real example I did in previous interviews. Option three is bring your own interview, or bring your own, uh, product or project where you show up with a repo you're working in that you send to me ahead so I can pre-review, like, "Yeah, is this real enough? We can work on that." And then we just pair together. The interview, that one is a bit longer. I'll do an hour and a half to two hours for that. But the interview is us pairing on you doing things in your code base so I could see how you work, I can ask questions, I could see how you resolve conflicts, I could see how you collaborate.

Because you're not just a person landing code. We have agents for that. I need to know how it feels to work with you if you're going to be on my team and working with me for years. And I do not, for the life of me, understand why any interview isn't that. And I think the vast majority of the culling that is starting in FAANG and is going to get worse is because we are hiring on smoke signals, not on actual collaboration ability. And the, the one here that kills me the most, the thing I would hard nope and never recommend somebody work at a company for, is if the people you interview with are different from the team you'll be working on.

That is the greatest sin any company can commit, and I genuinely cannot fathom companies still do this, where they have the interview team that's job is to interview, and then you join the company to be on a different team that isn't the interview team. That, I've had two times in my life where I interviewed a candidate, they accepted the role, and then they weren't on my team. The first time it's because I was switching teams right when they got hired, and I felt so bad I became her, one of her closest mentors. I still talk to her at least once a week because I... She had told them she had partially joined because she was excited to work with me, and I still feel guilt about that one to this day.

1:17:02 Speaker 1: The second one was because I left the company right after she got hired. I still feel really bad about that one as well.

1:17:07 Speaker 1: The thought of someone getting excited to work with me and about how I work and then not getting to do it

1:17:14 Speaker 1: haunts me. And the fact that there are companies that structure their whole interview pipeline that way sickens me.

1:17:20 Speaker 1: I, I said I have multiple interview strategies. The fourth one I think is actually one of the best now. It's bring your own interview. If you don't like the three styles of interview I offer, propose your own. Obviously, I have to approve it before we go through with it. But if you think you can showcase your skills in a different way that would benefit you in that you feel better about how you present yourself, and it would benefit us that we can see the best version of you, because that's what we want. I want to hire and work with the best you, so the interview should be of the best you. So if you can show up with a different style of interview you want to do, awesome, let's do it.

I've only had one person ever take me up on that, sadly, but I, I'm hoping if I ever have to, like, do interviews more actively again, that more will. The sad reality now is I'm out of the loop for interviews because I don't have to interview people to hire them anymore. I have a pipe of the most incredible engineers all offering to work for me for free. Many won't even take no as an answer. They'll just contribute for free, to, to free code anyways. So I don't know how interviews look right now at companies just because I haven't been on either side in a while. But the little bit I've heard has been hellish.

1:18:25 Speaker 1: And I wouldn't be scared in an interview or, like, before an interview to just hit up the company with a couple questions, like, "Will I be interviewing with the people I'll be working with? Will I have the opportunity to hang out with them? Will there be, like, a lunch where I could sit with the team I'll be working with?

1:18:42 Speaker 1: What style of interview is this? Will-- Is it okay if I bring my own project and one of the interviews is me working on it with somebody?" Because I want to know what it feels like to pair with what might be my new team. And if the company says, "No, we can't do that," just end the interview there. Like, if you care enough to do these things, you care enough to not deal with one of these companies.

1:19:10 Speaker 1: Sorry. Anyways,

1:19:13 Speaker 1: what do we have next here?

1:19:19 Speaker 1: How do I see the future of interviewing with AI is what I just did effectively. Uh,

1:19:26 Speaker 1: what do I think of companies that rely on microservices or a bunch of different services? I think currently I'm being slowed down because I'm not able to make agents run total end-to-end tests. "Should companies rebuild thinking agent or AI first?"

1:19:39 Speaker 1: I would argue that, like, the problems that I'm hearing about i- in this way aren't problems that are agent-specific. They're problems that already existed, that agents just

1:19:50 Speaker 1: accelerated to an extent. Like, if your company had a lot of really fast-moving devs pre-AI,

1:19:57 Speaker 1: they would be really frustrated with a microservice architecture that they can't run locally to test changes. It's so frustrating, more than almost anything, to be in that scenario where you,

1:20:10 Speaker 1: like, can't validate the work that you're working on.

1:20:16 Speaker 1: You gotta figure out how to do that. It doesn't matter if it's microservices, monorepos, or whatever. You need to have a tool that a human or an agent could run to test things end-to-end to the best of your ability. Obviously, nothing is the same as running in production, but the closer you can get, the better. This doesn't have to be you change the architecture of your systems,

1:20:39 Speaker 1: but it should be a single command your agent can run to spin things up in a way it can test. This could be a cloud environment that you can auto-provision. This could be a Docker image that you run on your machine. This could be a bunch of sketchy scripts that have to run to provision things a certain way. It doesn't really matter what it is, but making sure your agents and your engineers are able to verify and validate things before you start going through the expensive loop. Like, like once the PR is filed,

1:21:07 Speaker 1: the risks start to increase. The more confidence you can have before the PR is filed and before the merge button appears, the better. And building tooling, building systems, burning tokens to build a bunch of slop, like, it's okay for this layer to be slop. If this layer isn't what ships to your users, this layer is what lets you take what ships to your users and replicate it locally,

1:21:26 Speaker 1: there's room in every code base for some slop. And this is one of the best places to fit the slop in your code base.

1:21:32 Speaker 1: It-- Mostly 'cause this slop will prevent other slop from shipping to your users.

1:21:37 Speaker 1: Love the glasses, Matt.

1:21:41 Speaker 1: What do we got here next? Uh, "How do we use T3 via remote?" Uh, T3 new question. Obviously, taking the opportunity to discuss that. T3 code has a thing called T3 Connect built in. So when you s- set up T3 code on a machine, you can do it through the command to, like, spin it up with the CLI, or you can install the app. You can sign in through T3 Connect, and now you have three, up to three machines for free that have full capability to connect to each other just by being signed in. And from the phone, you can control them all as well.

1:22:12 Speaker 1: The...

1:22:16 Speaker 1: How do I put this? The-- There's other, like when you have more machines, you wanna do more things, you can use Tailscale or any other connection method, but it's relatively simple. You scan a QR code if you're not using T3 Connect, you just sign in if you are, and now you can fully control each machine from each machine. We made it as simple as possible, and if you think that this is-- sounds scary or complex, I understand, because every other tool did this so wrong. There's, like, just little things that we did. Like, there's no real way in Codex when you're using it remotely to open up the code that it's changing in an editor of your choice.

I put a bunch of time into the T3 code implementation here, where if you have SSH access to the machine that you are controlling in T3 code, Command O will open VS Code in the SSH mode so that you are SFTP accessing all the files so that you can edit the code, look at the code, and see it in your editor of choice, even if the code is on a different box in a work tree somewhere else. And I think it's really important to, to get your workflow to a place like that, where whatever you need to feel comfortable and confident in what you're shipping, make sure your tools do that. And if they don't, fix it, and if they won't let you fix it, move to something else.

This is also why I thought it was important to make T3 code open source, because when the other tools I used didn't let me build features and workflows to increase my confidence and happiness and excitement,

1:23:39 Speaker 1: it frustrated me so deeply. And even though I could, like, hit up the labs and get them to change things, the process was too slow. I wanted a tool I could fix and customize myself. So if T3 code isn't doing what you want it to, fork it. About a fourth of our users at any given time are running forks, and a lot of big companies run internal forks.

1:23:56 Speaker 1: Make your tools work for you. And remote is one of the pieces that we built 'cause we wanted that for us so that we could parallelize more and have better control of our remote machines.

1:24:05 Speaker 1: Build the things that make your workflows feel better for you.

1:24:13 Speaker 1: Alicia asked a fun question. Uh, "I talked in the mega kickoff about programming becoming more about coding around intent and intentions rather than encoding specific actions in the future. Want to hear a bit more about that."

1:24:27 Speaker 1: I think it's actually a good one to wrap up on, 'cause I normally try to avoid future-future discussions, 'cause no one knows where things are going at any given time. The, the main point I was trying to make with that is that the actual direct implementation details matter less than they've ever mattered. The, the fact, this isn't an opinion, this is a, a fact, that I was able to rewrite the TypeScript compiler in an entirely different language, a project that took some of the best engineers in the world many years to complete, and I was able to do that in a loop for 500 dollars of Claude sub in two weeks. That is unfathomable.

That is a different world we are in now,

1:25:09 Speaker 1: where the reason the thing is built matters a lot more than the way the thing is built.

1:25:14 Speaker 1: Because the way is a malleable thing more than it's ever been, but the reason you built the thing is probably going to be more static. Historically, it's been the opposite. Like, a company's goals and vision and direction shift faster than the code does. Now the code can ship faster or shift around and change more than anyone's mind is able to comprehend. We need to work around that. How do we

1:25:39 Speaker 1: build in a way-

1:25:42 Speaker 1: Where we

1:25:44 Speaker 1: can, like,

1:25:47 Speaker 1: feel like we all have a shared understanding of why this thing exists. We as in you and me as coworkers, but also Claude and, like, ChatGPT as agents contributing as well. Making sure we all understand and agree on the, the reason, the motivation, and the intent

1:26:04 Speaker 1: is going to be where most of the work happens going forward.

1:26:11 Speaker 1: I think that is a good one to end it with. Sorry that I missed so many questions. We could do this literally forever, especially with how much things are changing nowadays.

1:26:22 Speaker 1: Okay, one last fun one. If I had to build T3 code from scratch now, what would I do differently?

1:26:27 Speaker 1: I would use Opus 5.5, and it would be significantly easier, because when I built it, we were using GPT 5.2 and, uh, Opus 4.6. Opus 4.5, I think, initially, actually. It--

1:26:39 Speaker 1: I, I-- And there's, like, weird random architecture things here and there. Uh, I would not have let NPM be involved, like, at all in our packaging strategy, just because it has caused us so much pain. And I would never, ever, for any reason, support Windows ARM. Windows ARM was a mistake on Microsoft's end and on our end for supporting it. Ah,

1:27:03 Speaker 1: good stuff. This was super, super fun, guys. I appreciate the opportunity a ton. Any last things from the Mega guys you guys want me to do or jump on?

1:27:14 Speaker 0: Uh, thanks a lot, Theo. Thanks a lot, everyone. Um, of course, we will share the recording. We will share all the information, all the links with you guys. You will have everything, uh, uh, shared on Discord. Hopefully, you will get as much from this session as, uh, as possible. And thanks again, Theo. This was fire.

1:27:33 Speaker 1: Of course. Thank you guys for having me. Super, super fun.

1:27:37 Speaker 3: Yeah. Thanks for much, man. So much. It's, it's great that you, you guys all been here. Uh, it's, it's really nice to have you. If you have any other questions about Mega and, and stuff connected, I can pick a few if you, if you want to stay. But otherwise, we are done with the Q&A session. Uh, thank you, Theo. Thanks so much. We'll have another session next week, but please remember that this session was, uh, the only one on Friday because we wanted to give you, like, an extended week to kind of, like, settle in a bit with Mega, which is, I don't-- I know not the easiest thing because there is a lot of moving parts.

So, um, thank you for your, uh, understanding and patience on fixing all of that, uh, and being active on the Discord as well. But the next session is on Wednesday, and all of the sessions are happening on Wednesdays. Everything will be posted on Discord. So, uh, meanwhile, if you have any other questions for me or for-- to the Mega team, uh, you can put them, uh, in the chat. Uh, otherwise, and the rest, thanks so much for being here, and thank you for being part of Mega. We really enjoy your company, and we stay, uh,

1:28:45 Speaker 3: whenever we are awake on Discord as well. So we'll keep your, uh, questions there. Thanks so much.

1:28:53 Speaker 1: Peace, y'all.

1:28:54 Speaker 3: Thank you. Bye.