Control your AI coding agents from your phone.

What is this video about, in one paragraph?

Ray loves "touching grass" - being away from his desk - while still shipping software. His trick: AI coding agents (like Claude Code, Codex, Cursor, and Grok) that do the typing for him. His friend Korallis shows him T3 Code, a free app that lets you run and steer those agents on your own computers from your iPhone. By the end, Ray is sending coding tasks from his phone to his Mac Mini while watching it happen live. The rest of the video is them swapping power-user tips: skills, orchestration, model picks, and favorite tools.

What exactly is T3 Code?

T3 Code is a free, open-source app (in alpha, meaning early and still evolving) that gives you one clean control panel for all your AI coding agents, on all your machines. Ray describes it as "a baby Cursor" - it looks like a mini code editor, but its real job is remote control.

The problem it solves: coding agents like Claude Code or Codex normally run in a terminal on one computer. If you walk away, you can't see or steer them. Cloud services (like Cursor's cloud agents) solve this by running agents on their servers for a fee. T3 Code gives you the same superpower on hardware you already own, using the AI subscriptions you already pay for.

• Free and open source - the code is public on GitHub (not accepting outside pull requests yet).
• Runs on Mac, Linux, and iPhone - Korallis's main work machine is Linux; Ray uses Macs.
• It's an Electron app - the same app shell on desktop and phone, so updates land everywhere at once. A native Swift (Apple) version is in TestFlight.
• Your only limit is your subscriptions and imagination - it replicates the "cloud agents" experience with your own gear.

What do I need before I start?

Surprisingly little:

• One computer that stays on. A Mac Mini, an old laptop, or a Linux server. This is where the agents actually run. Korallis has a Mac Mini and a Linux server running 24/7; Ray has a Mac Mini plus two DGX Spark boxes (small AI computers that run Linux).
• Your phone (or iPad, or another laptop) with T3 Code installed and signed into the same account.
• At least one AI coding subscription - Claude Code, Codex (ChatGPT), Cursor, or Grok. T3 Code itself is free; it drives the subscriptions you already have.

How do I set it up? (The 5-step quick start)

The whole setup in the video takes about five minutes. Here's the recipe:

1. Install T3 Code on your computer and sign in. Do the same on your phone.
2. "Publish" the computer. In settings, turn on T3 Connect for that machine. Publishing means: "make this machine reachable from my other devices."
3. Connect devices. Under "All Environments," every machine you've signed into appears automatically. Click Connect next to the one you want. Ray's Mac Mini is named "Honu" - yours will show its own name.
4. Check your providers. Open the Providers tab. T3 Code auto-detects which AI tools (Claude, Codex, Cursor, Grok) are signed in on that machine. Toggle on the ones you want to use. It even auto-detects your connected GitHub for source control.
5. Open a project and prompt. Pick a folder on the remote machine (you can browse its disk from the app), choose your AI model, and type your first instruction - e.g. "Tell me what's going on in this repo. Do we have the latest changes?"

Which AI providers work with it - and can I use several at once?

Yes, and that's the point. Anyone serious about AI coding usually has more than one subscription. T3 Code connects to the big ones: Claude Code, Codex, Cursor's CLI, and Grok. It auto-detects whichever ones are signed in on each machine.

Two power features worth knowing:

• Multiple accounts per provider. Have two Claude or two ChatGPT subscriptions? Hit "+" again and connect both. More accounts = more parallel agents.
• Everything shows up in one sidebar. Instead of juggling separate terminal windows on different machines, every running agent session - on every machine - appears in one unified list.

How does the phone control actually work?

Once your machines are connected through T3 Connect, the session is live and mirrored: what you see on your phone is exactly what's on the desktop, in real time. Type a prompt on the phone and you can watch it appear on the computer screen. Korallis's verdict: 90% of his coding now happens from his iPhone, often from the couch while making dinner for his kids.

Details that make it feel polished:

• Push notifications. When an agent finishes a job, your phone taps you on the shoulder ("agent work completed") and drops you straight into that chat.
• Pick the machine per prompt. When you send a task, you choose which connected machine should run it - so a heavy build goes to the always-on Linux server while a quick fix stays on the laptop.
• You never lose the session. The agent keeps running on the machine even if you close the app or switch devices. The phone is just a window.

How do I keep dozens of agent chats organized?

Once you have several machines and projects running, the chat list fills up fast. T3 Code has three simple tools:

• Settle. Swipe left on a finished chat and hit "settle." It moves out of your active list into a done bucket, so only live work stays on top.
• Snooze. For a long-running job you want to check tomorrow, snooze hides it until you're ready.
• Filter by project. Each chat shows which project, model, and machine it's running on, and you can filter the list to one project at a time. It also shows which files each agent touched.

