This is a video I never wanted to make,

but the more I think about it, the more

I feel like I kind of have to because if

I'm being realistic with you guys, I've

always been a terminal first person. I

know, I know I'm the vibe coding soy boy

JavaScript guy that's always plugging

things in VS Code and invested in a VS

Code fork, but I am not that at heart. I

do like being able to scroll around code

and click and select things with a

trackpad or a mouse, but generally for

my day-to-day work, I was always in a

terminal. I've been a big terminal nerd

since before I even wrote code. I was

using them to host my Minecraft servers,

to SSH into computers all over the world

and do all sorts of fun, crazy things. I

had a deeply modified GNU screen config

that I put a lot of time into before I

started moving over to T-Mox because I'm

old enough that GNU screen was still the

standard when I started. I have been

using terminals for the majority of my

life. Since I was 13, I've spent most of

my time running, working, auditing, and

doing my day-to-day stuff inside of my

terminal. And that's just not the case

anymore. I had a moment a few days ago

where I was getting a bunch of work done

and I started commanding to try and find

my terminal and I couldn't find it

because I had done a reboot and not

opened up my terminal because I didn't

need it for like eight plus hours. And

that's when it hit me. I'm not doing my

work in a terminal anymore. And I

really, really need to talk about why.

Before I can do that, we're gonna have

to take a quick break for today's

sponsor. When I'm working on a new

project and it's time to go live, the

first thing I do every single time is I

put it up on GitHub. But right after

that, I use today's sponsor, Blacksmith,

because as soon as I want real CI, I

don't want to deal with GitHub actions

anymore. If all I got from Blacksmith

was the better speed, it would be worth

it. If all I got from Blacksmith was the

cheaper price, it would be worth it. If

all I got from Blacksmith was the four

times faster cache downloads, it would

still be worth it. But that's not all

you're getting. You also get the best

observability I've ever seen into what

your CI is actually doing. What jobs are

passing? What jobs are failing? Where

are they coming from? Where's time being

spent on projects like T3 Code, this is

so helpful. Trying to figure out why our

CI is slow and fixing it has never been

easier. It's fast by default, but you

can get even faster when you can do

things like SSH into the box and see

what's up or use an actual native MacR

runner for your Mac builds like we have

to for our iOS and Mac apps. It's

honestly gotten hard doing those time

comparisons because I haven't chosen to

use GitHub actions in months. Save

stress, time, and money on your actions

at soy.link/blacksmith.

I already know how this one's going to

go. There's going to be endless bias

accusations of, "Oh, Theo's just here to

plug T3 code. He's [ __ ] on terminals

so that he can plug his own thing." Oh,

do you mean this open- source thing that

I spent a shitload of money and time

building because I so deeply believe the

terminal is the wrong place? If you

think T3 code is the reason I'm doing

this, your reasoning is worse than

Sonnet 4s is because this is obviously a

thing I built because of my beliefs, not

I'm lying about my beliefs because I

built this thing. That obviously doesn't

make sense. I wish you guys would just

use your brains a little more before

leaving those shitty comments. I'm sure

there's already a hundred of them plus.

Scroll through the Obsidian ones and I'm

sure you'll find plenty about how I'm

just plugging my own [ __ ] But in order

to skirt those accusations for now, I

will switch to Chat GBT. So, here we

are. An app I haven't used in a while. I

just had to update it cuz I haven't been

in it as much, but it still is, in my

opinion, one of the best starting points

for a developer who is moving into

coding more with AI. While the Codex app

was the big thing that pushed me over on

this belief that terminals were just not

the right place to be coding anymore, it

was not the start of my journey here.

The place that I started thinking about

this most is honestly kind of

embarrassing and I even feel bad putting

it in here. I I feel sick even typing

it. Oh god, just can Can I delete it

now? Do I do I have to leave this word

on the screen? I'd really like to just

hide this. I'm just going to get rid of

that. Okay. Really though, when I first

tried out anti-gravity, I was mostly

unimpressed. But there was one

particular piece that impressed me.

There was a hotkey that opened up the

