From Claude Code to T3 Code, without leaving Claude

I didn't switch models. This post is about switching the window I look at them through.

I've been a terminal user for a long time, and that's where I ran Claude Code from June on. The commit log on this site has co-author lines from six Claude models since then, from Opus 4.8 to Opus 5.5. A month ago I moved to T3 Code. It has nine of my projects in it now, and I've opened 196 threads there, every one of them on Claude.

What got me to try T3 Code was Theo, who makes it. I've followed his work on YouTube and X for a while, and his content is the reason I gave it a go.

Two practical things pushed me to switch. I was running too many sessions at once, across too many repos, and terminal tabs aren't a good way to keep track of that. And I was reviewing agent diffs in terminal scrollback, which is a bad place to read code.

This is the how-to I'd have wanted on day one, plus the part I added a month in: the iPhone app and its Live Activity.

What T3 Code is, and what it isn't

T3 Code is an open-source (MIT) app from Theo and the team at Ping. Its README calls it an "agent harness control surface". It doesn't ship a model and it isn't a new agent. It drives the agents already installed on your machine (Claude Code, Codex, Cursor, OpenCode and a few others) using the subscriptions you already pay for. There's a desktop app, a web app, and iOS and Android apps.

For Claude, that means it uses Claude Code's own login and configuration. That one fact is why the move is cheap.

It's early software, and the README says so plainly: expect bugs.

1. Keep Claude Code installed and signed in

T3 Code looks for the claude binary and the credentials it already has. If Claude Code works in your terminal, this step is done. If not:

claude auth login

If you use two Claude accounts, say work and personal, give each its own config directory with CLAUDE_CONFIG_DIR and add each one as a separate instance in T3 Code. Don't do it by changing HOME: the credentials end up somewhere the provider won't look.

2. Install T3 Code

On macOS:

brew install --cask t3-code

Or install the CLI, which starts a local server and opens the web app:

curl -fsSL https://t3.codes/install.sh | sh
t3

To try it without installing anything, npx t3@latest works too. Then add a project by pointing it at a repo folder.

3. Check what came with you

This is where I expected to lose an afternoon, and didn't. Because T3 Code runs Claude through Claude Code's own harness, everything I'd built around the CLI was there in the first thread:

• CLAUDE.md files. My global ~/.claude/CLAUDE.md (Tailwind v4, always) and this repo's CLAUDE.md both load like before.

• Skills. Personal ones from ~/.claude/skills and repo ones from .claude/skills. If both define a skill with the same name, the one in your config directory wins. Skills you've disabled in Claude's settings stay out of the composer, and enabled plugins add theirs.

• MCP servers. The Hygraph server I set up for Claude Code is how this post got into the CMS. It was drafted in a T3 Code thread and saved as a Hygraph draft over MCP.

• Memory. Claude's project memory came along too, so decisions from earlier CLI sessions were still there.

The quickest check: open a thread in a repo and ask the agent which instructions and tools it can see. If it lists your CLAUDE.md rules and your MCP servers, your setup made it.

4. Pick your permission mode on purpose

You pick a permission mode per thread in the composer, and set the default under Settings → General → New threads. They line up with Claude Code's modes roughly like this:

• Supervised is default: it asks before running commands or changing files.

• Auto-accept edits is acceptEdits.

• Auto is auto: Claude's automatic review approves routine actions and asks you about the rest.

• Full access is bypassPermissions. It's the starting default, so change it if that's not how you work.

Claude Code's read-only plan mode has no match in that list. And Full access doesn't override Claude's own settings: if they turn off bypass or require approval for an action, you still get asked.

5. Set a default model per project

Project settings can pin a model and its options. Mine for this repo is Claude Opus 5.5 at high effort, starred as a favourite so it's one click away in any thread. A new thread keeps your current model and mode, unless the project you open it in has its own default. For a model that isn't in the picker, add its full ID under Add custom model. Custom models may get fewer effort and context controls.

Juggling sessions: threads instead of tabs

This was the first reason I switched, and it's where the app earns its place.

• One thread per task. Each thread sits in the sidebar under its project, so nine repos don't turn into a wall of identical terminal tabs.

• New worktree. When a task needs its own branch and working directory, start the thread in a new worktree. Two agents on the same repo stop stepping on each other.

• Cmd+Enter to queue the next one. It starts the thread and opens a fresh draft right away, so you can hand out several tasks in a row. With New worktree on, each one gets its own.

• Pin what matters. Pinned threads stay above active work. The order is saved on the server, so it's the same on desktop and phone.

• One prompt, several models. Shift-click models in the picker and each gets its own thread and worktree. Handy for comparing two models on the same task.

Reviewing diffs and PRs

The second reason. Reading diffs in terminal scrollback was the weakest part of my old loop.

• Per-turn diffs. Each turn's changed-files list shows only the edits, commits and conflict fixes from that turn, not whatever got pulled in. A branch comparison shows everything against the base.

• Commit, push and open a PR from the thread. T3 Code can write the commit message and PR description from what the thread did and the checks it ran. Turn on Repository conventions and it follows your project instructions and recent commit subjects, which matters if you care what your log looks like.

• A Pull requests page. Review changes and comments, request reviewers, check out branches and merge without leaving the app. Files you mark as viewed sync back to github.com.

