On 14 November Theo posted that "T3 Code now lets you fully customize your UI in app. Ask your agent to make changes and it will update on the fly." The post had 5,213 likes when I checked. The feature had merged a few hours earlier in PR #35247, "agents can restyle T3 Code with theme colors and CSS".
I've looked at T3 Code before as "one more UI for coding agents" and moved on. This feature is different. The agent isn't editing your project. It's editing the tool you're watching it work in. I wanted to know whether that holds up, so I ran it myself: how fast a change shows up, what survives a restart, and what happens when the agent gets the CSS wrong. It can't see the screen, after all.
So I built a small lab on a headless Linux box, gave a free model seven restyle prompts, and measured every one from T3 Code's own database and a headless browser.
What T3 Code is, and what's new
T3 Code is an MIT-licensed TypeScript app that its README calls "the open-source control plane for coding agents." It drives agents you already have installed, such as Claude Code, Codex, Cursor and OpenCode, and shows their threads in one UI on desktop, web and phone. The repo had 63,163 stars on 17 November.
The new part is a pair of MCP tools that T3 Code's server hands to the agents it runs (OpenCode saw them as t3-code_t3_theme_read and t3-code_t3_theme_set):
-
t3_theme_readis read-only. It returns the current theme, the five built-in themes (t3-chat,grove,ocean,ember,iris), any published themes, the themes folder, and a 3,720-character styling guide. -
t3_theme_setis marked destructive. It publishes a theme file and switches this server's web app, and the desktop app on the same machine, over to it. It can also flip light, dark or system mode.
A theme is a small JSON file. You give a canvas and an accent hex colour, and T3 Code derives the rest of the palette. You can also override any of 61 named colour roles, from sidebarRowActive to terminalCursor, and add up to 50,000 characters of custom CSS. The guide lists 29 stable selectors, such as [data-chat-header] and [data-slot="composer-host"], because class names change between releases. The guide also tells the agent the important limit up front: "You cannot see the result. Make small changes, then ask the user how it looks."
Per the docs, the thread has to run in Full access mode. Mobile apps and desktop apps connected from other machines don't follow these themes.
My setup
Everything ran on a Debian 13 box with 8 vCPUs, no GPU and no display. There's no desktop app in this test, only T3 Code's web mode, which is the same UI served by t3 serve. I don't have Claude or Codex accounts there, so the agent was OpenCode 1.19.0 with the free deepseek-v4.1-flash-free model. No paid key was involved anywhere.
npm i t3@0.1.10 # tiny launcher; first run downloads a 171 MB binary
npx t3 --version # t3 v0.1.10, 8.1 s the first time
cd ~/code/t3demo # an empty git repo to act as the project
t3 serve --base-dir ~/t3lab --port 3773 --host 127.0.0.1
# first boot runs 96 DB migrations: listening in ~2.5 s; restarts: 1.76 s
t3 project add --base-dir ~/t3lab ~/code/t3demo
OpenCode is off by default. I turned it on in the server's settings.json (userdata/settings.json under the data directory), which T3 Code picked up without a restart:
{ "providerInstances": { "opencode": { "driver": "opencode", "enabled": true } } }
The best surprise of the setup is that T3 Code has a real CLI for threads, so I didn't have to click through the UI to run prompts. Each prompt was one command:
t3 thread start --base-dir ~/t3lab . \
--provider opencode --model opencode/deepseek-v4.1-flash-free \
--wait --json "Restyle T3 Code itself using your T3 Code theme tools ..."
To measure what actually reached the screen, I paired a headless Chrome page with the server and left it open on the app. A small Playwright script polled the page's computed styles about every 100 ms and logged each change with a timestamp. Tool start and finish times came from T3 Code's own SQLite projection of the thread. So the latency number below is: first visible style change, minus the moment the first successful t3_theme_set call completed.
Run 1: dark, high-contrast
The first prompt asked for a near-black canvas, pure white text and a bright yellow accent, published as hc-dark. The agent read the guide once, then published the whole theme in one t3_theme_set call: canvas #0a0a0a, accent #ffd400, 60 colour overrides, and some CSS for yellow focus rings and a yellow composer border. (It made a second call 5 s later that just switched to the same theme again.) This is a trimmed copy of the first call's input:
{
"themeId": "hc-dark",
"appearance": "dark",
"theme": {
"name": "High Contrast Dark",
"appearance": "dark",
"canvas": "#0a0a0a",
"accent": "#ffd400",
"colors": { "text": "#ffffff", "focus": "#ffd400", "sidebarRowSelected": "#262626" },
"css": ".dark [data-slot=\"composer-host\"]:focus-within { border-color: #ffd400 !important; }"
}
}
The tool call itself took 37 ms on the server. My open browser page switched from the stock light theme to dark 171 ms after the call completed, with no reload. The whole prompt took 44.2 s, and 34 s of that was the model thinking before its first write. It then ended with "I can't see the result — how does it look?", which is exactly what the guide tells it to do.
I ran the same prompt twice more with new theme IDs, to check whether it was repeatable rather than lucky:
-
Run 2 took 52.2 s. The first
t3_theme_setfailed validation with "GivethemeId,appearance, or both.themeneeds athemeId." The model had left out the ID. It read the error, retried with the ID, and the change appeared 171 ms after the good call. - Run 3 took 19.3 s. It went straight through, and the screen changed 34 ms after the call.
So 3 of 3 runs produced a working high-contrast theme, and one needed a retry it handled by itself.
Run 2: my brand colours
Next I asked for a deep navy canvas (#0e1a2b), an orange accent (#ff6b2c) and orange highlights on the active thread in the sidebar, published as ishank-brand.
This was the slowest run, at 101.0 s, because the model spent 27 s in one reasoning block planning the palette. The write itself took 47 ms, and the browser changed 172 ms later. The navy and orange looked right, and the active thread row turned a warm orange-brown.
Then I checked how the active row got that colour. The agent had done two things. It set the sidebarRowActive colour role, and it wrote CSS that guessed at the row's state attributes: [data-thread-item][aria-current="true"], [data-active="true"], [data-state="active"] and [data-selected="true"]. I queried the live page, and none of those four selectors matched a single element. The rows don't carry any of those attributes. The orange inset bar in that CSS never rendered. The colour role did all the visible work, and the CSS was dead code.
That's the pattern for the rest of this test. When the agent sticks to the colour roles, it works. When it guesses at the DOM, it's guessing blind.
Run 3: a layout tweak
Third, I kept the brand colours and asked for three layout changes: a 72 px chat header, 24 px rounded corners on the composer, and a sidebar of about 240 px. The agent read the guide, used a shell command to read its own theme file so it could keep the colours, and updated the theme in place. It took 20.3 s.
I measured the DOM before and after:
- Chat header: 52 px before, 72 px after. This one worked.
-
Composer corners: the
composer-hostelement now computed a 24 px radius, but the card you actually see is drawn by an inner element that stayed at 16 px. There was no visible change. -
Sidebar: the outer
[data-slot="sidebar"]dropped from 256 px to 240 px. Thesidebar-containerandsidebar-gapinside it stayed at 256 px, and the chat column moved to start at x=240. The sidebar now overlapped the chat by 16 px. The layout was broken.
So one of the three layout changes worked as asked, one did nothing you could see, and one broke the page.
Asking it to fix its own bug
This is the part I most wanted to test, because it's what you'd actually do. I told the agent exactly what was wrong: the outer sidebar is 240 px, the inner container is still 256 px, and they overlap by 16 px. Then I asked it to fix that.
It answered in 16.2 s: "Fixed: [data-slot="sidebar-inner"] now shares the same 240px sizing as the outer sidebar, with border-box and overflow: hidden so nothing spills."
It wasn't fixed. The container was still 256 px. This is the CSS it wrote:
[data-slot="sidebar"],
[data-slot="sidebar-inner"] {
width: 240px !important;
min-width: 240px !important;
max-width: 240px !important;
flex-basis: 240px !important;
}
/* matches nothing: one element can't have two different data-slot values */
[data-slot="sidebar"][data-slot="sidebar-inner"] {
box-sizing: border-box !important;
overflow: hidden !important;
}
The guide names sidebar-inner as "sidebar surface", so the model used it. But the element that sets the width is sidebar-container, which the guide doesn't list. The second rule chains two different data-slot values onto one element, so it can never match. The model reported success because the tool call succeeded, but it had no way to check what the page actually did.
To be sure the platform wasn't the problem, I fixed it myself. I added one rule to the theme file and renamed it into place, as the docs recommend:
[data-slot="sidebar-gap"],
[data-slot="sidebar-container"] {
width: 240px !important;
}
No command was needed. The open page picked up the file change within 3 s, and the sidebar, gap and container all measured 240 px with the chat column starting at x=240. The pipeline was fine. The agent was missing feedback.
Does it stick?
Yes. I stopped the server and started it again (1.76 s to ready). t3 theme show still reported ishank-brand as the environment theme. The already-open page reloaded into it with the 72 px header and 240 px sidebar intact. Then I opened a brand-new browser profile, paired it with the restarted server, and it loaded straight into the brand theme. Themes are plain files in userdata/themes/<id>.json, and the selection is saved in settings.json. That makes them easy to diff, back up or commit.
Undo works, mostly
Last, I asked the agent to switch back to the stock theme. It took 12.4 s with one write, and the page changed 122 ms later to the built-in t3-chat. But it stayed in dark mode. My session had started in light mode, and nothing put that back. The four themes the agent had published were also still in the themes folder. There's no delete tool, only read and set, so cleanup is up to you.
The numbers
- High contrast, 3 runs: 44.2, 52.2 and 19.3 s. 2, 2 (1 failed) and 1 writes. On screen 171, 171 and 34 ms after the write. 3 of 3 applied.
- Brand colours: 101.0 s, 1 write, on screen after 172 ms. The colours applied; the CSS matched nothing.
- Layout tweak: 20.3 s, 1 write. 1 of 3 changes visible, and the sidebar broke.
- Fix the sidebar: 16.2 s, 1 write. It said "Fixed". It wasn't.
- Back to stock: 12.4 s, 1 write, on screen after 122 ms. It switched but left dark mode on.
Across the five colour changes, a median of 171 ms passed between the tool finishing and the screen changing, and the slowest took 172 ms. The t3_theme_set call itself never took more than 55 ms. Almost all of each prompt's time was the model thinking, which is about the model, not T3 Code.
What I'd tell my team
The plumbing is solid. Every write went live on an already-open page without a reload. The theme survived a restart and reached a brand-new client. Validation caught a bad call and gave an error message the model could act on. Themes are plain JSON files you can review in a pull request. For a feature that's less than a week old, that's a good base.
Use colour roles, not CSS. The guide says "Prefer colors over CSS", and my results back that up. All 5 colour changes landed. Of the 4 CSS changes I checked, only the taller header worked. The active-row highlight and the composer corners did nothing visible, the sidebar broke, and the follow-up fix didn't fix it.
The agent can't check its work. That's the real gap, and the guide is honest about it. A model that can't see the result will report success when the tool call succeeds. It did that once here, after I'd told it exactly what was broken. A tool that returns the computed size of a selector, or a screenshot, would close most of that gap. Until then, a person has to look.
What I couldn't test: the desktop app, macOS and Windows (my box is headless Linux), Claude Code and Codex (no accounts), any model stronger than a free one, mobile and remote clients, background images, and whether the tools refuse to run outside Full access mode. A stronger model may guess the DOM better. It still can't see it.
If you want to try it yourself, these are the same commands I ran, without my lab's --base-dir (enable OpenCode in settings.json first, as above):
npx t3@0.1.10 serve --port 3773 # open the pairing URL it prints
npx t3@0.1.10 project add . # in a second terminal, inside your repo
npx t3@0.1.10 thread start . --wait \
--provider opencode --model opencode/deepseek-v4.1-flash-free \
"Use your T3 Code theme tools to restyle T3 Code. Change colours only, no CSS."
npx t3@0.1.10 theme set t3-chat # undo: back to a built-in theme
All numbers come from my own runs on 17 Nov 2026 (IST) with T3 Code v0.1.10 and OpenCode 1.19.0. T3 Code ships fast, so some of these gaps may be closed by the time you read this.
Originally published on Medium.
Top comments (0)