Google Antigravity: how to combine rules, skills, and workflows for reliable AI agents

Google Antigravity is gradually turning the AI assistant from an autocomplete tool into a configurable engineering agent. Instead of issuing one-off prompts, developers give it working rules, discrete skills, and ready-made scenarios, then kick off a repeatable QA process with a single command. In practice, code review, refactoring, and test generation can be assembled into a local pipeline without external orchestrators and without constant manual supervision at every step.

Three building blocks: rules, skills, workflows

The core idea revolves around three building blocks. Rules set the agent's baseline constraints: code style, accepted practices, and the project's technology boundaries. Skills act as reusable knowledge packages for a specific task, such as code review, deployment, or writing tests. Workflows tie all of this into a sequence of actions you can invoke with a slash command. Google's documentation compares workflows to saved prompts and rules to system instructions. The point of this layering is to keep the agent from pulling the entire set of instructions into context at once; it loads specialized instructions only when needed.

Progressive disclosure and skill structure

Google is also betting on progressive disclosure. A skill doesn't sit in the model's context permanently: at first the agent sees only a short description of the skill, and it loads the full instructions only when the task actually matches the skill's purpose. This cuts down on clutter from unnecessary tools and rules, reduces latency, and helps keep the model's behavior from drifting. A skill can also be more than a text note: it can be a small project folder with a SKILL.md file, additional scripts, reference materials, and assets. Skills can be stored globally for all projects or locally inside a specific workspace if they're tied to one team's stack and processes.

Hands-on scenario: QA for Python

The hands-on scenario for Antigravity is fairly down-to-earth: QA for Python code. You create .agents/rules and .

agents/skills folders in the workspace, then add a Python rule that requires PEP 8, uses black for formatting, and restricts dependencies to free open-source packages. You can attach this rule to a glob pattern covering all .py files so it applies automatically to any Python code.

Separately, you set up a test-generation skill: it lives in its own directory, contains the required SKILL.md file, and describes how the agent should write coverage for code that has already been reviewed. This keeps the setup modular: project standards live apart from one-off chat commands.

On top of these blocks, you then build a workflow with a name like qa-check. It instructs the agent, step by step, to open the current Python file, find bugs and style violations, simplify inefficient sections if needed, then invoke the testing skill, and finally output ready-to-use unit tests with a recommendation to run pytest in the terminal. The demo uses a deliberately sloppy division function with poor formatting and no handling for division by zero.

After the workflow runs, the agent doesn't just rewrite the code more cleanly; it also proposes a test suite covering normal, negative, and fractional values, plus a separate case for division by zero with the expected error. This matters: Antigravity doesn't stop at cosmetic refactoring here, but carries the task through to a verifiable result, where test logic confirms the code's quality.

What this changes for teams

This approach has two practical consequences. First, teams can build repeatable engineering routines inside the IDE without a separate automation layer on top of the editor. Second, the AI agent stops acting as a general-purpose conversational partner and starts working as a specialized executor with a clear area of responsibility. For development, that means less manual switching between review, fixes, and testing. For Google, it's another step toward having Antigravity compete not only with coding assistants but with full agentic work environments.

In brief:

• Antigravity turns the AI assistant into a configurable engineering agent with repeatable, one-command QA.
• Three building blocks: rules (constraints), skills (knowledge packages), workflows (slash commands), plus progressive disclosure.
• In the QA scenario, the agent carries the task through to verifiable unit tests rather than just refactoring the code.