Intro

Hey everybody. We're gonna take a quick break from going over Firebase details to jump into a new release of Google Antigravity. So if anyone's been using Claude in the last several months, "Skills" are a developing standard that have proven to be quite helpful. And we now have them available here in Antigravity.

So released just today. If you run to the documentation for Google Antigravity, they have a very brief description. If you scroll through, they give you basic guidance on how to create a skill and the basic file format and directory locations to get you started. They also link to the open standard, which is right here. And this has been put out by Anthropic with support growing across all the different LLM providers and development tools. You can see here pretty much every name has it listed. There's a specification, reference library and most importantly, some example skills. So if you come in over here to "anthropic/skills" repository and you jump into the skills directory, they have listed several different skills that the community, actually, I guess just Anthropic has provided.

Skills Creating Skills

The most important one to get started for creating your own skills is this "skill-creator". Let's go ahead and take a look at it. Most importantly, the "SKILL.md". This gives guidance in kind of a meta fashion of how to create skills as an LLM given this skill.

So you can take a look at the basic directions and it is concise, yet descriptive. And I recommend before you create any skills of your own, you go ahead and add this as the first skill to your working directory.

Adding a Code Review Skill

And with that overview in place, let's go ahead and just go into some code just to show off how you can ultimately use the LLM to create at least a starting point for any number of skills that can help guide your development. So here I have brought over the skill-creator from the Anthropic repo.

You can see the same markdown file as well as the references and scripts that we saw in the GitHub repo. Let's go ahead and start with a code-review skill. This can be helpful just to guide the LLM to more specifics about your repo whenever you want it to do a code review. So we'll jump over into the Agent Manager and let's go ahead and ask it to create a skill.

So "let's create a code review skill that references specific details from our AGENTS.md and uses our typecheck, linting scripts as part of its work".

So this should run through and you'll see it does load up. We lost it, but it does load up the skill that we added for adding new skills.

And we now have an implementation plan. So as you can see, it is giving us a suggested name. No new permissions are required. It's gonna create the SKILL.md file. It reviewed our code base and found the correct validate call. But we are using pnpm. So let's make a note there. To review a little bit further, got our compliance details, and that all looks pretty good. We'll at least give it a go and we can review it once it's generated.

All right. Let's take a look at this again. We do have now the PNPM setting. I think everything in general looks good. Let's go ahead and proceed.

We will allow it to create the directory.

All right. Let's take a look at the walkthrough, see what it describes.

And it's doesn't have a ton of information. Probably better to just go ahead and look at the generated file. So let's go over to the editor to look. We'll expand our skills.

Reviewing our Code Review Skill

We now have our code review, and you can see it has the front matter here with name and description, and it's following the guidance of our skill-creator skill to use directive language. We've got a usage, yep, with specific snippets of language we might use. Contextualize and validate. We make sure we run our automated checks before moving on, which I think is good guidance. Analyze our changes with a diff. And it does have, as you can see, specifics to our repo referencing explicitly our @packages/ui package.

Adjusting our Code Review Skill

Guidance on skills say that we shouldn't reference back to your README and your AGENTS.md file. It's better to have these available here. So let's add a direction: " let's pull out specific references to our AGENTS.md to be copied here".

And our goal here is to have the content available in the skill since to load the full AGENTS.md file is gonna add a lot more tokens to our context, even though Gemini especially has such a large context window. Okay, so now we've got pulled out, explicitly the bits of the AGENTS.md file that we want to use as part of our code review. It would be better if it actually listed the section. So let's do one more change to that "add reference to specific section anywhere AGENTS.md is used to ease lookup".

All right, and now you can see it explicitly references the section. This can be helpful if it needs to go to our AGENTS.md or as users we need to go see where we're referencing and can ensure things are consistent. So this looks to be a pretty good general code review skill . As we move on in our project and run into new issues or add new tools we can continue to edit this to reflect just what we want in our code review. So to test it, let's go ahead and ask it to do a code review.

Running a Code Review

So "do a full code review on our project". Let's see what we get.

You'll notice while we wait for this to finish, it does define a specific section on what to generate when it generates the review. So we will get an output file when it does run. And we also ask it to do a validate before it actually reviews the code to make sure it at least passes deterministic validation.

So we'll go ahead and run that. And we succeeded.

You can see here it's currently analyzing our package.json, to look at tech stack alignment.

And now it's working on the report.

Okay, and so we get a code review report out of this. What's nice is we get a nice, green check mark that our automated checks did run. We get a nice summary and we get a, basically our different sections, so "Standards & Alignment" and ensured that we had the right "Architectural Integrity". And because we added the sections, we get those referenced, which can be great just for review later on. We can see here we did find a minor drift between what we have documented and the implementation. Yep, we're using 16 yet our AGENTS.md file is asking for 15 for Next.js. Our versions do match. So yeah, let's go ahead and get this fixed up. So one of my favorite things about Antigravity is just all of the integrated capabilities for both referencing file and line numbers, as well as easily adding comments as you get reports and other walkthroughs from LLM generation.

So we'll submit.

Fixing after Code Review

Okay, so let's look at our AGENTS.md, we did update the documentation. Let's accept that. And let's look at our skill. Made sure to reflect. I never accepted these. Let's accept them. And let's do another code review. So " code review again after our fixes".

All right. It's gonna ask for validation and we will run that script.

All right, let's look at our report.

Looking quite nice. Got an excellent status. Always feels good when you're complimented by your agent. No critical issues found. And we got good check marks throughout.

So Many Good Skills

So as you can imagine, this code review report could be written to file, can be version controlled alongside your repo, could also be added to pull requests just so you have documentation up in GitHub that code reviews are being applied as feature requests come through.

Ultimately just a excellent bit of agent capability. So I would encourage you to explore as much as you want. If you've already been using Claude, I'm sure you've already been using skills, but to have the excellent UX that comes with Antigravity as well as having full skills support built in, I think is a major win.

Just brings Antigravity further and further in competition with Claude, Cursor and the likes.

So tune in. We'll be back to Firebase next, but wanted to get this in while the iron was hot with the new release of skills and Antigravity. Catch you next time.