• Stacks. Stacked PRs show their position in the stack, with Merge stack and Rebase stack actions.

GitHub auth comes from a token in Settings, then GH_TOKEN, then the GitHub CLI (2.81.0 or later). If you already use gh, it just works.

On the iPhone: T3 Connect and a Live Activity

The iPhone app is a remote. The projects, Claude's login and the agents stay on the machine that runs T3 Code, and the phone connects to it, so that machine has to stay on and awake while you work.

Turn on T3 Connect on the machine

T3 Connect makes the machine reachable from your other devices without touching your router. In the desktop app, open Settings → Connections, sign in, and enable T3 Connect for that environment. On a machine that runs the CLI:

t3 connect

Signing in alone doesn't make the machine reachable. Accept the background service the setup offers, or start the server with t3 serve.

Pair the iPhone

Install T3 Code from the App Store, sign in to the same T3 Connect account, and choose the environment. That's the whole pairing, and it's how my iPhone got on, a month after my first thread.

Once connected, the app also learns the machine's LAN and Tailscale addresses and saves them as extra routes. It uses the first route that answers, so at home it talks to the machine over your network, and away from home it falls back to T3 Connect. The LAN route needs Network access turned on in the machine's Settings → Connections.

You can skip T3 Connect and pair over the LAN or Tailscale with a QR code from t3 pair. But notifications and the Live Activity are pushed through T3 Connect, and a direct connection alone won't get them.

If the phone can't connect, open the environment's Details in the app's connection settings. It checks the four hops in order (this device, T3 Connect, the machine's tunnel, T3 Code on the machine) and marks the first one that failed. t3 connect status runs the same check from the machine's side. Two less obvious causes from the troubleshooting doc: Connectivity Assist in the iPhone's Wi-Fi settings, and a clock that's a few minutes off on either device.

What the phone can do

• Threads. Open any thread and send messages. Offline, you can still write and queue them; drafts and queued messages survive app restarts.

• Approvals and questions. When an agent asks for permission, the thread shows a card with Allow once, Allow session and Decline. Questions get their own card to answer.

• Pull requests. Reviews from all your environments in one list. Read the description, activity, commits and changed files, leave line comments (they stay drafts until you submit the review), mark files viewed, or tap Work on PR to open a thread with the review attached. Anything you've loaded stays readable offline.

• Voice. On supported iPhones with iOS 26 or later, the composer's microphone transcribes on the device, and you edit the text before sending.

• Updates. Pick the machine under Settings → Environments and tap Check for updates to update T3 Code on it from the phone.

Turn on the Live Activity

In the app, open Settings → Notifications and enable both:

• Device Notifications sends an alert when an agent finishes, fails, needs approval or asks for input. Tapping it opens the thread.

• Live Activity Updates keeps one Live Activity on the Lock Screen and in the Dynamic Island that follows your agents without opening the app.

Turning on Live Activity Updates also switches it on for each linked environment you're allowed to configure. Ordinary alerts stay quiet while the app is open, but the Live Activity keeps updating. Reading a thread on another device doesn't silence the phone.

What the Live Activity shows

It's one Live Activity for all your agents, not one per thread. Each thread in it has a status: Connecting, Working, Approval, Input, Done or Failed. Threads waiting on you sort first, then failures, then the ones still working.

That's mine, in the Dynamic Island's compact view. The T3 mark sits on the left. The 2 is the number of agents at work, and that badge only shows while none of them is waiting on you. When one needs an approval or an answer, the right side reads Approval or Input instead, and once everything has finished it reads Done or Failed. The colour follows the most urgent thread: blue for working, amber for an approval, indigo for a question, red for a failure, green when done. Tapping it opens the thread that needs you, or the top one if none does.

Expanded, the island shows the count and the top three threads, each with its title, project and status. The Lock Screen version lists up to five under a header like "2 active agents · 1 needs attention". Finished results stay visible for up to 15 minutes. If updates stop arriving, threads that were still running switch to "Out of date" instead of claiming an agent is still at work.

One thing may look different on your phone: on 24 October the app's source swapped that count for a quieter working glyph, keeping the labels for when something needs you. Newer builds may show the glyph.

A checklist for the switch

1. Confirm claude works in your terminal and you're signed in.

2. Install T3 Code and add your repos as projects.

3. Open a thread and check that your CLAUDE.md, skills and MCP servers show up.

4. Set the default permission mode yourself, since it starts at Full access.

5. Pin a default model and effort per project.

6. Use New worktree for anything that runs alongside another task.

7. Sign in to gh so the PR features work.

8. Turn on T3 Connect on the machine, then sign in to the same account in the iPhone app.

9. Enable Device Notifications and Live Activity Updates in the app's Settings → Notifications.

Same Claude, different desk

Nothing about how the model works changed. The skills, the instructions and the verification loop from an earlier post are still files in the repo, and they still do the work. What changed is that I can see all of it at once: which threads are running, which are waiting on me, and what each one changed. The first two now fit in the Dynamic Island.

If your Claude Code setup lives in files, and it should, moving it is mostly installing an app.

That's the move. A deeper post on T3 Code is coming, and it picks up where this one stops.