You need to try the GitHub Copilot CLI right now

the GitHub Copilot CLI. Yes, we have another tool and I've been talking a lot about it on X or Twitter, whatever you want to call it. And that's because I

actually like it a lot. And one of the things I want to do on this channel is just always be really honest with you about what I think works and what I think is just shenanigans. And the

Copilot CLI just really works really well. It's become my daily driver. And

well. It's become my daily driver. And

so in this video, I want to kind of walk you through how to get started with it.

So it's a bit of a beginner video, but at the same time, I'm going to show you some of the things that I do with it, some tweaks, where I actually use it, some of my workflows, and we'll actually build something in this video as well,

because that's the only way that you can really watch or learn to see how the Copilot CLI is actually used in real life. And so if you're ready, let's do

life. And so if you're ready, let's do it. All right. So, to get started,

it. All right. So, to get started, obviously the first thing you're going to want to do is install the CLI. So, uh

you can just Google that. Y'all know how to do that. And um then just click the install now button. Right now, that takes you to a GitHub page. I think this is going to be improving shortly, but

just find your installation and then install. Here, I was on a Mac, so I did

install. Here, I was on a Mac, so I did a Brew install. Now, the next thing you're going to want to know is where should I run this thing? Uh should I run it in the system terminal or how should I do this? So, I'm going to show you how

I do it, which is that I always run it inside of Visual Studio Code with the project that I'm working on open. Uh,

and so, let me show you what I mean and why I do this. So, for this video, I've created a folder called the uh CLI video. So, let's just move into that

video. So, let's just move into that here in the terminal. And you'll notice I have the terminal on the right and uh the editor on the left here. And that's

intentional. You'll see why here in just a second. Okay. Uh so with our terminal

a second. Okay. Uh so with our terminal open here, we actually want to open Visual Studio Code on this folder. We

don't have to do that to run the CLI, but Visual Studio Code has this concept of being open on a folder. And so we want to keep with that concept here just

to make it easier on our brains. So I'm

going to run here um code insiders with a dot and a dash r. And it just says open the current folder in the existing window. So, now we've done

existing window. So, now we've done that. You can't really tell other than

that. You can't really tell other than we have the title up here. Let's open

that sidebar again. And if you're wondering how I actually got the terminal here in the sidebar, what you have to do is from the bottom panel here, from the bottom panel, you just drag these things and drop them there.

So, if you didn't know you can do that, you can. That's how I got the terminal

you can. That's how I got the terminal over here. Now, I don't even though

over here. Now, I don't even though we're in the terminal, I don't run the CLI in the terminal, per se. Okay, I run it over here in the editor space. And to

do that, you what you can do is just say uh terminal. And if you look for

uh terminal. And if you look for terminal in editor, you can create a new terminal in the editor space like this right here. Um I do this a lot. And so

right here. Um I do this a lot. And so

what I do is create a keyboard shortcut.

And then what we're going to do here is just look for terminal in editor. And

then here it says create new terminal in editor. And you can see I have that set

editor. And you can see I have that set to uh control option t cuz I do this a lot. And so uh control option t and we

lot. And so uh control option t and we get a new editor instance here or a new terminal instance rather in the editor space. Now let's go ahead and fire up

space. Now let's go ahead and fire up the CLI. So we're just going to type

the CLI. So we're just going to type copilot and here's the CLI. Now the

first time you do this you'll get a nice animation and you'll have to type /lo to actually log in but I've already done that so you're not going to see that here. All right. So with the copilot CLI

here. All right. So with the copilot CLI up, let's just do a quick tour of the interface here. Um you can see it's

interface here. Um you can see it's telling us that we can type at to mention files slash for commands or question mark for shortcuts. Now um I

mostly use slash commands. We'll talk

about some of the shortcuts. I hardly

ever mention files. In fact, we don't even have one in here. But if we were to say uh create a simple readme here, it will create a simple readme for this project. And then what we could do is

project. And then what we could do is just mention the file here. So we might want to say, you know, spruce up this readme. And you'll notice it's saying,

readme. And you'll notice it's saying, do you want to create this readme? And I

do, but I don't want to have to tell the CLI every single time that it's okay to do something, you know. And so what it could do is say yes and don't ask for file operations again. But it's going to ask me this every time it tries to do a

