Build Better AI Agents with Google Antigravity Skills and Workflows

Photo by editor

# Introduction

Chances are, you’ve already realized that the new, agent-first era of artificial intelligence is in which developers are embracing new tools that genuinely understand the unique processes behind code generation, rather than generating code reactively.

Google Anti-Gravity There is much to be said for this matter. This tool holds the key to building highly customizable agents. This article uncovers part of its potential by demystifying three foundational concepts: rules, expertise, and workflow.

In this article, you’ll learn how to combine these key concepts to build more robust agents and powerful automated pipelines. Specifically, we’ll walk through a step-by-step process for setting up a code quality assurance (QA) agent workflow based on specific principles and skills. Let’s go!

# Understanding three basic concepts

Before getting your hands dirty, it’s easy to break down the following three elements of the Google Antigravity ecosystem:

• Principles: These are the basic constraints that dictate the agent’s behavior, as well as how to adapt it to our stack and match our style. They are saved as Markdown files.
• Skills: Think of skills as reusable packages containing knowledge that instruct the agent how to solve a concrete task. They are allocated in a dedicated folder with a file name. SKILL.md.
• Workflow: It is the orchestrators who hold it all together. Workflows are invoked using command-like directives preceded by a forward slash, e.g /deploy. Simply put, a workflow guides an agent through an action plan or trajectory that is well-structured and consists of multiple steps. This is the key to automating repetitive tasks without loss of accuracy.

# Taking action

Let’s move on to our practical example. We’ll see how to set up Antigravity for review. The python Code, apply correct formatting, and develop tests — all without the need for additional third-party tools.

Before doing these steps, make sure you have downloaded and installed Google Antigravity on your computer first.

Once installed, open the desktop application and open your Python project folder – if you’re new to the tool, you’ll be asked to designate a folder on your computer file system to act as the project folder. Regardless, the way to add a manually created folder to Antigravity is through the “File >> Add Folder to Workspace…” option in the top menu toolbar.

Say you have a new, empty workspace folder. In the root of the project directory (on the left), create a new folder and name it .agents. Within this folder, we’ll create two subfolders: one called rules And the name of one skills. You can guess that these two are the places where we will define the two pillars for our agent’s behavior: rules and skills.

Project Folder Hierarchy | Photo by author

Let’s first define a rule, which contains our basic constraints that will ensure the agent’s adherence to Python formatting standards. We don’t need verbose syntax to do this: in Antigravity, we define it using clear instructions in natural language. within the rules subfolder, you will create a file named python-style.md And paste the following content:

# Python Style Rule
Always use PEP 8 standards. When providing or refactoring code, assume we are using `black` for formatting. Keep dependencies strictly to free, open-source libraries to ensure our project remains free-friendly.

If you want to nail it, go to the active agent customizations panel on the right side of the editor, open it up, and find and select the rule we just described:

Customizing the activation of agent rules | Photo by author

The customization options will appear above the file we just edited. Set the activation model to “Globe” and define this globe pattern: **/*.pyas shown below:

Setting Globe Activation Mode | Photo by author

With this, you just ensure that the agent that will be launched later always applies this rule when we are working on a Python script specifically.

Next, it’s time to describe (or “teach”) some skills to the agent. It will be a skill to perform robust tests on Python code – extremely useful in today’s demanding software development landscape. within the skills subfolder, we will create another folder with the name pytest-generator. Make a SKILL.md file inside it with the following content:

Defining agent skills within a workspace | Photo by author

Now it’s time to put it all together and launch our agent, but not without an example Python file inside our project workspace that contains the “poor quality” code to try it all out first. If you don’t have one, try creating a new one. .py File, it’s called something like this. flawed_division.py in the root directory, and add this code:

def divide_numbers( x,y ):
  return x/y

You may have noticed that this Python code is intentionally messy and buggy. Let’s see what our agent can do about it. Go to the Customization panel on the right, and this time focus on the “Workflows” navigation pane. Click “+Workspace” to create a new workflow that we’ll call qa-checkWith this content:

# Title: Python QA Check
# Description: Automates code review and test generation for Python files.

Step 1: Review the currently open Python file for bugs and style issues, adhering to our Python Style Rule.
Step 2: Refactor any inefficient code.
Step 3: Call the `pytest-generator` skill to write comprehensive unit tests for the refactored code.
Step 4: Output the final test code and suggest running `pytest` in the terminal.

All these pieces, when glued together by the agent, will change the development loop as a whole. With the dirty Python file still open in the workspace, we’ll fire up our agent by clicking the agent icon in the right-hand panel, typing qa-check command, and press Enter to run the agent:

Invoking QA Workflow through the Agent Console | Photo by author

After execution, the agent will have revised the code and a new version will be automatically proposed in the Python file, as shown below:

Refactored code suggested by Agent | Photo by author

But that’s not all: the agent also comes with the comprehensive quality testing we were looking for by generating a large number of code snippets you can use to run a variety of tests. pytest. For example, some of these tests look like this:

import pytest
from flawed_division import divide_numbers

def test_divide_numbers_normal():
    assert divide_numbers(10, 2) == 5.0
    assert divide_numbers(9, 3) == 3.0

def test_divide_numbers_negative():
    assert divide_numbers(-10, 2) == -5.0
    assert divide_numbers(10, -2) == -5.0
    assert divide_numbers(-10, -2) == 5.0

def test_divide_numbers_float():
    assert divide_numbers(5.0, 2.0) == 2.5

def test_divide_numbers_zero_numerator():
    assert divide_numbers(0, 5) == 0.0

def test_divide_numbers_zero_denominator():
    with pytest.raises(ValueError, match="Cannot divide by zero"):
        divide_numbers(10, 0)

This sequential process performed by the agent consists of first analyzing the code we defined by the rules, then autonomously calling the newly defined skills to develop a comprehensive testing strategy tailored to our code base.

# wrap up

Looking back, in this article, we’ve shown how to combine the three key elements of Google Antigravity—rules, expertise, and workflow—to transform ordinary agents into specialized, robust, and efficient collaborators. We illustrated how an agent has to master the proper formatting of mass code and the ability to define QA tests.

Iván Palomares Carrascosa He is a leader, author, speaker, and consultant in AI, Machine Learning, Deep Learning and LLMs. He trains and guides others in using AI in the real world.