Today I'm using Google's new

anti-gravity AI editor to build and

deploy a full stack web app from

scratch. I'm going to show you exactly

how this tool helps you stop being a

code [music] brick layer and start being

the architect who runs the show.

Hi, I'm Martin.

Google recently released anti-gravity,

which is an agentic development

environment. That means instead of just

autocomplete, it has autonomous agents

that can plan, code, and test your

software. This might feel like a big

shift, but it's actually just the next

step in a 70-year evolution. In the

1950s, engineers wrote machine code.

Then compilers arrived, allowing us to

focus on logic rather than binary. We

didn't stop building. We just stopped

doing the lowlevel grunt work. AI tools

like antgravity are the modern compiler.

They promote you from being a brick

layer manually laying every brick to

being the architect.

You create the blueprint and the AI lays

the bricks. To show you this shift, I'm

going to build Guest Pass. It's a full

stack web app that solves a universal

problem for cafes, hotels, and

libraries. Guests asking for Wi-Fi

password. You enter the Wi-Fi details

once and it generates a QR code card

that can be printed and displayed.

Guests can scan it and join instantly.

No more crawling under the desk to read

the router.

We're deploying this to Cloud Run, but I

won't write the code. I'm going to

manage the agents who do. Let's open

anti-gravity. Create a new directory for

the guest pass app and start drafting.

Here we are in mission control in the

anti-gravity editor. Now, a beginner

would just type make a Wi-Fi app, but an

architect writes a spec sheet. If you

want quality code, you have to give

quality requirements.

I'm pasting in my requirements and I

want you to notice three specific things

I'm telling the agent.

First, I specified tailwind via CDN. My

experience as a developer is telling me

that I don't need a complex front-end

build pipeline for a simple tool like

this. I'm keeping the architecture lean.

Second, look at this critical note. I

told it not to save the generated QR

codes on the server. Remember, these

images contain actual Wi-Fi passwords.

If we store them, we're creating a

security risk. That's the architect

protecting the user.

And third, and this is my favorite part,

I'm forcing you to use a modern version

of NodeJS.

Usually, TypeScript requires a compile

step, but I know that modern Node

versions can run TypeScript natively. A

brick layer would copy paste an old

complex Docker file. As the architect,

I'm deleting the build step entirely.

All right, the spec is locked in. Let's

see what it builds. Over here on the

left, I can see what the agent is doing.

I've told antiggravity to use its own

judgment for when to ask me to confirm a

step. This is the default setting, by

the way. As you can see, it uh proceeds

pretty much by itself. Over here on the

right, I can see the various artifacts

it's creating. Here is the

implementation plan. For example, when

working with other AI tools, I often

created an implementation plan myself.

But Andrew Graavity does it for me. I

can of course edit it. Uh more on that

later. Aha, it built the app and is now

running it in a web browser. Look at the

blue dot moving on the screen. No hands.

That is not my mouse pointer. Is the

tool independently navigating and

clicking through the app to test it.

When working with other AI tools in the

past, I would often test the app

manually in a web browser and then copy

paste any errors back into the tool. No

need for that anymore.

It ran the test successfully and it

added a screenshot of it to the

artifacts. Again, I would do this

manually when using other tools, but

anti-gravity does it for me. We're

seeing a trend here. The team who built

anti-gravity has taken semmanual

processes that work well with AI and

automated them. All those best practices

are baked in so we don't have to think

about them. I like it. But here is one

thing I don't like. It looks like it

only tested the happy path in the

browser. I'll tell it to test the case

when the user doesn't enter a network

name. That should create some sort of

message to the user instead of creating

a bad QR code. Let's see. Anti-gravity

added the test case to the

implementation plan. Good. Good. Uh,

then it ran the happy path test again.

Yeah, that's fine. Ah, there is the new

test case I added. It cleared the

network name field and clicked the

generate button. A message appeared and

no QR code was created. Excellent.

Now that I have better test cases in

place, let me show you one of my

favorite features of anti-gravity.

It generates these artifacts along the

way. Uh like this task list and I can

add comments to them just like in a

Google doc.

I don't have Docker installed on my

laptop. So I will add a comment about

how it shouldn't do a local Docker

build. Then I click the blue submit

button. the tool removed that from the

task list and won't do it again for this

app. Nice. Now, I'm a developer, so I

really like to see the code. If I'm

going to submit it under my name, I want

to review it first, every last semicolon

of it. Also, I may want to make some

edits to it. If I click this icon here,

I get a regular code editor view just

like I'm used to. I can even accept or

reject the edits made by the tool. All

right, let's deploy this app to my dev

project to make sure it works in the

cloud. Cloud Run is a great place to

host apps because it's serverless and I

don't have to worry about scaling or

paying for idle capacity. You know,

Cloud Run is kind of like a cheat code.

It allows us to be serverless. I don't

have to provision a VM or configure

engine X or anything like that. I just

hand Google the container and it gives

me a secure scalable URL. It allows the

infrastructure to move as fast as the AI

writing the code. I never remember the

G-Cloud command for deploying to Cloud

Run. So, I'll just ask Antiggravity to

deploy for me. And here is why that

architect work earlier matters. Because

we created that specific node 23 Docker

file, Cloud Run will use our blueprint.

It won't guess. It executes exactly what

we as architect designed.

This will take a few minutes. You know

what that means? Tea break.

Oh no, there was a deployment error. In

the past, I would have to find the error

in the logs, do a search for that error

message, figure out what needs to be

changed, and then make the update. But

anti-gravity is smart enough to figure

it out by itself. Right here, it says

deployment failed due to port mismatch.

Cloud Run expects 8080. App used 30,000.

and is fixing the problem without my

intervention. That saved a lot of time.

Now, the cloud still needs a minute to

process the new deployment. I can speed

that up. But here's the difference. I'm

waiting and maybe having a cup of tea,

but I'm not working. I'm not frantically

searching Stack Overflow. I'm just

letting the agent handle the retry.

And it says deployment complete. The

application is now live on Cloud Run.

I'll click the public URL.

Ah, there's my app. I'll enter a fake

network name and password.

And it created a QR code as expected.

The app works in the cloud too, not only

on my machine. So, what are the big

takeaways from building the guest pass

app today? First, the shift is real. You

are no longer a brick layer typing

syntax. You are the architect using your

valuable skills to design the blueprint.

Second, anti-gravity is agentic. It

doesn't just write code. It wrote an

implementation plan, caught errors, and

drove the terminal itself.

And finally, Cloud Run is kind of like a

cheat code. It allows the infrastructure

to move as fast as the AI writing the

code. I handed Google the container and

it gave me a secure global URL.

Thank you everyone for watching. If you

have any questions for me, please add

them in the comments. Also, please let

me know what you thought of today's

episode. I read every single comment.

Now you have the tools, you have the

skills. I can't wait to see what you

build.

[music]

>> [music]