tool call. So I'm going to say yes.

tool call. So I'm going to say yes.

test. But then I'm going to come back to uh the CLI here and I'm going to say allow all like this. And when we do this, we're

like this. And when we do this, we're turning on what's essentially also referred to as YOLO mode. So it's never going to ask me again for permission.

And I want the full agent experience. So

that's what we're going to do. Now, I

like to alias this as well from the command line. So I'm going to press Ctrl

command line. So I'm going to press Ctrl + C twice to jump out here. And from the command line, you can launch it in this mode by doing copilot- yolo, which gives

you the exact same thing. It's just auto approve um on my default. So, I don't like to type that. So, what I do is I just alias it so that I can just type yolo and I get the exact same thing.

Copilot in allow mode. And if you're like, I don't know how to create an alias, well, that's why we use the VS Code terminal because copilot is built in there as well, right? So if you don't

know then you could just ask command or controlI on Windows right say alias copilot alias copilot-

yolo to uh yolo right and it will create that alias for you whether or not you're in powershell or bash doesn't matter. So

this is why we like the VS Code terminal because it has AI built in and that's command or controlI I because we still need to be in the terminal. We're still

going to have to do things. We want to have Copilot there with us as well, not just in the CLI. So let's go back into our session. In the session that we had,

our session. In the session that we had, uh there's two ways to get back to it.

So if we say copilot-res, this will bring up a list of our recent sessions here. So you'll get to see I've

sessions here. So you'll get to see I've been working on a lot of stuff. So

simple read me right here. Um, it's the top one here, right there. You can see Opra's working on some project ideas as well. So, we could we could resume that

well. So, we could we could resume that way. The other way that we can resume

way. The other way that we can resume here is we could just do um we could do this. We could say copilot

this. We could say copilot uh d- continue. And this will just resume the last session we were in, which is the session that we just left.

And speaking of aliasing, something that we could do here that's kind of fun is we can say alias copilot- continue to uh

CPR, right? And so essentially,

CPR, right? And so essentially, so it's going to add this to my ZSH file. I'm going to go ahead and let it

file. I'm going to go ahead and let it do that. And then we have to reboot our

do that. And then we have to reboot our shell here. And then once we've done

shell here. And then once we've done that, if we just type CPR, that will just resume the last session that we were in. So here we are. So if we kill

were in. So here we are. So if we kill it, get back to the terminal, that's fine. CPR bring it back to life. Get it?

fine. CPR bring it back to life. Get it?

All right. Okay. Now, the next thing that we want to do here is look at some of the slash commands that we're going to use a lot. So, obviously model or models is a big one. This is selects the

AI model that you want to use. I'm

seeing Opus 46 is the default.

I don't know if that's actually the case for everybody and I don't know if that's the case for you as well in your company, but you can see all of the models we have access to here. And

again, if you don't see these, your company, if you have a company sub, may be controlling what you can and can't see. Okay? And so that's why they may

see. Okay? And so that's why they may not be present in this list.

Additionally, you'll see some models here that say hidden from me. And that's

because these are not public models.

These are either internal models or they're not they're they're preview models. And so I have these hidden here

models. And so I have these hidden here um just so they don't confuse you as to why aren't those in my model list. Well,

because they're not available to everyone just yet. So, uh, we're going to be on cloud opus 46. I'm a huge fan of Opus. 53 is great, and we're actually

of Opus. 53 is great, and we're actually going to use 53, um, but not not directly, and I'll I'll explain why here in just a second. So, this is how we could change our model if we wanted to,

uh, and our reasoning levels. If you

want to change the reasoning level, pick the model and then you can change the reasoning level. Now, let's look at some

reasoning level. Now, let's look at some shortcuts that you're going to use a lot. So, one that I keep using that

lot. So, one that I keep using that you've seen me use a bunch here is just CR L. And that just clears the screen.

CR L. And that just clears the screen.

Doesn't start a new session. Just clears

the screen. And so, um, what we can do here is look at some of the other commands that are super important. So,

what other commands what other commands do I need to know?

Um, one of them is control A, which is going to take you back to the start of the line. And the other one is control

the line. And the other one is control E, which is going to take you to the end of the line. And there's other things you can do like control K, which I think deletes all of the all of the text after