agent manager view that let you see what

the agents were doing across different

instances of anti-gravity. So if you

have like three windows open for three

different projects, you could have this

one window on top that showed you what

was going on with agents in each of

those other projects. It was a left

sidebar with projects that had threads

in each project that you could see from

one external view. Huh, sounds familiar.

Interesting. As much as I don't want to

admit it, the anti-gravity agent manager

was one of the first times I experienced

that. And if anti-gravity wasn't such a

[ __ ] show, I probably would have

actually used it a bit. I even said as

much in my coverage of anti-gravity when

it dropped. But what's much more

exciting to me is the new agent manager

workflow. I think this is a great idea

and there's a lot of little pieces that

I'm hyped about. So, anti-gravity was

the first step in my descent as I

realized that the terminal was not the

right place to do this anymore. Funny

enough, just a few weeks prior, I was at

the cursor office complaining to them

that all their new integrations with the

cursor v2 agent view made it too hard

for me to use my terminal because they

made it way too annoying to like get the

path that a work tree was in. So I could

cd into it in my terminal and then run

things. Because a flow I often had is I

would use cursor. I would open up

something in the sidebar, tell it to go

do something, get a result, want to go

check it, and then have to find some way

to CD into that path for the work tree

in order to run it, install things, and

do stuff. And the built-in terminal was

no, not happening, especially at that

point in time. So, I ended up bullying

them enough to give me the one-click

copy buttons that I needed in order to

keep using my terminal for the actual

doing things beyond sending prompts. And

I got to the point where I would use

cursor to send a prompt and then my

terminal to do everything from reviewing

the diffs, reading git history,

investigating changes, actually running

the code and doing things. And I was

split like 50/50 between I would be in

the cursor app for prompting and that

would be my terminal for everything

else, especially git stuff. I did all of

my git through the stock bog standard

git commands. Occasionally I would add

like oneliner helpers to do things like

commit and push with one line stuff like

that. But for the most part I just used

stock git cli. I need to get this

anti-gravity thing off the screen. It's

going to hurt me. But then the models

got better and importantly the codeex

app came out. And when I started using

this, my beliefs that I had from

anti-gravity saying that this is

horrible, but it's also kind of the

future got me really excited. And the

more I played with it, the more

impressed I was. The ability to just

break your work up into different

projects and clearly see what's going on

in them. to have multiple things going

at the same time all in their own work

trees. The ability to quickly open up a

terminal and type things in here if you

need for whatever stuff that you're

doing. I got to the point where I was

still looking at my git history through

the terminal inside of my codeex

instance and it was solid. It was

actually quite good. And in a world

where I was using my terminal more and

more because I had at this point moved

to cloud code and was constantly running

cloud code in my terminal, opening lots

of terminals, using awesome tools like

cmx, which I still highly recommend to

manage all of my different things going

on. I was still a big T-Max guy. I was

still a very deep big T-m guy. I only

started using tabs in my terminal at the

start of this year as like a personal

challenge when I set up a new computer

to see if I could finally move off

T-Mux. The answer was no spoiler, but I

I tried. So, I went through all of that

and then the Codeex app dropped and I

was like, wait, I can just screenshot

something and paste it and see it. I can

select text and copy it and paste it and

the formatting is not broken. I can

scroll and it doesn't lag a whole bunch.

And most importantly, by far, I can hop

between different things easily by just

clicking. I know this sounds silly and

dumb, but when you're working on three

plus things at a time, it's just a

couple too many hot keys in T-Max. And

keeping track of what is where is even

more annoying. You have to remember

which hotkey goes to which thing. And

then you start building systems in your

head for these three panels are for

these three things. This fourth panel is

for this thing. This fifth panel is the

flex panel. I use it for whatever. But

then you end up with a sixth task and

your whole model breaks down. I tried my

hardest to figure this out. And again,

to their credit, Semox got the closest

anything has gotten to figuring this

out. By giving you a sidebar similar to

what you get out of something like the

Codeex app, but also just giving you a

terminal on the other side. It's great

and it's still my default terminal. In