Can I see how much my agents are costing me?

Yes - there's a built-in usage view showing how many tokens each agent has burned. (A token is roughly a chunk of a word; AI models meter their work in tokens, and subscriptions include a lot of them.) It also shows your cache rate: when an agent re-uses earlier work instead of re-reading everything, those tokens are "cached" and cost far less. A high cache rate means your prompts are efficient.

The jaw-dropping number from the video: Korallis burned about $12,000 worth of API usage in seven days (really three) - all covered inside his flat monthly subscriptions. Ray's view already showed ~$109 in cache savings. Flat subscriptions + heavy use = the effective price per task drops toward zero.

What are "skills," and why does everyone keep mentioning them?

A skill is a small instruction file that teaches an AI agent a repeatable way of working. Korallis's definition: "A skill is simply a workflow that tells the AI: don't work the way you normally do - work this way instead." If a coding agent is a new employee, skills are the onboarding docs.

• How to use one: just name it in plain language - "use the codex-waves skill." No special syntax needed. (The old way - $skill or /skill - still exists, but differs per tool; naming it plainly works everywhere.)
• Global vs. project skills. Some skills apply everywhere (how you like code written); some belong to one project (a Swift app doesn't need TypeScript rules). Keep them separate so agents don't get confused.
• Cherry-pick, don't hoard. Popular skill repos can have 100+ skills where only five are good. Korallis's trick: paste the repo link to your agent and ask, "Which of these would actually benefit my projects?" It shortlists; you approve.
• The golden rule: "If I do something more than twice, I create a skill for it."

What is PStack and "potato mode"?

PStack is a famous, free skill collection by Lauren Tan (an engineer who worked at Meta and Netflix, maintains the React compiler, and works at Cursor). It encodes how a top engineer runs a whole software pipeline: planning the architecture, test-driven development, interrogating the code, reviewing PRs - as ready-made workflows. Ray calls the output quality jump "really amazing."

"Potato mode" is PStack's main entry point. You tell your agent "use potato mode," describe what you want, and it figures out which workflow to run - plan, build, test, review - and launches the right sub-agents for each step. You go from being a "prompt monkey" (Ray's words) to a manager giving one instruction.

• Originally Cursor-only; now open for everyone. A developer named Eric made an open-source version ("open PStack") that works with Claude Code and Codex too. In the video they install it by simply pasting the repo link to the agent and saying "set this up for me - I'm using T3 Code."
• Autopilot. Say "land everything on autopilot" and the agent merges work to main - running tests, reading PR comments, and fixing itself along the way.
• Automate-me. Show the agent how you test or check things once, and it captures your personal style into a new skill. Your habits become automation.
• Onslaught. A cleanup pass that strips the pile of comments some models love to leave all over your code.

How do the agents work together? (Orchestration)

Orchestration means one AI acts as the manager and delegates work to other AIs. In T3 Code, your chat window is the orchestrator: whichever model you pick there (Ray picks Claude Opus) reads your request and can spin up other models as sub-agents - for example sending bug fixes to Codex - then collect and combine their answers.

Two rules from the video:

• One chat = one orchestrator. You can't swap the orchestrating model mid-chat. For a new small task, settle the chat and start a fresh one.
• Different models for different jobs. Their shared setup: Claude Opus for planning and features, GPT for bug fixes and double-checking, Grok for fast everyday implementation. PStack stores this mapping in a config file so potato mode routes each step to the right model automatically - and for big decisions it convenes a "panel" of three agents that must agree.

How do I see my running app on my phone?

Building from a cafe is only fun if you can also see the result. Two options from the video:

• Deploy to a host (the common path). "90% of people deploy to Vercel anyway," Korallis notes - your agent builds and deploys, and you open the public link on your phone.
• Tunnel to your machine. Ask the agent for something like: "I want to reach localhost port 3000 on my Mac Mini from my phone on 4G." It can set up a free Cloudflare tunnel - a secure public URL that forwards to your machine - and hand you the link. No deployment needed for a quick check.

Can I look at files and code, or is it just chat?

T3 Code includes a mini-IDE: a file browser, a code viewer, and a real terminal for each connected machine - all inside the app, even on your phone. Ray's reaction: "It's literally like a mini IDE. It's really good." There's also a one-click "open in Cursor over SSH" button if you want the full desktop editor on the remote machine. Themes are supported, including importing VS Code themes.