the cursor. It does. And if you want to

the cursor. It does. And if you want to see what these are, you can just do uh a question mark here. And you'll see here they all are troll E. Um editing is what

you're looking for right there. So you

can look at to that at any time to see what those are, but those are the ones that I use the most. Uh it looks like control U to delete to the beginning of the line. And so if we had a longer

the line. And so if we had a longer prompt, control-U, delete to the beginning of the line. Good to know those shortcuts. Okay. Now, I talked

those shortcuts. Okay. Now, I talked about how I had a custom agent. You can

set up your own custom agents here by just doing / agent. And then you can see I've got a couple of them here. And an

agent, let's like if we were going to create a new agent here. Um, we could put it in either the user config, which is available to every project, or just

this project. A an agent is just a

this project. A an agent is just a prompt file which gives the agent some instructions, but they're very very powerful. In fact, I believe there's not

powerful. In fact, I believe there's not a lot you can't do with custom agents.

You can solve pretty much any workflow problem with them. Um, but if we were going to create one, let's just call this a test agent here. It's this is just a test. Uh, and again, these are

just uh we're just showing how to create a custom agent here. It's not going to do anything. And then in here we would

do anything. And then in here we would say something like you know you are a coding agent always follow this workflow and then the agent's been created and it's created here. You can see it right

there. And if we click this will

there. And if we click this will actually open it in Visual Studio Code.

This is another reason why we like to be in VS Code when we're using the terminal because if we commandclick on links when given them from the terminal to files,

they open right here. This is super powerful. I can't undersell this enough

powerful. I can't undersell this enough that the terminal on its own is great, but you when you need the file editing capabilities and want to see the file, you just can't beat this experience. So,

you definitely want to be in Visual Studio Code.

Okay. Now, I talked about a custom agent I have here called Anvil, and that's the one that we'll be using today. And you

can get this if you go to burcllin.kub.io. io/anvil

and then it's just a plugin. And so

these plugins are supported by the copilot CLI. Uh this one is on GitHub.

copilot CLI. Uh this one is on GitHub.

If you just look for the Anvil repository, you can see how I created a plugin. And this plugin has a custom

plugin. And this plugin has a custom agent and the context 7 MTP server. Uh

and again, and then there's a front-end design skill here that I'm recommending, but I don't give that to you because there's another place that I want you to install that from. So when you run this, you'll get the context 7 MCP server and

the agent and you can know that that's the case. If you go to MCP here, you can

the case. If you go to MCP here, you can see context 7 is there. And context 7 just allows the agent to read docs as markdown files. That's it. The anvil

markdown files. That's it. The anvil

custom agent does quite a bit more. So

the agent really tries to force the model to use context 7 a lot to use fetch a lot and then it forces it to do what we call adversarial reviews or

essentially to check its work with GPT53 codecs and Gemini which is one of the hidden models that I'm using here. And

the reason why I'm doing this is because I really like Opus very agentic. It

likes to please. It wants to do the work but it doesn't always do the best job.

GBT53 on the other hand is very rigid.

It's not very much fun to work with, but it only does exactly what it's asked to do. So, if we put these two things

do. So, if we put these two things together, we get better results out the other side. Now, the last thing I want

other side. Now, the last thing I want to show you before we get started here is this front-end design skill, which I've recommended. So, skills, if you

I've recommended. So, skills, if you haven't watched my video, my video on my video on skills should check that out.

But they're just markdown files. There's

a great one called Front-end Design and I recommend that you have it. It does

front-end design. Uh to install it, you're just going to copy and then come down and then you want to run this in your terminal. Now, this is a really

your terminal. Now, this is a really good opportunity for us to see a couple different ways to do that. So, one of the ways is we could just open our terminal here to the side and execute it

there. That's probably the easiest way.

there. That's probably the easiest way.

If you actually wanted to uh cancel out of the CLI, what you could do is pressR C twice and that just ends your session and then we could run the command.

However, there's a different way to do this that's kind of unique. So, let's

bring our session back here with CPR.

One, one of the things that's built into Linux, this is a Linux only thing that I'm about to show you, is if you press control Z, it will suspend the process.

And in this case, that's the CLI. And

then we can run this other command to install the front-end design skill, which I'm not going to do because I've already installed it here. And then if we want to bring this back, if we just