fact, all the boxes I SSH into, I have

in a little folder called SSH, so I can

have all of these connected and quickly

hop into them at any point. But man,

having a real UI with text that was more

pleasant to read with much easier to

navigate and find things with a category

system that made sense, having actual

projects that are based on where things

are in your computer, it just it made me

code way more. But one of the biggest

problems I had with Codeex is that it

was closed source. So when it did have

regressions or problems or things that I

wanted to fix, it just wasn't super

realistic. I was able to bug the Codex

team a bunch. And thank you to my

friends over at OpenAI. You guys have

been awesome about taking all of my

feedback and addressing it meaningfully

and swiftly. But there would still just

be random regressions and changes and

things like the merge into chat GPT.

Like this is no longer Codex. This is

now chat GPT. They let you use the old

icon thankfully, but like this is now

the chat GPT app. Because the Codex app

was so good, it made these tools

accessible to people who weren't

developers and they decided to give that

capability to non-devs by rebranding it

and calling it chat GPT. This is one of

my biggest issues. If you wanted good

open-source solutions, you basically had

to use the terminal. You had the codec,

but you also had lots of other awesome

things. Shout out to stuff like Open

Code and Pi, phenomenal harnesses and

terminal tools for coding with AI. But

if you wanted a guey like codeex, your

options were to use the one locked to

the provider that you like. So you can

use the cloud code app with your cloud

sub or you can use the codeex app with

your codec sub. You could hack the

codeex app to use other things kind of.

You could kind of do the same for the

cloud code app, but you shouldn't

because the cloud code app is just not

very good. But your only option if you

wanted one place for everything was open

code, but then you lose all the

subsidization because open code isn't

using the official harness. You also

don't get the features that get added to

things like cloud code or codec. If you

wanted the best features for the best

price with the best models, you had to

use claude in the CLI or codeex in the

desktop app because both companies kind

of stop supporting the other side as

much where a lot of new codeex features

only happen in the app and a lot of new

cloud code features only happen in the

CLI. And I got to a pretty nasty point

where if I needed to use my cloud

models, I was in the CLI. And if I

wanted to use Codex models and GPT

models, I was in the guey. And I ended

up finding myself defaulting to OpenAI

models even in things they were worse at

because I just liked having a good app

more. And it's all these little things

that add up. Like seriously, if you

haven't tried one of these guies, I I

would love to self-plug, but just go try

the codeex app. It is genuinely really

good. It has its edges. It has its

annoyances. They added the new activity

view, which is inspired by what we've

been building in T3 Code. And as cool as

it is, it's not quite all the way there.

But god damn, if this isn't a massive

improvement on what you're already

doing, I don't know what to tell you.

It's so much easier to keep track of

what's going on, where work is

happening, what you've been doing, and

actually getting stuff done. I can't

tell you how many times I lost track of

some terminal session. I had to open up

cloud code and tell it to go find the

cloud code I was doing work in or the

work tree that I started from, or all

these other things. I had to put a ton

of time into just keeping track of what

was going on. And as you can see from my

chaotic setup here, I put a lot of time

in. I had to reboot this machine earlier

today, so I lost all the sessions I had,

but I had like 30 terminals in T-Mux on

this one Linux box for various cloud

code and CEX things that I was doing. I

still have a whole bunch over on my

other Linux box here for all these types

of crazy tasks that I've been trying

just like running goals indefinitely to

see what happens. like the TypeScript

Rust port that I was briefly working on

before I ran out of tokens. Just keeping

track of what is what is so annoying.

And you can do like renames and things

if you want to take the time to, but

it's so annoying. And the amount of work

I had to put in to try and make an

environment that was reasonable just to

switch between cloud code and codecs on

real work and keep track of what I was

doing. It's just more mental overhead.

I'm going to be real with you. It just

is. And this is not historically how

terminals worked. Historically,

terminals have been the option that is

less mental overhead and slightly more

upfront cost. You had to spend a little

time to set it up how you want. And then

from that point on, the terminal is

mostly just doing the same thing the way

you want to. But in a world where the