Their philosophical take, though: "Who looks at code anymore?" The whole point of agentic coding is describing outcomes and reviewing results, not reading every line. (Korallis confesses he's still a Neovim terminal person at heart.)

How is this different from just using SSH?

SSH (Secure Shell) is the classic way to control a remote computer: a text terminal tunnel. Ray used to SSH from his phone with an app called Termius, and hated it - code formatting falls apart on a phone screen, and copying/pasting is painful ("I don't want to hit enter, I want a new line!"). T3 Code replaces that with a purpose-built interface: formatted conversations, file browsing, notifications.

But sometimes you still need a raw terminal on your phone. Korallis's recommendation: Moshi, an iPhone terminal app he calls "the best app on my phone" - polished scrolling, themes, image pasting, an Apple Watch companion, Hetzner support, and bring-your-own-key dictation. Free tier is genuinely enough for most people; the $200 lifetime unlock is for heavy multi-device users (install via the App Store, getmoshi.app, or Homebrew - and buying on the web skips Apple's 30% cut).

T3 Connect vs. Tailscale - what's the difference?

Both connect your devices, but they work differently. Tailscale is a private network (VPN): it makes your devices act like they're on the same home network. You can use T3 Code over Tailscale instead of T3 Connect. Korallis's experience: T3 Connect responds faster, and Tailscale dislikes multiple devices sharing the same port - his laptop and phone would kick each other off. His setup: 3 main machines on T3 Connect, 6 more via Tailscale - nine devices total.

What advanced tricks do they show? (Remote iOS builds, machines driving machines)

For app developers: with Xcode MCP installed, an agent on a remote Mac can build an iPhone app for you. (MCP - Model Context Protocol - is a standard plug that lets AI agents operate external tools; here, Apple's Xcode build system.) It gets gloriously meta: Ray has one Mac trigger a build on another Mac, driven from his phone - machines controlling machines.

Other wishlist items they give the T3 Code team (a contributor named Maria is live in the chat):

• ACP support (Agent Client Protocol) - would let T3 Code talk to almost any agent tool, including Pi and OMP, with live status. "ACP basically gives you everything."
• SSE streaming - watch the agent's raw working live, not just its final answer, so you can spot it drifting off-track early.
• Keychain access in the built-in browser - so agents can log into sites that expect your saved Mac passwords.
• A voice-mic button for dictating prompts, and fixing a bug where the "update available" popup doesn't actually update.

That whole stretch was a live Q&A with Maria - every item, translated into plain English with what it means for you, is in The Maria Q&A, translated below.

Which AI model should do which job?

This is the most "insider" part of the video - Korallis's personal casting call, refined over thousands of dollars of token burn (model names as of the video, August 2026):

• Claude Opus 5 (high, not extra-high) - the thinker. Planning, architecture, orchestration. High effort is plenty and burns far fewer tokens than extra-high. He prefers running it through the Pi/OMP harness rather than Claude Code itself.
• Grok - the workhorse. "It literally does 90% of my work" - everyday implementation that doesn't need deep thought.
• GPT (Sol) - the verifier and bug-fixer. Checks Opus's plans, fixes bugs, cross-examines the other models' work.
• Gemini 3.7 Flash - the PR reviewer. His accidental discovery: his daughter shouted "Gemini!" during a voice dictation, the tool misrouted his PR reviews to Gemini - and it outperformed everything. It caught bugs that GPT, Grok, and Cursor's Bug Bot all missed, thanks partly to its huge 1-million-token context window (it can hold an entire large PR at once; Grok's is ~100k+).

What is the "Lee Engineering" skill?

Korallis's own open-source skill (linked in the video description). Where PStack encodes workflows, Lee Engineering encodes his engineering values and model routing: which coding principles to follow, which models he currently has access to, and - clever bit - which ones still have usage left. It routes each task to whatever model is available and uncapped, "so it'll use something until it's got nothing left." His equivalent of potato mode is simply saying "use Lee Engineering."

Where do local, free models fit in?

A local model is an AI that runs on your own hardware - no subscription, no per-token cost, no data leaving your building. Korallis runs Qwen 3.8 on his own machine and Ray runs DeepSeek on his DGX Spark boxes. The strategy: don't spend premium tokens on cheap work.

• Documentation and PR write-ups go to Qwen. "Why should I waste a million tokens writing PR docs?"
• Reading huge codebases goes to the local model too: it chews through the code in small bites and writes summary files (summary.md, summary2.md...). The expensive model then reads only the summaries - full context of a 6-million-line codebase at a fraction of the cost.
• His agents also keep a local vector database (PG vector) - a searchable memory of everything he's ever built, so any agent can reference any of his past code instantly.

What happens with truly enormous codebases?

Even a 1-million-token context window taps out eventually. Korallis's legal-tech project is 29 million lines of code (5 million of it just workflow "harness" code); finding everything related to one feature in something like Apple's codebase could mean 15-20 million lines. No agent can read that in one go.