hit FG, which is short for foreground, then it will bring the process back. And

it's back. So there's a couple different ways that you can either drop out of the CLI or get back into the CLI. It's

probably easier though to just have your terminal instance open and do these things over here and leave these things open. Now, another thing that we've got

open. Now, another thing that we've got here is that up here at the top, if we have multiple terminal instances, it's not really easy for us to tell what's what. Uh, and the reason for that is

what. Uh, and the reason for that is because it just says node up top. So, if

we open another terminal instance here, and we have copilot running over here as well. So, let's yolo into this one. Now,

well. So, let's yolo into this one. Now,

we don't really know like what's happening over here. here and what's happening over here. They both just say node. So, there's a fix for this. If you

node. So, there's a fix for this. If you

go to settings UI and then what we're looking for is terminal uh title and then you can see terminal tabs title here might be a little small.

And what you want to do is you want to set this to sequence, right? This this

one right here. So, let's just copy this. Come down. We're just going to set

this. Come down. We're just going to set it to sequence like this. And then hop out. And then when we do that, you can

out. And then when we do that, you can see here what we've got at the top is uh a little bit more of a descriptive definition of what's actually happening.

So in this one, as you as we go along, you'll see that what it does is it actually updates these titles with the title of the chat session, which is super nice. So you can see what's

super nice. So you can see what's actually happening. One more tip I want

actually happening. One more tip I want to give you, and it's a lot of logistics before we get started, is that when you are running the terminal in a tab like this, it swallows a lot of the shortcuts

that you're used to. So, the commandB works for me, but it won't work for you.

And I can zoom in and I can zoom out, but it won't work for you. And to fix this, what you need to do is go to user settings, and then you want to look for terminal uh integrated.

I think it's just commands to skip shell. That's what we're looking for

shell. That's what we're looking for here. So, you can see here, these are

here. So, you can see here, these are the different commands. Basically, what

we're saying is don't pass these commands through the shell. Let VS Code handle them. And really the three that I

handle them. And really the three that I add are zoom in, zoom out, and to toggle sidebar visibility. That's it. And then

sidebar visibility. That's it. And then

once you add those, then your keyboard shortcuts will start to work uh as you would expect them to. So that's a quick fix there for that. Now, got a lot of

setup here. We've done a bunch. Let's go

setup here. We've done a bunch. Let's go

over and let's start to build something.

And the question is always, well, what are we going to build? And I always build the same thing. So let's look at that. If you've watched some of my other

that. If you've watched some of my other videos, I always build this site. And

the reason why I build this site is because it looks trivial, but it's actually not. Um, so it's a it's a site

actually not. Um, so it's a it's a site for sharing links. Um, if we add a link here, we can add another link. Uh, let's

add microsoft.com. Let's add github github.com/copilot.

github.com/copilot.

Right. And then up here, we can add dope links. Oop, it's already taken. And so

links. Oop, it's already taken. And so

there's a lot that's going on here. We

can publish, but we have to log in to publish. And so then we could see all of

publish. And so then we could see all of our links. And then here's the links

our links. And then here's the links that we can we can reorder these. And

then we can give somebody a single URL and they can share it with the world like this. All right. So I've logged in.

like this. All right. So I've logged in.

If I hit publish now, we get this URL.

And if you were actually to go to this URL right now, you will see this list of links which I've created here. And I

there was some others already in there say to local storage. That's why you see some duplicates. So we want to recreate

some duplicates. So we want to recreate this site. That's the task that we're

this site. That's the task that we're going to be doing with the agent. So,

let's jump back into the CLI and learn some more as we do this. So, we want to build this thing. How are we going to do that? So, first I'm going to switch to

that? So, first I'm going to switch to my agent and I'm going to go to Anvil.

Now, the next thing we want to do is we want to do a plan because we're starting from, you know, absolute zero. There is

nothing here. And this is a very special scenario to be in. It's one you may not be in if you're not building green field projects, right? If you're working with

projects, right? If you're working with existing projects, you may be in different scenarios here. But because we don't have anything, we really need to plan first. Whenever I'm doing this and

plan first. Whenever I'm doing this and I have to give this thing quite a large prompt because I'm about to try to describe what I want. I don't want to type this. I want to speak this. And so