work I'm doing is changing so actively

that the projects I'm working on might

be brand new, they might be months old,

they might be years old, and the amount

of work I'm doing in parallel can change

a ton as well. I might be working on one

thing. I might be working on 10 things.

The rigidity of the systems I built for

myself in the terminal was not flexible

enough for the work that I was doing

today. And I tried my godamn hardest to

fix that. I put a ton of effort into

making it so I can paste images over

cmox over SSH through my T-Max layer

here. So I can command V here and paste

an image through cmox over SSH into the

T-modex instance on this machine

remotely. That [ __ ] was so buggy for a

while and now it's relatively stable. So

I could finally paste images over SSH,

but that's like a thing I had to put

time and effort into to do something as

basic as screenshot something and then

send it to my agents. With a guey, I

just do it. And I would say like halfish

of my prompts have images because when I

have an error or a thing that is

annoying me, it's a lot easier to just

screenshot, send it, and say fix and it

will. Whether that's a screenshot of

your app or just a weird error you

didn't expect to get when you ran a

command. Sending screenshots to your

model is very effective, but it's not

very effective when you can't even see

what the image is. But my biggest

complaint is none of this. It's actually

okay. It's kind of part of one of these

things. It has very little to do with

the terminal and very little to do with

the agents. It's three very specific,

very annoying letters. SSH. SSH kind of

[ __ ] sucks. It's really useful,

really powerful, and I spend a ton of

time in SSH, but as soon as my

connection isn't perfect, I end up with

all sorts of problems. I had a problem a

few days ago where I was running Cloud

Code over SSH on my local network, which

is a Wi-Fi 7 network with gigabit to 10

gig speeds depending on if I'm wired or

wireless. And I had my computer plugged

in over 10 gig at my desk downstairs.

and I was getting sticky keys while I

typed trying to do work in cloud code.

It turned out it was bound to the Wi-Fi,

not to my Ethernet. But the fact that I

even had to care is absurd. And don't

get me started on trying to do things on

mobile. GH I I tried so hard to make

Terus work for me. I paid the full price

for it. I support the developer. I think

it's awesome and it helped me debug

something even this morning. Like I

still use these things. They're just not

the thing I default to anymore because

they're fragile. And it's incredible how

powerful a standard SSH is. That's been

around for over 30 years and it works so

great to this day. And there are other

fun things like I know SSH3 is

apparently much better. I know mosh is

really cool, but I do not have it in me

to deal with all of those things to get

marginal improvements, especially if I

want these to work on my phone because

trying to do real work on my phone via a

terminal has me questioning my own

sanity and also questioning the

reliability of all the other people who

were saying that using their terminal

over their phone was a totally

acceptable way to do quad code. It just

isn't. And thankfully, Codex accepted

this fact and they introduced the

ability to control the Codex app, now

the ChatGpt app, over the Chat GBT app

on your phone remotely. And it was so

much better. It had its rough edges, but

the ability to spin up some work on my

computer and then finish the thread on

my phone when I'm away, it just kept me

off my computer a lot more. And I found

myself like walking around doing more

chores, leaving my apartment to go run

errands, and being able to check in on

the stuff that I was doing overtime. It

was really fun and cool and also

obnoxiously buggy and most importantly

was super restricted to the Codeex

desktop app, which meant I could only

use it on my Macs. And when you combine

that with all of the annoying parts of

how codeex is implemented around the

security policy stuff on Mac OS where it

spins up five plus processes per thread

and per sub agent which can just pose

your performance. I was getting annoyed

and I had a couple things that I wanted

and I will list all of the stuff that I

wanted to make sure I could do. The

things that were annoying me obviously

pasting images was a very important one

for me. I also wanted all models with

subsidization. So, I wanted to make sure

whatever came out here worked with my

cloud code subs and my codec subs, so I

could get the 8 to 14 grand for 200

bucks instead of having to spend 8 to 14

grand for it. I wanted good remote

control. I wanted best-in-class

Linux support because, as I've said in

many videos, check out my Linux video I

did recently, Linux is so much better

