One Hand, 150 Autonomous Merges: What Theo's

Theodore Kohlhepp, the developer and streamer better known as Theo of t3.gg, has been coding with one hand since early August. A thumb ligament he first tore years ago, then again about two months ago during an ordinary gesture at his desk, has left his left hand in a cast with a coin-flip prognosis: roughly 50% odds the immobilization heals it, 50% odds he needs another surgery and six more months of limited use. His doctor delivered those odds directly, according to Theo's September 1 livestream on YouTube.

Since August 8, the day his hand went into the cast, he says he has shipped more than before. His GitHub contribution graph is the evidence he points to. The experiment forced into existence by a torn ligament turns out to be one of the clearest public demonstrations yet of what working entirely through AI agents actually looks like, and where it strains.

The Accidental Accessibility Study

Most of what we know about AI-assisted development comes from people who could do the work either way. A developer with two working hands tries Cursor, writes a post, and we learn little about whether the tool changed the ceiling or just the mood. Theo's situation strips out the choice. He typed at 160 words per minute before the injury. Now his keyboard hand is pointer finger on Command, ring finger on Tab, and his thumb does not work.

His first finding is negative, and it's a useful one: you cannot dictate code. He demonstrated on stream, trying to voice a simple loop, "let x = 4, let y = 12, while x is less than y, x++." His verdict: "that's not viable." People who have coded by voice for decades, he said, are "a goddamn trooper and a hero." The productive path is describing outcomes, not transcribing syntax.

The second finding concerns the social cost of voice input. Theo disliked talking to his computer in an open office so much that he used to book meeting rooms to dictate in private. The fix cost about $70: a small directional podium microphone that picks up whispered dictation while rejecting background noise. He demoed it by playing a YouTube video louder than his own voice; the transcription tool heard only him. After he showed his team, every member bought one. His advice for everyone else is unglamorous and correct: try your laptop's built-in microphone first. The hardware only matters if you need to whisper.

Managing Machines by Description

The third element is less about AI and more about documentation discipline. Theo maintains a project called Fleet that catalogs every machine on his network: how to reach each host over SSH, what each box is for, what's installed. When an agent needs to move a file between computers or provision software, it reads Fleet and does the work. No SCP commands written by hand, no waiting at a terminal for a download to finish before typing the next step.

That last detail is the actual insight. The bottleneck in most workflows was never typing speed; it was the serialization of small waits. Describing the whole task to an agent, including the steps that depend on unfinished steps, removes the waiting. Theo's framing: he started "pulling it in slightly earlier" and letting the agent go "slightly further" than he would have before the injury.

Terminals, meanwhile, he has abandoned almost entirely. "Talking to your terminal is hell," he said, and weeks of one-handed use hardened a conviction he already held: terminal-based agentic coding is the wrong interface. He routes everything through T3 Code, his open-source coding agent, and ChatGPT for non-code life admin.

Where the Terrain Gets Contested

The livestream's most quotable claim is also its most debatable. Theo described letting models write and merge pull requests autonomously: over 100 PRs merged by what he calls Astra and at least 50 by Fable, with two regressions, both removed animations. His conclusion: "That's a better hit rate than most talented developers have," drawing an analogy to self-driving car accident rates per mile.

Readers should weigh what this evidence is. It is one developer's self-reported tally across his own projects, with no published benchmark, no independent verification, and a stake in the outcome: Theo builds and monetizes T3 Code. The self-driving comparison has the same structure: per-mile rates can look excellent while the residual failures are the ones that make headlines. Two animation regressions in marketing sites and apps is a low-stakes error surface. Whether the same merge rate holds on infrastructure code, security-sensitive paths, or someone else's unfamiliar codebase is a question his stream doesn't answer, and he doesn't pretend it does.

There's also a quiet economics story underneath. Theo acknowledged that aggressive orchestration, agents spinning up sub-agents, "melts usage," and that he doesn't think "$20 tiers are viable anymore." He runs multiple accounts with custom load balancing to distribute quota. A workflow that requires a $200 monthly subscription per heavy user changes the calculus for teams on headcount.

The orchestration itself is the roadmap. T3 Code's upcoming Orchestrator V2, built largely by his colleague Julius, lets an agent spawn threads with other models, treat them as sub-agents, and coordinate results. Theo demonstrated an early build live: one agent opening a second thread, running a task, and reporting findings back, labeled as coming from another agent. The pattern echoes what's happening elsewhere in the industry, from Microsoft pushing autonomous agents into editors to scheduled agents running overnight jobs. His own framing of the shift: "The agent should come in earlier in your process and it should go longer before it bothers you."

He also flagged the commercial tension honestly. T3 Code wraps Claude Code and Codex, and he wants to avoid provoking Anthropic, whose bans on third-party tooling he attributes to quota abuse rather than principle. That dependency is a structural risk he can manage with popularity, in his telling, but not eliminate.

What the Melee Detour Shows

The stream's tangent, the 100% decompilation of Super Smash Bros. Melee, is more than a tangent. With the game's code fully reconstructed, recompilation for other platforms becomes possible, long-standing bugs fixable at the source, and the community's controller-compensation hacks replaceable with real fixes. Theo's read on why Nintendo's past hostility to the scene removes any deterrent now is characteristically blunt, and the broader point stands: decompilation is becoming the preservation path of least resistance for games trapped on dead hardware.

It's also worth noticing that he set an agent to compile the decompiled code and fork-and-improve a project in the background while filming, with explicit instructions not to file PRs upstream. That's the same workflow, applied to someone else's code, with the guardrails stated aloud.

The Open Questions

Theo's injury turned a productivity philosophy into a forced experiment, and the results cut in two directions. The direction he emphasizes: delegation beats typing, agents should own more of the task lifecycle, and the merge button is a smaller frontier than most developers assume. The direction he mentions only in passing: the gains ride on expensive subscriptions, unverifiable self-reporting, and goodwill from model providers who could change terms tomorrow.

Both can be true. The most honest read of the past month is that one-handed coding worked well enough to keep shipping, and that nobody yet knows how much of that success transfers to codebases, risk profiles, and bank accounts that look different from his. His own health carries the same uncertainty as his thesis: 50/50 on October. The next data point on both arrives at the same time.

Marcus Chen-Ramirez covers AI, software development, and who pays the costs.