type this. I want to speak this. And so

to do that, I'm going to use the builtin voicetoext support in the operating system. For a Mac,

system. For a Mac, you'll need to go to settings. And then

in settings, you want to just look for keyboard. So

find keyboard here. And then under keyboard, you're going to look for dictation. Turn that on. And then set

dictation. Turn that on. And then set the shortcut to press control key twice.

If you're on Windows, I'm pretty sure it's already on. It's just Windows keyh.

Okay. So I'm going to I'm about to dictate a prompt in and we're going to create a plan. But we want to be in a special mode to do that, which is plan mode. So I'm going to hit shift tab,

mode. So I'm going to hit shift tab, which is going to take me to plan mode.

And then I'm going to start planning. So

let's do it.

I'd like to create a site called the URL list. The whole point of the site is to

list. The whole point of the site is to allow users to create lists of links and then share them with one URL. So, the

site is essentially a homepage that describes what the site does with a big prominent input that says, "Create your first list." And then after the user

first list." And then after the user puts a link in, it takes them to a compose page where they can continue to put more links in. And as links are put in, the open graph data for those links

is fetched from the internet so that each link has a nice icon, title, and description. The user can edit those

description. The user can edit those titles and descriptions or they can take them as is. They can also reorder the items in the list using drag and drop.

Additionally, they get to create a vanity URL. But these vanities have to

vanity URL. But these vanities have to be unique and the list can also have a description. Now, once they have all

description. Now, once they have all this, they can publish the link the list and make it public. In addition, they also have a my links page where they can

see all of their links and they can edit those lists of links at any time from that my links page. To do this, I want

you to use Firebase as a backend. I've

installed the Firebase CLI and I've logged in. So, feel free to create

logged in. So, feel free to create whatever resources you need. If you need something from me, just ask. In

addition, as always, use the front-end design skill when you're building so that we have a nice, beautiful site. And

I'm going to give you some design inspiration for that site. So, that was kind of a long prompt here. I'm going to press shift enter to go down. And you

can see at the bottom, I said I was going to give it some design inspiration. We're going to do that. So,

inspiration. We're going to do that. So,

let's jump over to the browser and we're going to go to color.adobe.com.

We're going to look for just a nice palette here. So, let's look for explore

palette here. So, let's look for explore and then spring. I was like I like light sort of pastely colors. So, let's look at what we've got here. So, this is really pretty. You can imagine that

really pretty. You can imagine that might make a really pretty site. This

one here is nice. I like this. So, I'm

going to click on it here. And then what I'm going to do is say copy as CSS, right? And then let's go back. I'm just

right? And then let's go back. I'm just

going to paste all of this in. Now,

there's a lot of lines so you won't see them. But if we were because we are in

them. But if we were because we are in Visual Studio Code, let's create a new tab here. And we can just paste in and

tab here. And we can just paste in and look. And you can see what's really

look. And you can see what's really interesting about this is not only is it uh describing the color to use, but it's also describing white bush roses on a

background of blue sky in the sunlight.

The AI is going to look at that and it's going to translate that into design. So,

we're literally giving it inspiration in the in the in the form or shape of CSS classes. Totally fascinating. Okay, so

classes. Totally fascinating. Okay, so

let's let's not save this and we're going to go ahead and send this. This is

a massive prompt, right? Like I

basically just said whatever was on the top of my head. And now the agent Opus 46 is going to go to work here and it's going to try to create the plan for

this. So now you can see here it looks

this. So now you can see here it looks like we're not in yellow mode. So let's

do yes. And let's go back and do allow all. If you remember, that's how we get

all. If you remember, that's how we get into yellow mode. Permissions

are now enabled. Good. So, it won't ask me anymore.

And I may speed this up a little bit so that you don't have to watch the AI think. But it looks I see you already

think. But it looks I see you already have a project called link list. So,

I've done this demo before. Should I use that existing project? Uh, let's create a new one just so we're starting from scratch here. How should users

scratch here. How should users authenticate? Uh, let's start with just

authenticate? Uh, let's start with just Google Signin. We'll just start with

Google Signin. We'll just start with that. What front-end framework to use?

that. What front-end framework to use?

Interesting. I didn't specify any part of that. React plus V recommended. Next.