for agentic work because the file

systems just suck a lot less. And

spinning up a work tree takes 2 seconds

instead of 30 seconds to 2 minutes. just

so much better. And even when I'm going

like really heavy on my work on my Linux

boxes, it is rare I can spike even like

a third of my utilization. Like I have

32 cores on this machine. It's an a

Ryzen AI max box. It's the framework

desktop. I mentioned that before. I have

tried to stress this machine and I

basically cannot do it. And a lot of

that is just the fact that Linux doesn't

have all of the chaos trying to scan

every single thing Codeex does. So, I

best-in-class Linux support, good mobile

support, good performance, low battery

impact, and probably the single biggest

part, a good way to manage lots of

things at once. This is all the stuff I

wanted. The only one of these things

terminals offer me are best-in-class

Linux support. They don't help in any of

these other categories in any way. And

now you guys have waited long enough.

The commenters can do their thing. I

need to talk about T3 code because

Julius and I made T3 code because we

shared a lot of these frustrations. We

wanted to love Codeex and did for a lot

of things. I know Julius still uses it

heavily. I've slowly moved off the Codex

desktop app. It has its benefits for

sure and I'm hoping that we can clone as

many of those as possible in the near

future. Julius and I tried all the other

options that existed at the time and

were very unhappy with them. The couple

that were okay, we gave a lot of

feedback to and they fixed some things,

they failed others and we got annoyed. I

got so annoyed about the performance

part in particular that I tried building

my own native guey for codecs to just

try and make something faster. I ended

up in hell with scrolling text because

Swift UI and AppKit are not great at big

scrollable views with text. And it turns

out Google put a lot of good work into

Chrome for that. So I begrudgingly threw

that project away. Begrudgingly spun it

back up on Electron just out of

curiosity. decided to architect it in a

way that made other things like the

remote control a little easier by

putting everything on a websocket

instead of binding it through the

electron RPC. And the result was

something surprisingly usable. The

result was T3 code. It did not look at

all like this at the time. It was

sinfully ugly at the time, but it

allowed you to use codecs with an

open-source guey that was a lot less

impactful on your systems performance.

I'll be honest though, for the first few

months, I still found myself using the

Codeex app more than T3 Code. I would

rotate between them for sure, but I

spent most of my time in Codeex

probably. There would be moments where I

went up and down, but I kept finding

myself back in codeex, but Julius

couldn't take that. Julius continued

iterating on T3 code because Julius has

something that I don't.

Julius hates terminals. This one was

hard and I've argued with him a bunch

about this. He exclusively used Git

through the VS Code extension. He didn't

even He probably knows most of the Git

commands in the terminal, but he never

uses them. The only terminal he would

open was the one in VS Code or cursor to

spin up his dev servers. Everything else

he did through the editor. He's one of

the best devs I've ever met in my life.

He's without question the best dev I've

ever known that hates terminals. For me,

T3 Code was a way to have an open-source

solution that could potentially solve a

handful of my problems. For Julius, T3

Code was his ability to escape the

terminal. And he took the challenge, and

the [ __ ] did it. He made T3 code

so reliable, so stable, so well

implemented and integrated. He got work

trees working perfectly. He got cla

working perfectly. He got open code and

grock working as well. And even cursor,

although the cursor integration needs

some work. Big update coming there soon.

He did all of that because he wanted to

take advantage of all of the models from

all these providers at all of these

subsidized rates, but he didn't want to

have to use a shitty terminal app and

memorize a whole new set of hotkeys for

every different one. And T3 Code became

his surface for managing all these

different agents and all these different

solutions with a onestop place where

everything behaved the same regardless

of which models you were using. And

reminder, this is using your cloud code

and your codecs on your machine. And

we're not doing some hacks like -p. We

were using the official agent SDK

blessed by Ampropic. They were going to

change the policy. They have temporarily

held it. They might indefinitely hold

it. Still waiting for updates there. But

this all works above board officially

supported by both Cloud Code and Codeex

to the point where the Codex team is

publicly shouting us out as inspiration

for features they're adding into Codeex.

