Theo-brainUnofficial. Not affiliated with Theo or t3.gg.
Sign inYou
33:48
0:00

Boris Is Right Again (I Hate It)

Monday, Aug 24 · 34 min · about 9 min to read

Theo-brain watched all 34 min

Theo reads 'coding is solved' narrowly: give an agent a well-specified change and it makes it about 99% of the time. Finding bugs on its own is not solved; a Claude Code desktop bug shipped because no one opened the app to look. The takeaway: write a good plan and set up a way to verify changes, like easy local testing and visual proof.

Briefing is enoughThese notes should be enough; watch only if you want to hear Theo make the argument in his own words.

Tap any time to jump the video there.

Key takeaways

Theo reads 'coding is solved' narrowly: give an agent a well-specified change and it will make it about 99% of the time, even if the change isn't what you actually wanted. Finding and preventing bugs on its own is the part that isn't solved.

hearing Boris say coding is solved, bugs are not yet solved. What I'm hearing him say is that this part here agents have gotten incredible at. If you give them a wellsp spec change, they will make that change. The change might not be what you actually want, but if you tell them what to do, they will do it 99% of the time.

The Claude Code desktop bug that started this, update text cut off on screen, shipped because no human or agent ever opened the app to look. Seeing it would have taken seconds.

you legitimately think after this code was written by an agent that any human or agent actually checked what it did in the app? Obviously no. Because this would be a very quick thing you see and you're like, "Oh yeah, that is wrong. I should fix it." But no one did because

Plan quality sets the range of outcomes. Good plan plus good engineers: roughly 8 to 10 out of 10. Bad plan: 1 to 4, however good the engineers. A vague plan: anywhere from 1 to 10.

output. Like if the plan is good and the engineers are good, we can say the range of success here would be like 8 to 10 obviously out of 10. Where with the bad plan, I would argue that the software coming out will also probably be bad as low as like a one to a four out of 10.with an empty or bare plan, the range is massive. I would say as far as 1 to 10, you have no idea. It depends on a lot.

Even good plans and good engineers only produce good software when there is a system to verify the changes. Theo's examples of that verification layer: QA, staging environments you can test in, and slow rollouts.

Good plans and good engineers should result in good experiences, but I would argue they only do when the good engineer has a system to verify the changes are actually good. But if youIt's the verification layer. things like QA, things like staging environments you can test in, things like slow rollouts that will make sure that bad code

Theo largely agrees with Matt Pocock that agents are 'tactical tornadoes': fast at day-to-day work, but they won't look after long-term architecture or codebase health on their own initiative.

agents feel to him right now. I largely agree. I don't think agents will preemptively, proactively do good with strategic planning of codebase health and architecture over time, but I do

Four skills here are new to you.

Make your app easy for agents to test New

What it is
Set up the project so anyone, human or agent, can quickly start the app and try a change. Theo changed thousands of lines in T3 Code so its dev server (the local test version) runs over Tailscale, a private network, with a read-only snapshot of real data.
Why Theo cares
His rule: if it's too hard for you to spin up and test, it's way too hard for your agents. He did this work so he could check the agents' changes and the agents could check their own.
How to try it
  1. Ask your agent: how many steps does it take to run this app locally and check a change? Then ask it to cut that down.
  2. If you review work from another device, have the agent make the dev server reachable there instead of only on localhost.
  3. Ask for a test setup that uses a read-only snapshot of real data, so tests are more useful.
too hard for you to spin up and test, it is way too hard for your agents to do the same. You need to make it easier to actually verify your code bases. And I
actually made a lot of changes like thousands of lines of code changed in T3 code to make it easier to run the dev server over a tail scale environment while also pulling in a readonly snapshot of your existing data to make it a more useful test. These are the

Demand visual proof, then actually watch it New

What it is
Have agents attach a video or screenshot showing the change working. Theo notes a new GitHub CLI update lets agents upload these without committing them to the codebase.
Why Theo cares
Proof videos are often 'obvious slop' showing the feature not working. When he points that out, the agent realizes its mistake and fixes it.
How to try it
  1. Tell your agent every pull request must include a video or screenshot of the change running.
  2. Watch it yourself; if it shows something broken, ask the agent what it saw.
the thing didn't work at all. I cannot tell you how many times I've had to say, "Wait, the video you shared shows this not working. What did you see?" And then it realizes it got it wrong and it goes

Use agents as strategy consultants New