of that. React plus V recommended. Next.

Okay. All right. React plus V sounds good. We'll stick with that. Where

good. We'll stick with that. Where

should it be hosted? We want it hosted on Firebase. Everything is going to be

on Firebase. Everything is going to be on Firebase. Should creating a list

on Firebase. Should creating a list require signing in first. Ooh, now this is a good catch.

So, yes, sign in required require. No,

anyone can create, but only signin users can manage. So I think what we want here

can manage. So I think what we want here is anyone can create a list but only signed users can publish them. If the

user is not logged in uh they can create the list which should be saved to local storage.

Right? So there we're not getting an option we like. So, we're providing some steering and some specification to the planning. And we're not writing any code

planning. And we're not writing any code right now. The agent isn't writing any

right now. The agent isn't writing any code. All it's doing is helping us

code. All it's doing is helping us gather all of the requirements that we actually need to build this because otherwise it's going to have to do a lot of guessing and it's going to guess incorrectly because it's an AI. It's not

a mind readader. Now, it's gone off to create the plan. I should point out that in a normal workflow for myself at this point, I will move on to something else.

So, I'm not going to sit here and just watch it. What I'm going to do is I'm

watch it. What I'm going to do is I'm going to create a new instance of Visual Studio Code and I'm going to start to build something else or I'm going to go back and work on something else. So, for

instance, I've been working on a mobile app for iOS that is a chat app that works the way that I want it to work.

So, I'm going to go back here and I'm going to start working on this chat app.

Normally, this is what I would do, right? I would let this other thing cook

right? I would let this other thing cook in the background and then periodically I'm going to go back and check And it looks like the plan mode is done. I'm

just in time. Now, you can see we're getting a couple different options here.

Accept plan and build on autopilot.

Accept plan and build on default. So,

I'm actually going to take any of that.

I'm just going to hit escape to just completely cancel out of that. I'll

explain why here in a minute. So, you

can see it's created the plan here. And

if we remember, if we commandclick this, then we can see the plan right here. So,

here's the plan. And you can see it's it's actually quite long. Uh, it's

laying out the um the data structure.

It's laying out all of the pages, the routes, the cloud functions that are needed, the security rules. There's a

lot. And ordinarily, if we weren't making just a demo video, we would go through this, review it. Doesn't you

don't have to review it in in intense detail. You have to scrutinize every

detail. You have to scrutinize every detail, but you do need to go through and think about the different things that are happening and just see if anything pops out to you as being a red flag. That's generally what I do. But

flag. That's generally what I do. But

since we are making a video, we want to implement the plan. And so what we're going to do instead here is we're going to switch into I'm going to do shift tab and we're going to go into autopilot mode. And autopilot you can think of it

mode. And autopilot you can think of it as like the copilot CLI version of a Ralph loop. Okay, if you don't know what

Ralph loop. Okay, if you don't know what a Ralph loop is, it's essentially just putting the agent in a while loop and the agent just runs and runs and runs and it keeps being fed back its own

result until it gets to this point where it's looked at its own output so much that it feels really confident that it's implemented things correctly. That's

built into the CLI. I love this feature.

It's called autopilot. We're going to leave it on anvil, right? And we're just going to say implement. Now, we could mention the plan file here if we wanted to with the at, but we don't need to.

We're just going to say implement the plan and then let it cook. Now, this is going to take a second. So, I'm going to go off and work on some other things and we'll come back and see exactly what's

happened here and what we got. See you

in a minute. All right. So, I'm coming back to you here before this is actually finished so we can take a look at a few things that are happening while this thing is running. So one of the things that we can do while it's running is we

can look at the different background tasks. So you can see that it's doing an

tasks. So you can see that it's doing an adversarial review with 53. The hidden

model is Gemini with open 46. So if we hit /tasks, we can see each one of these and we could dig in and see which what happened here, right? So we can see that

it looks like Gemini found some SSRF and open graph cloud function critical severity, right? And so it's going to

severity, right? And so it's going to take this up with Opus. They're going to figure it out between the two of them.

So you can check in on background tasks that way including background terminal processes. So I'm going to escape and

processes. So I'm going to escape and escape again to go back. Now the other thing that I want to show you here which is quite fascinating is that the other benefit of doing this inside of Visual