We put a lot of work into all of this.

Not just building it, but negotiating

with the labs to make sure we do things

the way they want so that we can

continue offering your subscriptions to

the platforms you like in our app

without getting banned. And then the

magic piece comes in. There's a little

button here at the bottom. Other apps

have this to be clear. Most of them have

it as a use it on your machine or use it

on the cloud button. We have something

different. When you set up T3 code on a

machine, you can now control that

machine through T3 code on the app on

another computer on the website on

app.t3.codes or in the mobile app. Yes,

we have a fully supported mobile app for

iOS and Android. And yes, it is also

fully open source. So, if you want to

build it yourself, you can. This here is

magical. The thing that has

fundamentally changed how I work is the

ability to just pick a computer, send

off a task, and close my laptop. Before

this, I found myself having to like

prioritize my life around when I could

run an agent. Because if I had to run an

agent and then I had a meeting coming up

and that was going to overheat my

computer and make it unpleasant to use

in a call and spin my fans up so loud

that I couldn't use the mics on my

laptop, then I would wait until I got to

the end of the meeting and then spin it

up, hoping I don't have another one

coming up. If I had an appointment or a

trip or an event or something I had to

go to, I wouldn't spin up my agents

because as soon as I lose Wi-Fi, they

die. One of the more embarrassing things

I must admit here is that I'm notorious

for coding in Ubers. I would spend a lot

of time driving around to different

events and things because I have to go

to a lot of different [ __ ] And I would

often pick an Uber just because I could

sit in the Uber and get some code out.

And when I'm at my office, I am so

behind on so many other things. I have

to do all of that. So my Ubers became my

like peaceful coding time. I have a lot

of posts where I talk about the crazy

performance improvements and changes I

made from Ubers. But something bad

happened. I started using claude code

when Opus 45 dropped. I This poses me

going back to Opus 45 and trying

something. But notice how I ended it. I

will have to stop momentarily as I am

currently coding in an Uber. My bad data

connection was causing me problems. And

as soon as I got there, I had to close

my laptop and whatever agent I was

running died and I had to spin it up

later hoping that it would continue. And

the more that this happened and the more

I was doing tasks that would take hours

instead of minutes, the more I just

didn't want to code in Ubers anymore

because as soon as I have to close my

laptop, it's over. And now I have to

think about my work in a way where I

know I have enough time of laptop open

for the task to be completed. And I was

like structuring my day around this. It

was bad. Now I pick the box I want this

to run on. I send the prompt and I stop

thinking about it. I could send

something to soul like do a deep audit

of this codebase and then command Q T3

code so it's fully dead. There is no T3

code open on this computer anymore. I

can then reopen it and the work is still

going. Or I can command Q it again, get

it hard killed on my machine and go to

app.t3.codes and see the exact same work

across all of my machines with the

ability to continue sending prompts, see

what's happening, paste images, scroll

through history, and even spin up the

terminal if that's what you want to do.

You got to admit that's pretty cool. And

all of this is over the websocket

connections that are spawned by T3 code

when you run it on a machine. We now

have a bunch of easier ways to connect

as well. If you're already a tail scale

person, I have a feeling you'll dig this

new feature I recently added. npx t3.

I'll do it nightly cuz that's what I've

been using lately. T3 at nightly

pair-tail scale. This command will give

you a pairing code that you can scan on

your phone or a URL you can use to

connect on the web. And now you have a

full T3 code instance that you can

control. You do have to serve it

somehow. So T3 nightly serve and that

will host it. Or you can use the even

easier way which is npxt3 connect which

will open up a URL to sign in with

GitHub, Google or whatever else. And

then it will create a background

instance on this machine as long as on

Linux Mac support coming soon that

allows you to forever connect to this

machine and run the agents that are

already configured on that same machine.

So, if you have an old laptop somewhere

at your house or a PC that hasn't been

turned on in a while or already have a

Linux machine that you use, set up a

Linux on it if it's not already set up.

Install Cloud Code Codeex, both or

neither. Run this one command, npxt3

connect. And now you can control that