What it is
Before a big change, ask agents to review your architecture or your planned changes and to investigate theories you want to test. You keep the strategic decisions.
Why Theo cares
Agents won't do strategic thinking on their own, but he sees a lot of power in them as advisors. With a confident plan and a way to verify, they then execute it remarkably fast.
How to try it
  1. Ask your agent for feedback on how the current architecture fits a change you're planning.
  2. Have it test an idea in a quick prototype before you commit to it.
  3. Only hand off execution once you're confident in the plan.
during that workflow. If you ask agents to look into these things and give you feedback on how your architecture looks or what changes you're planning on making and you can even have it investigate theories to prove ideas you have out too. There's a lot of power to be had with agents helping you as

Spec bugs properly before handing them off New

What it is
Write a detailed bug report saying what is wrong and what the fix should look like, and give the agent even a minimal way to check its fix.
Why Theo cares
With that, he says most frontier models can absolutely solve the bugs. What they can't yet do is find bugs on their own.
How to try it
  1. When reporting a bug to your agent, describe what you saw, what you expected and what 'fixed' looks like.
  2. Tell it how to confirm the fix, such as a screen to open or a step to repeat.
post. I think if you have the bug speced out properly, like a detailed enough bug report that describes what is wrong and what the fix should look like and then add even the most minimal verification system there, the vast majority of frontier level agents and models can absolutely solve the bugs, too. They're

Advice

Test the result, not just the code. Pull the change down and check it solves the problem, or at the very least require the agent to show you it did.

What that means is we need to be actually using the code or agents, right? We need to pull it down on our machines and test it and check it and make sure it solves the problem it's intended to at the absolute least we need the agent to show us that it did that itself. And until the agents can do

If you want agents to act like engineers, do the engineering up front yourself: set up the systems and the plan. Agents can help with that, but you have to set them up for success.

their judgment to. Absolutely agree. In order to make your agents act more strategic and act more like engineers, you have to do the engineering upfront yourself. The agents can help you as you do it, but if you want the agents to be able to do these awesome things, you have to set them up for success. Man, I

Hot takes

If you're still writing code by hand, you are largely falling behind.

But the reality of engineering nowadays is that if you're writing your code by hand still, you are largely falling behind. And I have to do a thing I am

The era of finding bugs by just reading the code is over.

His reasoning: Any bug you can spot by reading code, agents can almost certainly catch too. The bug in question wouldn't have been caught in code review, because the code looks fine.

Because let's be real here, nobody would have caught this bug in code review because the code looks fine. If it didn't, the agents would have solved it. The era of finding bugs by just reading the code has, let's be real, ended. Any bug you notice from just reading code can almost certainly be noticed by the agents, too, and ideally noticed within

Claude Code desktop lags the web version largely because it's so much harder to test.

His reasoning: As a desktop app built on Electron, testing needs a full graphical virtual machine per task, which is expensive. And Anthropic's models are much worse at operating a computer than other labs' models. The web app is easy for agents to test, many tabs at once.

but I think a significant portion of why the Cloud Code desktop app isn't improving meaningfully in comparison to the Cloud Code web app, which is improving constantly, simply comes down to how easy it is to set up Cloud Code web for testing versus Claude Codeyou combine the fact that that is expensive and difficult and far from trivial to set up with the additional fact that cloud code models are just so much worse at computer use than models from other places, you end up without

Boris calling the cut-off text 'a UX issue, not a bug' is wrong.

His reasoning: The text is cut off at every reasonable display size, so it can't be the intended experience.

reply is making it harder. By what logic would you say the text being cut off in all reasonable display sizes isn't a bug? I'd be really curious what your definition of a bug is because this cannot be the intended experience. In

How Theo thought about this

He settled the fight by pinning down definitions. Boris said 'coding', meaning turning plans into code, not 'software engineering'. Theo says if Boris had claimed engineering was solved, this would be a very different video.

But Boris didn't say software engineering. He said coding. And that's historically what he has said. If Boris had said software engineering is solved, I would be making a very different video right now. But he didn't. Bugs are part

He separated the causes of bad software. On the input side: missing details in the plan, or bad details in the plan. On the output side: having no system that lets you verify the code.

different. Bad code happening because of no detail given in the planning process versus bad code happening because of bad details in that same planning process.there's another thing that can often result in bad code, which is the other side. Not that the code comes out bad, but because you don't have a system that allows you to verify the code on the

Sign in to mark what you've watched and keep notes.

Have a question about this one? Ask about this video →

Theo Daily is unofficial and not affiliated with Theo or t3.gg. Written by Claude Opus 5.5 from each video's transcript.