Studio Code is that we actually get integration with the built-in chat in VS Code. So, I'm going to open that chat

Code. So, I'm going to open that chat sidebar. And what you'll see here is the

sidebar. And what you'll see here is the different uh sessions that we've had with the Copilot CLI. They just show up right here. And I'm going to expand this

right here. And I'm going to expand this just a little bit. If I was to click into this, this will actually pull up and we're actually looking at the CLI

session in the chat sidebar. Right? So,

if you scroll back up here, and I'm quite zoomed in for videos, so it's really hard to see, but we can see exactly what's going on. And if we come

back up here, let's see. Let's Let's

see. Here's So, here's a good one. So,

this happened. Here's a sub agent that was used to check the fire store status.

Not something that's easy to look at in the CLI, but if we click here, it will take us into it. So, we can see exactly what happened, right? So, it used the

get diagnostics. So, it's using, follow

get diagnostics. So, it's using, follow me here, the CLI is using the editor's diagnostics tool, specifically the the

LSP or language server. So, if I do I'm going to pull up the bottom panel here.

If you ever go to problems and you see problems, that is the language server doing that. That's called LSP or

doing that. That's called LSP or language server protocol. The CLI

integrated with the editor is great because otherwise it doesn't know that there's errors. It can't use the editor

there's errors. It can't use the editor features like linting and error checking uh to check its own code. It actually

literally has to build and that's not the most efficient way. We want the agent to have the same tools that we would have. And then we can see that it

would have. And then we can see that it ran this command here and we could dig in and see exactly what that command was and what actually happened. So the

integration with Visual Studio Code super powerful can be understated. A lot

of times you don't care what's happening in the CLI, but when you do, you really need to be able to dig in and see it.

And the integration inside of VS Code provides that. And that's for free. That

provides that. And that's for free. That

just works. There's nothing you have to do to configure that. So, what's

interesting here is you can see that it's going over the reviews from 53 and from Gemini, and then it's doing a build and making sure that everything passes.

And it's actually deploying the hosting and the rules. So again, we're in a Ralph loop here. So it's really going to try to get to the end. And remember, I told it, hey, you have the Firebase CLI,

so just continue on until you're done.

Do whatever you need to do. And you can see as it goes, you'll see these SQL calls. And that's because the CLI uses

calls. And that's because the CLI uses this SQLite database in the back end.

And what Anvil does is it uses that SQLite database to track progress. so

that when it gets to the end, it doesn't hallucinate whether or not it actually did something. It has to check the

did something. It has to check the database to see if it actually did that thing. So, it's done. And I zoomed out

thing. So, it's done. And I zoomed out here so that we can see what's actually happening with Anvil because all of the stuff at the end is this custom agent.

So, you can see, let's just sort of walk through what it actually did. It

presents an evidencebased bundle. And

this is really for its uh benefit so that it knows that it here's the evidence that it completed and did what it said it was going to do. So the

initial state was clean after initial commit empty project with a readme only.

So it snapshot of the initial state and then after the verification after it gets done. So it ran V build it looked

gets done. So it ran V build it looked at IDE diagnostics. It looks at the Firebase rules. It looked at the hosting

Firebase rules. It looked at the hosting did the hosting functions. So it looks like blaze plane required fall back in place. So, it needs me to upgrade to the

place. So, it needs me to upgrade to the Blaze plan. And then there's no

Blaze plan. And then there's no regressions detected. And then here's

regressions detected. And then here's the adversarial review where it looked at 53 Codeex, Gemini 3 Pro, and Opus Force 6. They all found sort of kind of

Force 6. They all found sort of kind of the same things, went through and fixed all those things, and then it came back and basically said, "I'm done." And if you don't like this, you can just run

this command right here to revert all of it. And that is the idea of Anvil is

it. And that is the idea of Anvil is that it checks its work and makes it easy for you to roll back out of the changes that it made. Now,

it wants me to upgrade to the Blaze plants. I'm going to do that real quick.

plants. I'm going to do that real quick.

It actually wants to run this um in in the cloud. It's deployed it, but I want

the cloud. It's deployed it, but I want to run it locally. So, I will literally just ask, how do I run this locally?

And uh hopefully it won't try to run it itself. If it does, we can stop it at