machine and all of the agents on it from

a much much better interface without

having to deal with all of the

consequences of things like SSH, of

things like terminals, of all of the

different annoying pieces that you have

to deal with. But I really, really hope

you guys understand that I'm not doing

this in some secret plan to make money.

I'm doing this one out of frustration.

I'm doing this one out of the love of

the game. If I wanted to make a bunch of

money, I could have just sold this to

OpenAI or Ananthropic at this point, but

the goal is specifically almost a

counterbource

software that we use to build software

with. When I got into coding, it was

mostly a closed source ecosystem. All

the editors people use were closed

source. Things like Visual Studio,

things like Sublime Text. They had some

concept of extensions, but barely. And

then GitHub released Atom, which was

built on top of Electron. And then

Microsoft decided to fight back with VS

Code, which was an open-source electron

editor that became the industry standard

used by over 80% of developers. And

suddenly we all were using tools that we

could customize. And now AI is huge. And

everyone moved to cursor, which is a

closed source fork, or to claude code,

which is a closed source terminal, or to

the Codex desktop app, which is a closed

source desktop app. and our ability to

customize our tools started to fade

fast, which is particularly ironic

because we're also now in an era where

it's ever been easier to customize tools

as long as you have source code access.

And it just deeply frustrated me that

the tools I used would randomly get

worse and I couldn't fix them and had

things I wanted and didn't have the

ability for me to add them. And I wanted

to make sure that the next generation

didn't have to grow up with a bunch of

closed source tools they couldn't

customize and agents that are more than

capable of customizing. So, I ended up

spending a lot of time and money and

resource and betting hard on doing this.

Not because I think I can make money on

it. Sure, there's some potential to do

that in the future, but the goal here is

to make the best possible open-source

solution for coding with AI today. And I

do not believe that that solution is a

terminal. I genuinely believe that

solution is a graphical interface that

prioritizes the people who want to get

real work done with systems that help

you get that work landed. I have so much

more I want to say about T3 code in

particular, but that's going to have to

wait for another video. For now, I just

hope you guys get this takeaway. I don't

care which guey you use. Ideally, use a

decent one. So, like if you use the

cloud code desktop app, you're not

getting the like proper guey experience,

but use something like T3 code or codeex

or you can deal with the performance

issues in the new cursor glass version

or you build your own thing or use gene

or conductor any of these other guies

for managing your agents. I think you'll

feel the difference because it really

really is significantly better than

dealing with a terminal, especially once

you have more than one or two things

going on. The ability to just hop around

or hold down a hotkey and see which

thread maps to which button and I can

just commandclick between the different

things I'm doing. Being able to

rightclick and archive or just click

settle, all these little things,

especially once you start using images

and stuff too, it's just it's so much

better. And once I was liberated from

the reality that doing this on another

computer was too hard and no longer

sshing constantly just to make sure the

agent was durable. Once all of that was

implemented, it changed how I code. And

I went from landing like three or four

PRs a week to on my like heavy coding

days as many as 20 PRs a day landing.

And moving from the terminal to a real

graphical interface is a significant

part of why I was able to make that

shift. Just to make sure this is clear,

I love terminals and there's a lot of me

that misses using them as much as I used

to. But at the same time, they're just

not the right shape for the things that

we do today. And it's time to stop

pretending they are. The same way that

iPhones used to make all the apps look

like the real world objects in the

skumorphic era because it was important

that people saw a calendar and it looked

like a calendar because otherwise they

wouldn't use it. We're in that era still

now with AI dev tools. We're doing

things the way we used to because

otherwise it's too much at once. I need

you to look forward a bit though. I want

you to challenge that belief because the

devs who were the wizards at terminals

are the same devs who should be wizards

with agents. And as hard as it is to

admit, cuz I know it was really, really

hard for me, the terminal is not the

ideal interface for the way that we

build today. And if I'm being fully

honest with you, the only way the

terminal isn't holding you back would be

if you're not building big enough. Push

yourself more and try out some gooies. I

have a feeling you'll be surprised. And

until next time, peace nuts.