The fixes they discuss:

• RAG + a vector database: pre-index the codebase so the agent is pointed at the right files instead of wandering and reading everything. "It's instantaneous - go here, these are the files you want."
• Graphify (mentioned from chat): turns a codebase, docs, SQL schemas, and configs into a queryable knowledge graph - a map of how every piece connects - using local, deterministic AST parsing (reading the code's structure, not guessing).
• Specialist indexers: Korallis swears by Augment Code's codebase indexing ("insanely brilliant... no one uses it"), and both praise JetBrains IDEs' long-refined indexing.

The full play-by-play of this exchange, including how a vector database actually stores and finds code: the Graphify exchange, in detail. And the natural follow-up - how the index stays fresh as code changes daily: keeping the index fresh.

What do they say about the newest models and "harnesses"?

Quick hits from the shop-talk segment:

• GLM 5.3 - benchmarks place it above Claude Fable 5; Korallis only played with it for two hours, but "man, can it cook."
• Qwen 3.8 Flash - "very, very good"; his go-to for document conversion (Word/PDF work).
• On Anthropic "being cooked": Ray suspects the public gets noticeably nerfed models compared to what governments and select customers get behind closed doors - he watched Fable 5 bizarrely start adding emojis to his output right before the stream, while Opus behaved fine.
• The harness matters as much as the model. A harness is the wrapper around the model - its system prompt, tools, and rules (Claude Code, Codex, Pi, Cursor are all harnesses). The same model can behave terribly in one harness and brilliantly in another, because the harness's system prompt tweaks everything. That's why Korallis runs Opus through Pi, not Claude Code.

What is "Oh My Pi" (OMP)?

Pi is Korallis's favorite harness. Oh My Pi (omp.sh) is a ready-made, batteries-included Pi setup - "a coding agent with the IDE wired in" - built by a security researcher from the Netherlands. If you want a Pi configuration that's "insanely good straight out of the box," including Anthropic subscription wiring, this is his recommendation. It also has built-in language servers (LSPs - the same code-smarts engines IDEs use), search providers, and a collaboration feature where you share a link and someone else can watch your session live. Korallis published his own Firecrawl (web-search/scraping) plugin for it.

Two practical notes:

• Not yet in T3 Code - it needs ACP support, which is coming. Until then, he runs three OMP windows across three machines over SSH (via Moshi).
• The DIY remote setup: OMP + Tailscale on every device + Moshi on your phone approximates the whole T3 Code experience today.

"Does it support dynamic workflows?" - the answer that settles it

Korallis gets this question constantly, and his answer demystifies the whole field: a "dynamic workflow" is just a skill file. That's all it ever is - in Claude Code, in Codex, in every harness. If a harness doesn't ship the workflow you want, write a skill that describes it. "The harnesses are fully modular via the skill system... you can automate your entire life just via skills."

The agents.md trick (one file, every tool)

Most AI coding tools read a project instruction file called agents.md ("here's how this project works, here's how I want things done"). Claude Code is the odd one out - it only reads CLAUDE.md. Korallis's elegant fix: symlink it. A symlink (symbolic link) makes one file appear at a second path, so CLAUDE.md points at agents.md. Edit one file, every tool stays in sync - no copy-pasting, no drift.

What about Grok Bot? (Agents that run your life, not just your code)

A long, fascinating detour: Ray uses Grok Bot to run fleets of helper bots with almost no involvement. His coding bots talk to each other - one finds a bug, tells another, PRs get lined up and merged: "hundreds of messages have not involved me at all." He calls it his CI/CD pipeline with zero alerts.

His system for organizing bots - steal this:

• Think boardroom, not sessions. Don't run one endless mega-chat. Give each area of your life its own bot, like hiring advisors: a health bot, a "chief of staff," one per coding project.
• Three buckets: health, wealth, relationships ("relationships" = friends, family, life admin). New bot spins up whenever a new concern appears; big projects graduate into their own named group.
• Bots with separate concerns stay sharp. Each keeps its own context window lean, develops its own personality, and they brief each other in group chats when work overlaps.
• Korallis's version: his Grok Bot is wired into Microsoft Teams - it answers colleagues' feature requests, builds the feature, and reports back. "I don't think I've looked at my Teams in about two weeks."

Key concepts: the model, the harness, and the system prompt

Three words carry the whole back half of the video. Once these click, every "which tool should I use?" debate makes sense:

• The model (Claude, GPT, Grok, Gemini) is just an engine. It never reaches you raw.
• The harness is the app built around the engine - it decides the model's instructions, its tools, and its rules. Claude Code is a harness. Cursor is a harness. T3 Code is a harness. Pi is a harness.
• The system prompt is the harness's standing instruction sheet to the model - pages of "here's who you are, here's how you behave, here's what you never do." Every single answer is shaped by it, invisibly, before you type a word.

Korallis's point about Pi: in closed harnesses like Claude Code, that instruction sheet is locked - you get the behavior the vendor shipped, including the over-cautious bits (he calls models behaving this way "nerfed"). In an open harness like Pi / Oh My Pi, you can edit the instruction sheet yourself - tune the exact same model to behave the way you want. That is all "he uses Pi because you can tweak the system prompts" means: same brain, different personality, his hands on the dial. It's why his #1 setup is Opus running inside Oh My Pi instead of Claude Code. (More on harnesses: harness vs model and Oh My Pi.)

Key concepts: localhost, tunnels, and why your phone can't see your Mac

When your agent builds a web app on your Mac, it "runs" it at an address called localhost - which literally means this machine only. Your Mac can see it; your iPhone cannot, because as far as the internet is concerned, that address doesn't exist.

A Cloudflare tunnel fixes that: it creates a temporary public link (like https://something.trycloudflare.com) that quietly forwards to your Mac's localhost. Open that link on your iPhone from anywhere - 4G, a cafe - and you're looking at the app running on your Mac at home. Free, and no deployment needed. The home-base Mac does the work; the phone is just the window.

The other option (the one "90% of people" use) is deploying to a host like Vercel - a permanent public link instead of a temporary tunnel. Both paths, plus the exact prompt to give your agent, are in How do I see my running app on my phone?

The Maria Q&A, translated

Around 45 minutes in, the stream turns into a live Q&A: Maria - an engineer on Theo's team and a top-3 contributor to T3 Code - is in the chat answering questions and collecting feature requests, with Ray reading her messages aloud. Here's everything they covered (roughly 44:50-56:30), what each thing actually is, and what it would let you do. (One honest caveat: Maria's side exists only as chat messages read aloud, and the auto-captions there were extra-garbled - the meanings are solid, the exact wording isn't.)

1. ACP - the "universal adapter" they're all waiting for 46:26

ACP = Agent Client Protocol, an open standard (originally from the Zed editor team). Think of T3 Code as a power strip, and each harness (Claude Code, Pi, Codex) as an appliance with its own weird plug. Today, T3's team has to hand-build a socket for each appliance - that's why only a few tools work in it. ACP is everyone agreeing on one standard plug: any harness that adopts it works in T3 instantly, no custom wiring. That's why Korallis says "if you add ACP, it gives you basically any model you'd ever want" - including his beloved Pi harness, which T3 can't run today. Maria confirmed ACP is coming shortly, along with cross-provider orchestration - different AI brands coordinating on one task natively, instead of the duct-tape setup they rigged on stream.

What it means for you: today T3 works with a fixed list of tools. After ACP lands, new AI tools will work in T3 the day they come out - no waiting for T3 to add each one. (First mentioned in the advanced tricks section.)

2. SSE streaming - watching the agent think, live 47:48 56:16

SSE = Server-Sent Events, a standard way for a server to push live updates to an app. Right now, T3 shows you the agent's final answer - like getting a letter in the mail. Korallis wants the live play-by-play: every command and file edit as it happens, like watching over its shoulder. The point isn't entertainment - it's how you catch an agent "drifting" off the task early, instead of discovering 20 minutes later that it built the wrong thing. Maria said this will be supported first-party, and ACP makes it painless.

What it means for you: glance at your phone, see what your agent is doing right now, and stop it the moment it goes off track.

3. Xcode MCP + the iPhone simulator moment 48:31

Ray tried to demo his iPhone app and hit a wall: a macOS update had quietly uninstalled Xcode (Apple's app-building tool), so the remote build failed live on stream. The fix they discussed: Xcode MCP. (MCP = Model Context Protocol, a standard "tool socket" that lets an AI agent operate an external program.) Xcode MCP gives the agent hands inside Xcode: build the app, run tests, launch the iPhone simulator - all from a prompt. It even works machine-to-machine: one Mac triggering builds on another Mac, driven from a phone.

What it means for you: eventually, "build my app and run it in the simulator" from the sofa, on your old MacBook. It needs Xcode plus the MCP set up on the Mac first. (Also covered in remote iOS builds.)

4. The Keychain complaint 45:43

Keychain is your Mac's built-in password vault - the thing that autofills "Sign in with Google" and saved passwords. T3's built-in browser can't access it, so every login inside T3 is manual and painful. Korallis flagged it as needing a patch; Ray agreed.

What it means for you: nothing to do - just know that awkward logins inside T3's browser are a known bug, not you doing something wrong.

5. Voice-mic dictation 53:23

Someone asked for a mic button in T3 to speak prompts instead of typing. Maria's answer: they'd rather not build it in - use your phone keyboard's built-in dictation (or a tool like Whisper Flow) into the prompt box, so T3 stays lean instead of maintaining voice code.

What it means for you: same result, works today - dictate into the prompt box with your iPhone keyboard's mic.

6. The dead update button 50:37

Korallis's bug report: since the last T3 update, the "Claude Code needs updating / Codex needs updating" popup's Update button sometimes does nothing when clicked. Just a known bug, flagged to Maria on stream.

7. The free-tier machine limit is going up 53:23

Maria said they're trying to raise the free limit to five machines (it's effectively three today). She also confirmed T3 has no paid tier at all right now.

What it means for you: a typical setup - an old MacBook as home base, your main computer, and your iPhone - fits inside the free limit easily.

8. Grok Bot driving T3 52:42

Ray's dream request: let his life-organizing Grok Bot talk to T3 and just get work done - bots directing his coding agents without him in the middle. Maria's answer: there's a connector for it in the Providers tab. Korallis hadn't tested it yet. Early days, but that's where this is all heading. (More on Ray's bot system in the Grok Bot section.)

Korallis's tips & tricks, condensed

Every practical tip from the stream in one scannable list, grouped by theme. Where a tip has its own full section on this site, we link instead of repeating it.

The multi-machine setup 2:11 13:26

• Install every CLI (Grok, Claude, Codex, Cursor) on every machine - wire once, done.
• Full breakdowns: his home setup, piece by piece and the phone-to-CLI chain
• Always-on home bases: his Mac mini and Linux server run 24/7; he builds on two machines at once just by picking which 4:17
• 90% of his work is from his iPhone on the couch - the machines do the work, the phone is the remote.
• Connect multiple subscriptions of the same provider - two Claude accounts means more parallel agents 6:26
• Nine devices: the main 3 on T3 Connect (faster, more stable), 6 on Tailscale 52:00 - details in T3 Connect vs Tailscale
• Provider auth drops? Toggle it off/on in Providers, or log in via the built-in terminal - no screen sharing needed 23:19

Chat hygiene 14:07

• Swipe left to Settle finished chats so only active ones stay on top; Snooze slow multi-day plans.
• One chat = one orchestrator. New small task? Settle and start fresh 15:33 - full version in organizing chats

Skills - his core philosophy 16:16 1:46:57

• Invoke skills in plain English - "use the codex-waves skill," no special syntax.
• One prompt installs everywhere: "set this up on ALL my connected environments" 39:18
• Cherry-pick, never install a whole repo - paste a big skills repo into your agent and ask "which 5-6 would help my projects?" 40:48
• Skills are global or per-project - a Swift app gets Swift skills 41:29
• Golden rule: "If I do something more than twice, I create a skill for it."
• The agents.md symlink trick - symlink CLAUDE.md to agents.md so every tool reads one file. His "one final tip" 1:47:40 - walkthrough in the agents.md trick
• His "Lee Engineering" skill encodes all his coding principles and routes work to whichever subscription has headroom 1:13:52 - more in the Lee Engineering section

PStack 22:38

• Use Open PStack with Claude/Codex; tell it "I'm using T3 Code, route via my local CLIs," then just say "use potato mode."
• Combine with Matt Pocock's skills - his planning skill is "insanely good" 40:48 - full version in the PStack section

Model casting - his exact lineup 1:10:22 1:43:21

• Opus 5 (high, not extra-high) = the brain: planning and orchestration.
• Grok = the worker: 90% of implementation, cheap and fast 1:11:03
• GPT = bug fixing and cross-checking plans.
• Gemini 3.7 Flash = PR reviews via Cursor CLI - caught bugs across ~50 PRs that GPT, Grok AND Bugbot missed. Its 1M context eats huge PRs. His "extreme alpha" tip 1:11:44
• Golden rule: one model family writes, a different family reviews - never let a model grade its own homework.
• The harness matters as much as the model: his #1 setup is Opus 5 high inside Oh My Pi, not Claude Code 1:35:36 - deep dive in model picks

Tokens & local models 19:07

• He burned ~$12k of API value in days - all inside flat subscriptions. The subscription is the ceiling; burn through it fully.
• Watch the cache rate in T3's token view: high cache = efficient prompting 31:00 - explained in token usage
• Local Qwen for cheap stuff: docs, PR writeups, conversions - "why waste Claude tokens writing docs?" 1:15:59
• Huge codebases: a local model grinds through writing summary files; the expensive model reads just the summaries - full context of 6M lines for pennies 1:16:42 - more in local models

Big codebases 1:21:35

• His legal project is 29M lines - even a 1M-token window fails; use RAG + a vector DB to point agents at the right files.
• He keeps a vector DB of everything he's ever built 1:19:29
• Best indexer he's seen: Augment Code 1:23:39 - full version in huge-codebase strategies

Oh My Pi - his favorite harness 1:36:18

• omp.sh - great out of the box, works with the Anthropic subscription; install it alongside PStack + skills "and you won't go wrong."
• He runs THREE OMP windows building three things on three machines at once 1:39:48
• Uses Firecrawl (his own plugin) for all agent web searches 1:39:05 - full version in the Oh My Pi section

Phone terminal & remote iOS builds 1:26:25

• SSH from the phone = the Moshi app; the free tier is enough - covered in SSH & Moshi
• Remote iOS builds: Xcode MCP inside the CLIs, trigger builds from anywhere - even Mac-triggers-another-Mac 49:14 - covered in advanced tricks

Life automation 42:50

• He built six features from a Starbucks, on his phone.
• Cloudflare tunnel previews - just ask the agent for a localhost link 43:33 - explained in localhost & tunnels
• Grok Bot wired into Microsoft Teams handles all his work messages - "I don't think I've looked at my Teams in about two weeks" 1:04:47

Ray's own tips 35:52 1:03:23

• PStack's "autopilot" (lands work on main, self-fixes), "automate-me" (watches how you test and turns it into a skill), and "onslaught" (strips comment spam).
• The life-as-boardroom bot system: health, wealth, relationships - one bot each, and they brief each other. Full story in the Grok Bot section.

Korallis's home setup, piece by piece

The stream mentions his setup in passing; here it is assembled in one place. Three parts: the machines, the network, and what runs on them.

The machines 4:17 13:26

• A Mac mini that runs 24/7 - always on, never sleeps.
• A Linux server, also 24/7.
• His iPhone, which is where he actually sits: he says 90% of his coding is done from the couch on his phone. The machines do the work; the phone is the remote control.

The network 52:00

• He has nine devices connected in total.
• The main 3 go through T3 Connect - T3 Code's own built-in connection, set up with a few taps in settings; faster and more stable.
• The other 6 sit on Tailscale, a private-network tool that makes devices reachable from anywhere as if they were on the same home WiFi. (Full comparison: T3 Connect vs Tailscale.)
• Once connected, every machine shows up in a list inside T3 Code. When he gives a prompt, he picks which machine runs it - so he can build on two machines at the same time.

What runs on the machines 2:11 6:26

• Every machine has all four AI CLIs installed: Grok, Claude Code, Codex, and Cursor. Wire them once; after that any machine can run any tool.
• He connects two Claude accounts and two GPT accounts at the same time - more subscriptions means more agents working in parallel.
• For his favorite harness (Pi / Oh My Pi), which T3 can't drive yet, he does it manually: three OMP terminal windows open across the three machines, connected over SSH, driven from his phone with the Moshi app. (Details: SSH & Moshi and Oh My Pi.)

Why it's set up this way

His example: you're at the beach, an idea hits, you open your phone, type the prompt, and your always-on machines at home start working. The Mac mini and Linux server never turn off, so work continues whether he's watching or not.

The phone-to-CLI chain: how a prompt from the couch reaches the right machine

When Korallis says "every machine has all the CLIs installed," this is the full mechanics of what that means and how the phone talks to them.

1. Install the CLIs on each machine. A CLI is the command-line version of an AI tool - Claude Code, Codex, Grok, Cursor. Each is a small program you normally drive by typing in that computer's terminal. He installed all four on the Mac mini, then all four on the Linux server. Each machine has its own copy, with its own logged-in subscriptions. Nothing is shared between machines automatically.
2. Install T3 Code on each machine. T3 Code scans the machine it's on and detects which CLIs are present - "Claude Code is here, Codex is here." From that moment it can launch and drive them. This is the step that makes the CLIs remote-controllable.
3. Connect the phone. T3 Code on the phone reaches each machine over T3 Connect (or Tailscale). Setup details are in the setup section.
4. Pick the machine and the tool from dropdowns - not in the prompt text. Before typing anything, you pick two things in the app's interface: which machine (your connected devices show up in a list; Ray's Mac mini showed up as "Honu") and which provider/model (Claude, Codex, Grok - whatever is installed on that machine). Then your prompt is plain English: "pull the latest and run the build."

