T3 Code Is Promising But Not Ready for Your Workflow Yet

There's a particular type of disappointment that comes with testing new developer tools: the kind where you can see exactly what the creator was going for, appreciate the effort, and still have to conclude that it's not quite there yet. T3 Code, a new open-source GUI for Codex by Theo, lands squarely in this category.

AICodeKing, who claims to have tested "maybe more than 50 graphical interfaces by now," recently put T3 Code through its paces. His verdict? It's good in theory, buggy in practice, and facing stiff competition from tools that already do what it's trying to do—just better.

The Alpha Stage Isn't Just a Label

T3 Code comes in two flavors: a web server you can spin up with a simple command, or a desktop app. Both offer the same core experience, and in theory, the web version could be hosted on a server for remote access. The problem? There's no built-in security. AICodeKing notes you could slap an Nginx server in front of it for password protection, but that's asking users to DIY a pretty basic feature.

The desktop app is where things get interesting—and by interesting, I mean frustrating. Adding projects to T3 Code reveals some head-scratching design choices. The interface doesn't validate whether the folder you're adding actually exists. Type in a misspelled path, and it'll accept it cheerfully, only to throw a "simple Codex error" when you try to do anything.

"If you happen to add a misspelled folder or something then it won't give you any error or anything. It will get added and then when you send a message you get a simple Codex error and you'd have to figure out what's wrong yourself which is not very good to see," AICodeKing explains.

Worse, tilde paths don't work at all. On Unix-like systems, ~/project-name should expand to your home directory—basic shell behavior that developers expect. T3 Code just... doesn't handle it. You need the full absolute path or the directory picker. It's the kind of bug that makes you wonder if anyone tested this on an actual development machine.

What Works (When It Works)

Once you've wrestled a project into the interface, T3 Code does offer some legitimately useful features. It supports Git worktrees (parallel working directories from the same repository), branch switching, and toggles between plan and code modes. You can adjust reasoning effort settings and choose between full access or supervised mode—the standard agentic controls you'd expect.

The actions menu is actually clever: you can set up command sequences to run with a click, or automatically when creating a worktree. One-click commit-and-push is nice, though as AICodeKing points out, competitors like Conductor and Verdant already have this.

But here's where T3 Code falls apart: file change visibility. When the tool modifies a file, you get a notification that says "file change completed." That's it. No indication of which files changed, no diff view, nothing. There's supposedly a way to click and view changes, but AICodeKing reports it just throws an error—apparently dependent on Codex checkpoints that may or may not exist.

"I cannot know what files are being changed which is very weird," he says. For an agentic coding tool, being unable to see what the agent is actually doing to your codebase is... not ideal.

The Elephant in the Room: Better Alternatives Exist

This is where the landscape context matters. T3 Code isn't entering a vacuum—it's competing with tools that have already solved these problems.

AICodeKing gives honorable mention to Jean (by the developer of Kulifi), calling it "quite amazing actually" despite not having made a video about it yet. But his clear favorite is Verdant, which takes a fundamentally different approach.

Verdant doesn't wrap Codex or Claude Code—it has its own agentic harness. And according to someone who's tested dozens of these interfaces, it's "by a wide margin the best" for graphical agent interfaces. Why?

First, it's lightweight. Verdant idles at around 100MB of memory while T3 Code and Conductor both consume 200MB+. That might not sound like much, but when you're running multiple development tools simultaneously, every megabyte counts.

Second, it handles parallel workflows better. Verdant uses a browser-like interface where projects map to browser profiles, worktrees are like tabs, and you can run multiple threads within each worktree. "It flows with your brain correctly as most of us have used things like a browser for managing it," AICodeKing notes. The mental model matches existing patterns instead of forcing you to learn new ones.

Third, Verdant lets you edit files directly in the interface, stage changes, review code, and clean worktrees without context-switching to another editor. It's integrated in ways that T3 Code simply isn't yet.

Oh, and Verdant is also open-source.

The Open-Source Value Proposition

This raises an interesting question: what's T3 Code's hook? Its main selling point is being open-source, which matters—Conductor is proprietary, and having alternatives is healthy for the ecosystem. But when another open-source tool (Verdant) already does the job better, "at least it's open-source" becomes a pretty thin value proposition.

AICodeKing seems genuinely hopeful about T3 Code's future potential. Being open-source means the community could theoretically improve it, add features, fix the obvious bugs. But right now, those bugs aren't minor papercuts—they're workflow-breaking issues. No path validation, broken tilde expansion, invisible file changes, and non-functional diff views all compound into a tool that demands too much patience from users who have working alternatives.

"T3 code is good but has a long way to go for me to use it daily," AICodeKing concludes. "It is quite a bit buggy. It only has Codex which I don't use."

That last point is worth sitting with. The tool currently only supports Codex. AICodeKing doesn't use Codex. For him to even consider adopting T3 Code, it would need to 1) support models he actually uses, 2) fix all the current bugs, and 3) somehow differentiate itself from tools that already work well.

That's not a small ask for an alpha release.

Where Does This Leave Us?

The agentic coding tool space is getting crowded, and that's mostly good news. Competition drives innovation, and having multiple open-source options prevents lock-in to any single vendor's vision of how AI-assisted development should work.

But T3 Code highlights a tension in open-source development: releasing early to gather feedback versus releasing when the core experience actually works. Path handling and file change visibility aren't nice-to-haves—they're table stakes for a development tool. Shipping without them, even in alpha, risks poisoning the well. Developers who try T3 Code now might not give it a second look later, even after these issues are fixed.

Meanwhile, tools like Verdant are setting a high bar for what "production-ready" looks like in this space. Snappy performance, intuitive workflows, and robust file handling aren't aspirational goals—they're baseline expectations that existing tools already meet.

The good news? T3 Code is open-source and in active development. The bugs are fixable, the features are extendable, and there's clearly developer interest in building better interfaces for agentic coding. But right now, if you're looking for an actually usable agentic GUI, the reviewer who's tested 50+ options is pretty clear about where to look—and it's not here.

— Yuki Okonkwo, AI & Machine Learning Correspondent