itself. If it does, we can stop it at any time. By the way, you can stop at

any time. By the way, you can stop at any time with just hitting escape to once, twice, twice, once, twice will stop. Uh, and just uh you can just stop

stop. Uh, and just uh you can just stop the model from responding or doing whatever it's doing. Uh, so do you want to run this command? Uh, no. So, we're

going to run it ourselves. What we do?

What do we want to run? We want to run Looks like we want to run npxvit.

All right. So, it's running. And then

let's go ahead and click and open our site. All right. So, here's what it

site. All right. So, here's what it created. And remember, we provided the

created. And remember, we provided the CSS. And you can see uh it's looks like

CSS. And you can see uh it's looks like we're already signed in. I don't know how. Here's my links. Let's try

how. Here's my links. Let's try

google.com.

Uh it looks like it wants the fully qualified. So, let's put that in.

qualified. So, let's put that in.

Create our list. There it is. Okay. And

we've got two links. We can drag these.

We can drop them around. Can we put a new one in?

Microsoft Microsoft.com.

That looks good. Oh, we're and we're getting the Look at the like rounded. It

added a little rounded on the open graph, which is lovely. I love that. Can

I edit the different things? I can.

That's just That's really nice. Uh let's

do GitHub and GitHub. Interesting. Okay,

what about one more? What about this site? This is a good one.

site? This is a good one.

My my own blog here. Shameless plug.

There it is. Okay, and then here's our custom URL. And then can we publish?

custom URL. And then can we publish?

Uh, looks like we can. Uh, very nice.

Um, and so we could should have added a title here. If we sign out, then we can

title here. If we sign out, then we can sign in with Google. Here's here's my links. Let's create a new list. Give it

links. Let's create a new list. Give it

a name, a description. So, you know, there's some things that I would change here, like there's too many emoji. The

flow is a little bit goofy. uh I'd go back and start steering and making some changes, but essentially that's kind of like your burndown on the CLI, what you

need to know today to use it and kind of like how I use it for workflows. And you

can really build anything like I I can't stress this enough. One of the things that I had been working on was a Vibe coding competition that I had with Pierce from the product team last week

in Radmin. And if you tuned in for that

in Radmin. And if you tuned in for that uh live. So here's the other Visual

uh live. So here's the other Visual Studio Code instance. I actually have three of them and I'm using the peacock extension so that I can tell which one I'm in. So this this one's green. This

I'm in. So this this one's green. This

one's blue. And then this is the one that we were in. So it's just an easy way for me to visually move and see, okay, this is my mobile app. This is the demo app that we're working on now. And

here's the other one. So this one I just I just kind of want to show you because I'm I'm kind of proud of it. But the um the whole point of this was to create a thank you wall for contributors because

a lot of the contributions that are made or the code in Visual Studio Code comes from you comes from your poll request.

And so we wanted to honor that. And so I created a site here called the thank you wall. This was part of the challenge.

wall. This was part of the challenge.

And you can load up a release here and you can see all of the different contributors and then just sort of give them kudos here which is which is nice.

But I am showing you this because I also added the very bottom. I was like, "It'd be so cool if you could just like fly around and explore all of these different contributors." And so I I did

different contributors." And so I I did this so you can just fly around through the sky and explore.

I mean, and then give people kudos. This just

blows my mind. A year ago, this would have just been impossible. And this is just me sort of telling the AI what I want and it building. Look at these mountains and these trees and these

clouds. you can do this. There's nothing

clouds. you can do this. There's nothing

that you can't do. Uh, anyway, sidebar, got a little distracted, but that's the GitHub Copilot CLI. I like it a lot.

It's really powerful. I find that it's extremely good at handling background terminal activity. The autopilot or

terminal activity. The autopilot or Ralph loop in there is great. And we

didn't even get to things like fleets, which allow you to deploy an entire fleet of sub aents to go out and tackle big projects like refactors. I hope this

was helpful. I hope it helps with your

was helpful. I hope it helps with your workflows. And remember that whatever

workflows. And remember that whatever works for you, that's the right workflow. I'll leave the links to all of

workflow. I'll leave the links to all of this stuff that you need or we used in the video like Anvil below in the description. And as always, thanks for

description. And as always, thanks for watching and happy coding.