The full chain:

The design rule: the prompt describes WHAT you want done; the app controls WHERE and WITH WHAT it runs. You never write "run this on my Mac mini using Claude" in the text itself.

The one exception: for setup, a single prompt can hit every machine at once - "set this up on ALL my connected environments" rolls an install out everywhere in one go. That's for setup, not daily use.

The Graphify exchange: vector databases and huge codebases, in detail

Around 1:18:35 Ray asks Korallis about Graphify - a tool that turns a codebase (plus its docs, SQL schemas, configs, even PDFs) into a queryable "knowledge graph" using local AST parsing. AST is the code's grammar tree, so the tool maps how every file and function connects without an AI having to read everything. Here is the whole exchange, and what to take from it.

What Korallis runs instead 1:18:46

He hasn't used Graphify, but he runs his own version of the idea: a local PG vector database (Postgres with a vector add-on) that stores everything he's ever built. His local models (Qwen, DeepSeek) query it, so at any moment they can reference any of his codebases without re-reading the code.

Why "just hold it all in memory" fails 1:18:35 1:20:37

• Ray asks: couldn't you keep it all in the context window? Korallis: no. At 6-10 million lines of code, not even a 1M-token context window comes close.
• The key insight: finding things isn't the hard part - refactoring is. His example: "find all the code related to over-the-air updates" in something like Apple's codebase touches 15-20M lines.
• His own legal-tech system is 29M lines, and just the workflow-enforcement part is 5M. Hand that to an agent raw and it chokes - it has to spawn sub-agents, summarize in layers, and still loses the plot.

The best-practice ladder that comes out of it

1. Most apps (under ~1M lines): a normal agent handles those fine. You don't need any of this yet.
2. Middle ground 1:16:42: let a cheap local model read the codebase in small chunks and write summary files (summary.md, summary2.md...). The expensive model reads the summaries and gets full context for pennies.
3. Truly huge codebases: vector database + RAG. Instead of the agent hunting file by file, the database instantly answers "these are the exact files you need" - no wandering, no wasted tokens.
4. Off-the-shelf pick 1:23:39: the best codebase indexing he has ever seen is Augment Code - "a tool no one uses" that nailed it ("insanely brilliant"). JetBrains' IDE indexer got an honorable mention too. If your AI tool keeps missing things in a big project, that's the specialist to look at; at typical project sizes you won't need it.

Keeping the index fresh: how re-indexing works

The rule: you never rebuild the whole database. You re-index incrementally.

1. Every chunk's embedding is stored with a stamp of the file it came from - a hash of the file's exact contents (often the git blob hash).
2. When you change code, git knows precisely which files changed. The indexer compares each file against its stored stamp: same stamp, skip it; different stamp, re-process that file.
3. Only the changed files get re-embedded. Edit 3 files out of 50,000 and only those 3 are re-processed; everything untouched keeps its old embeddings. Seconds, not hours.

When does it run? Three common triggers

• On every commit - a git hook (a tiny script in the repo's .git/hooks folder) fires the indexer automatically.
• On every save - a file watcher notices the change instantly. This is how tools like Cursor and Augment stay live.
• On a schedule - a background job sweeps for changes every few minutes.

At Korallis's scale (29M lines, changing daily), commit-triggered or watcher-style is the way. Full rebuilds basically only happen when you change how you chunk or embed, not when code changes. The result: the index follows your git history, and the daily cost stays tiny because daily changes touch a tiny fraction of the code.

How to get this, two paths

1. Use a tool where it's built in (zero setup). Tools like Cursor and Augment Code index your project in the background and keep watching for changes on their own. This is what Korallis meant when he said Augment "nailed" codebase indexing.
2. Build your own (the PG vector route from the video): write an indexer script (scan the project, split code into chunks, embed, store with file stamps); make it skip unchanged files; attach it to a trigger (a git hook or a file watcher); then point your agent at the database, usually via an MCP server. Ready-made open-source projects cover most of this.

Jargon buster: every term they throw around

The video assumes you speak fluent AI-engineer. Here's the translation:

The cheat sheet: everything worth remembering

Everything mentioned in the video, linked

• The video itself - "My Friend Walks Me Through T3 Code on Mac and iPhone" by Ray Fernando (Aug 28, 2026)
• T3 Code - free, open source; search "T3 Code" on GitHub (100% open, not taking PRs yet)
• PStack - Lauren Tan's skill collection; "open PStack" is the community fork for Claude Code + Codex
• Lee Engineering - Korallis's skill for engineering principles + usage-aware model routing (linked in the video description)
• Oh My Pi - omp.sh, the ready-made Pi harness setup
• Moshi - getmoshi.app, the iPhone terminal (free tier fine; $200 lifetime for power users)
• Graphify - codebase-to-knowledge-graph tool (GitHub)
• Augment Code - Korallis's pick for best-in-class codebase indexing
• Ray's free community - rfer.me/start