Topics: Google Antigravity · Agent Skills · SKILL.md · AI IDE · Developer Productivity · Gemini

Google Antigravity made the AI IDE agent-first — but most developers are still using it like a chatbot. The difference between a slow, forgetful agent and a fast, surgical one comes down to Skills. This guide covers everything: what Antigravity Skills are, how semantic triggering works, how to install 1,340+ pre-built skills in one command, how to write your own SKILL.md from scratch, and five real-world skill templates you can copy and use today.

TL;DR — Start using skills in 60 seconds:

# Install 1,340+ pre-built skills globally
npx antigravity-awesome-skills

# Verify installation
test -d ~/.gemini/antigravity/skills && echo "Skills installed"

Then open Antigravity and type: "Use security-review on this file" — the agent loads the matching skill automatically. That's it.

What Are Antigravity Skills?

Antigravity Skills are modular, file-based capability extensions for Google's Antigravity AI IDE. Each skill is a small directory containing a SKILL.md definition file and optional supporting assets — bash or Python scripts, reference documents, templates, or configuration files.

Unlike traditional system prompts that clutter the context window, Antigravity Skills are semantically triggered — the agent only loads the specific logic and scripts required for the current task. This is the core architectural insight that makes skills so powerful. The agent is not burdened by hundreds of instructions it doesn't need. It loads only the relevant skill, executes precisely, and moves on.

Think of a skill as a reusable playbook for a specific type of task. You write it once, store it in a folder, and the agent learns to use it automatically whenever the context matches. Instead of prompting "remember to follow conventional commits" in every session, you write a git-commit-formatter skill once — and it fires every time you ask the agent to commit code.

Skills effectively transform the AI from a generic programmer into a specialist that rigorously adheres to an organization's codified best practices and safety standards.

Why Skills Matter: The Tool Bloat Problem

If you've been using AI agents long enough, you've hit a wall: the longer your system prompt, the worse the agent performs. This is known as Tool Bloat or Instruction Fatigue — when the agent's context window is stuffed with instructions it doesn't need for the current task, its reasoning degrades, outputs become less predictable, and token costs climb.

Skills represent a shift from monolithic context loading to Progressive Disclosure. Rather than forcing the model to "memorize" every possible capability at the start of a session, Skills allow the developer to package specialized expertise — such as database migration protocols, security auditing workflows, or specific code review standards — into modular, discoverable units. The model is exposed only to a lightweight menu of these capabilities and loads the heavy procedural knowledge only when the user's intent matches a specific skill.

The result: a leaner context window, sharper reasoning, lower token spend, and an agent that behaves consistently — not approximately.

The real "unfair advantage" of Antigravity in 2026 is Semantic Triggering. By building modular Agent Skills, the IDE only equips specific logic when needed, saving you thousands in token costs and preventing model confusion.

Skills vs MCP Tools vs Rules vs Workflows

These four concepts often get confused. Here is the precise distinction between each:

Antigravity Skills vs MCP Tools vs Rules vs Workflows
Concept	What It Is	When It Loads	Best For
Skills	SKILL.md playbooks with optional scripts	On-demand, semantically triggered	Encoding how to perform a workflow — step-by-step procedures, team conventions, deployment logic
MCP Tools	External service integrations (APIs, databases)	Always available when configured	What the agent connects to — Slack, GitHub, databases, cloud services
Rules	Always-on instructions in agent config	Every session, always loaded	Global constraints — tone, language, forbidden patterns, output format
Workflows	Ordered sequences that chain multiple skills	Manually invoked by name	Complex multi-step processes — full deploy pipelines, onboarding sequences

Skills provide operating instructions — tools provide actions. A skill can call MCP tools as part of its execution steps. This is the cleanest mental model: use Rules for what the agent should always know, Skills for what it should know on-demand, MCP for what it should connect to, and Workflows to orchestrate it all together.

How Semantic Triggering Works

Semantic Triggering is the mechanism by which Antigravity automatically decides which skill to load — without you needing to name the skill explicitly. It is the most important concept to understand before writing your own skills.

When you type a command like "Check if the staging server is healthy," the Antigravity engine scans its available skills. If it finds a skill with a description like "Validates staging environment health and reports status," it dynamically loads that skill into the current context.

Here is exactly what happens under the hood:

Menu Scan: At the start of each agent turn, Antigravity reads the YAML description field from every installed skill's SKILL.md. This is a lightweight metadata-only read — the full skill instructions are not loaded yet.
Semantic Match: The agent compares your natural language input against all available descriptions using semantic similarity, not keyword matching. "Push my changes" will match a skill described as "commits and pushes code changes to the remote repository."
Just-In-Time Load: Only the matching skill's full instructions — and its scripts and references — are loaded into the active context window for that turn.
Execution: The agent follows the skill's instructions, executes any referenced scripts, and returns the result.
Context Release: After the turn completes, the skill is released from context. The next turn starts clean.

The description is mandatory and the most important field. It functions as the "trigger phrase." It must be descriptive enough for the LLM to recognize semantic relevance. A vague description like "does code stuff" will never trigger. A precise description like "Use this skill when the user asks to refactor a TypeScript class or convert JavaScript to TypeScript" will trigger reliably.

Two Scopes: Workspace vs Global

Skills can be installed in two locations, each with different availability and use cases:

Workspace Scope

<your-project-root>/.agent/skills/
└── my-skill/
    └── SKILL.md

Workspace Scope skills are available only within the specific project. This is ideal for project-specific scripts, such as deployment to a specific environment, database management for that app, or generating boilerplate code for a proprietary framework. Because they live in the project directory, you can commit them to Git and share them with your entire team — every developer gets the same agent behavior automatically.

Global Scope

~/.gemini/antigravity/skills/
└── my-skill/
    └── SKILL.md

Global skills are available across every project on your machine. Use Global for personal productivity patterns — your preferred commit message style, your code review checklist, your documentation template. These travel with you across every project you open.

Which Scope Should You Use?

Workspace vs Global Skill Scope Decision Guide
Situation	Use Scope
Deploy scripts specific to this app's infrastructure	Workspace
Database schema validation for this project's DB	Workspace
Shared team code review standards	Workspace (committed to Git)
Personal commit message formatter	Global
General security review checklist	Global
Your preferred documentation template	Global

Install Pre-Built Skills from GitHub

Before writing your own skills, it's worth exploring what already exists. The antigravity-awesome-skills repository is an installable GitHub library of 1,340+ agentic skills for Claude Code, Cursor, Codex CLI, Gemini CLI, Antigravity, and more. It includes an installer CLI, bundles, and workflows.

Install with npx (Recommended)

# Installs to ~/.gemini/antigravity/skills by default
npx antigravity-awesome-skills

# Install to a custom path
npx antigravity-awesome-skills --path ./my-skills

# Verify installation
test -d ~/.gemini/antigravity/skills && echo "✅ Skills installed" || echo "❌ Not found"

# Count installed skills
ls ~/.gemini/antigravity/skills/ | wc -l

Install via Global Toolkit CLI

# Install the Antigravity global toolkit
npm install -g @google/antigravity-toolkit

# Verify
antigravity --version

# Initialize in your project
cd my-project
antigravity init

# Install skills from the community repo
antigravity add skills --repo "romin-irani/antigravity-skills" --skill "typescript-refactor"

Manual Install via Symlink (Power Users)

# Clone the community repo
git clone https://github.com/sickn33/antigravity-awesome-skills ~/antigravity-skills

# Symlink all skills to your global directory
mkdir -p ~/.gemini/antigravity/skills
ln -s ~/antigravity-skills/skills/* ~/.gemini/antigravity/skills/

The symlink method is the most flexible — you can git pull the upstream repo at any time to get new skills, and your global directory updates automatically.

Verify a Skill Is Available

# Check if a specific skill is installed
ls ~/.gemini/antigravity/skills/ | grep security-review

# Inspect a skill's trigger description
head -5 ~/.gemini/antigravity/skills/security-review/SKILL.md

How to Write Your Own SKILL.md File

Writing a custom skill takes about five minutes for a simple case. Here is the complete process from directory creation to first use:

Step 1: Create the Skill Directory

# For workspace scope (project-specific)
mkdir -p .agent/skills/my-skill-name

# For global scope (all projects)
mkdir -p ~/.gemini/antigravity/skills/my-skill-name

Step 2: Create the SKILL.md File

touch .agent/skills/my-skill-name/SKILL.md

Step 3: Write the YAML Frontmatter and Instructions

---
name: my-skill-name
description: Use this skill when the user asks to [specific trigger phrases here]. Trigger on [keyword 1], [keyword 2], or [keyword 3].
---

# My Skill Name

## Purpose
Brief explanation of what this skill does and why it exists.

## Instructions
Step-by-step instructions for the agent:

1. First, do X
2. Then, check Y
3. If condition Z is true, do A; otherwise, do B
4. Finally, report the result to the user

## Rules
- Rule 1 the agent must follow
- Rule 2 (e.g., "Never modify files outside the src/ directory")

## End State
Tell the agent what success looks like. Example: "The task is complete when all tests pass and the output confirms zero errors."

Step 4: Test the Skill

Open Antigravity, start a new session, and type a natural language prompt that matches your description field. The agent should automatically load and follow your skill's instructions. If it doesn't trigger, the description field needs to be more specific or match the natural phrasing users would actually type.

Step 5: Refine via the Agent

If a skill doesn't work well for you, don't just manually fix the code — let the coding agent figure it out. Once it finds the solution, ask it to update the corresponding SKILL.md with the learned workflow. This will capture the corrected workflow for the future, ensuring the agent doesn't repeat the mistake while saving you tokens and time on the next run.

SKILL.md File Anatomy — Every Field Explained

The SKILL.md file is the brain of the Skill. It tells the agent what the skill is, when to use it, and how to execute it. Here is every component of a well-formed SKILL.md file:

Full Annotated SKILL.md Template

---
# YAML Frontmatter — this is the ONLY section indexed by the agent's router

name: skill-unique-id
# Optional. Lowercase, hyphens allowed. Defaults to directory name if omitted.
# Must be unique within its scope. Used for logs and workflow references.

description: >
  Use this skill when the user asks to perform a database health check,
  inspect table schemas, or verify data integrity in the PostgreSQL instance.
  Trigger on: "check database", "query schema", "inspect tables", "db health".
# Mandatory. This is the semantic trigger. Must be descriptive and precise.
# The agent matches your natural language against this field.
# Use active verbs and realistic user phrases.

version: "1.2.0"
# Optional but recommended for team environments.

author: "your-name"
# Optional. Useful in team repositories.

requires:
  node: ">=18"
  tools:
    - psql
    - python3
# Optional. Documents dependencies so teammates know what to install.
---

# Database Health Checker

## Purpose
This skill ensures the production PostgreSQL database is healthy before
any deployment. It prevents broken deploys caused by schema drift.

## Pre-Conditions
- psql must be installed and accessible in PATH
- DATABASE_URL environment variable must be set

## Instructions

1. Run the health check script located at `{{SKILL_PATH}}/scripts/health-check.py`
2. Parse the output for any ERROR or WARNING lines
3. If output contains "ERROR": respond with "🛑 Database check failed — do NOT deploy" and show the error lines
4. If output contains only "OK" lines: respond with "✅ Database healthy — safe to deploy"
5. If the script fails to run: check that psql is installed and DATABASE_URL is set

## Rules
- Never modify the database during this check
- Only read — never write
- Do not expose the DATABASE_URL value in your response

## Examples

### Example 1
User: "Is the DB ready for deployment?"
Agent: runs health check → "✅ Database healthy — safe to deploy"

### Example 2
User: "Check database before I push to production"
Agent: runs health check → finds error → "🛑 Database check failed: table users missing column updated_at"

## End State
Task is complete when the agent has run the script and displayed a clear ✅ or 🛑 status.

The Description Field — Most Important Part

Accuracy in the description is vital for the agent's trigger logic. Use active verbs like "Generate," "Verify," "Execute," or "Format" to help the semantic engine match prompts more accurately. Here are examples of weak vs strong descriptions:

Weak vs Strong SKILL.md Description Examples
Weak Description (Will Not Trigger Well)	Strong Description (Triggers Reliably)
Helps with git stuff	Formats git commit messages using Conventional Commits specification. Trigger when user asks to "commit", "save changes", "push changes", or "prepare a commit message".
Security things	Performs OWASP security review on code files. Trigger when user asks to "review security", "check for vulnerabilities", "audit this file", or "is this safe to merge".
Test generator	Generates and executes pytest unit tests for Python functions. Trigger on "write tests", "test this function", "add unit tests", or "fix bug" in Python files.
UI stuff	Enforces UI component standards — lucide-react icons, Tailwind CSS classes, Radix UI primitives. Trigger on "new component", "add icon", or "refactor UI".

5 Real-World Skill Examples (Copy-Paste Ready)

Example 1 — Git Commit Formatter

Path: .agent/skills/git-commit-formatter/SKILL.md

---
name: git-commit-formatter
description: Formats git commit messages using Conventional Commits specification. Use when the user asks to "commit", "save changes", "push changes", or "prepare a commit message".
---

# Git Commit Formatter

When writing a git commit message, follow the Conventional Commits specification:

**Format:** `<type>(<scope>): <short description>`

**Types:** feat, fix, docs, style, refactor, test, chore, perf, ci

**Rules:**
- Subject line max 72 characters
- Use imperative mood: "add feature" not "added feature"
- Breaking changes must include "BREAKING CHANGE:" in the footer

**Examples:**
- `feat(auth): add OAuth2 login with Google`
- `fix(api): resolve 500 error on empty payload`
- `chore(deps): upgrade Node.js to v22`

Example 2 — Security Code Review

Path: ~/.gemini/antigravity/skills/security-review/SKILL.md

---
name: security-review
description: Performs OWASP security review on code files. Trigger when user asks to "review security", "check for vulnerabilities", "audit this file", or "is it safe to merge".
---

# Security Code Review

## Instructions

1. Scan the provided file or diff for these OWASP Top 10 risks:
   - SQL Injection
   - Cross-Site Scripting (XSS)
   - Hardcoded secrets or API keys
   - Broken authentication
   - Insecure deserialization
   - Sensitive data exposure

2. For each risk found:
   - Mark severity: CRITICAL / HIGH / MEDIUM / LOW
   - Show the exact vulnerable line(s)
   - Explain the attack vector
   - Provide a fixed code snippet

3. Output a formatted Markdown checklist

## End State
"✅ No vulnerabilities found" or a numbered list of findings with severity and fix.

Example 3 — UI Component Standardizer

Path: .agent/skills/ui-standardizer/SKILL.md

---
name: ui-standardizer
description: Enforces UI component patterns for this project. Trigger on "new component", "add icon", "build a button", or "refactor UI".
---

# UI Standardizer

## Rules
- **Icons:** Only use `lucide-react`. Never use `react-icons` or `fontawesome`.
- **Styling:** Always use Tailwind CSS utility classes. Avoid CSS modules unless explicitly specified.
- **Components:** Use Radix UI primitives for accessible components (Modals, Dropdowns, Tooltips).
- **State:** Use React Context or Zustand. Never prop-drill more than 2 levels.

## Examples
User: "Add a search icon to the navbar"
Agent: imports `Search` from `lucide-react`, applies `w-4 h-4` Tailwind classes.

User: "Build a modal for the delete confirmation"
Agent: uses `Dialog` from `@radix-ui/react-dialog`, styled with Tailwind.

Example 4 — Python Test Generator

Path: .agent/skills/python-test-generator/SKILL.md

---
name: python-test-generator
description: Generates and runs pytest unit tests for Python functions. Trigger on "write tests", "test this function", "add unit tests", "fix bug", or any Python file review request.
---

# Python Test Generator

## Instructions

1. Identify all public functions or methods in the target file
2. For each function:
   - Write at least one happy-path test
   - Write at least one edge-case test (empty input, None, boundary values)
   - Write at least one error-case test (expected exceptions)
3. Use `pytest` and `unittest.mock` where needed
4. Run the tests: `pytest tests/ -v`
5. If tests fail:
   - Analyze the failure output
   - Identify the root cause
   - Fix the failing test or the function (ask user which to fix)

## Rules
- Test file naming: `test_{original_filename}.py`
- Test function naming: `test_{function_name}_{scenario}`
- Never modify production code without user approval

Example 5 — SEO Content Optimizer

Path: ~/.gemini/antigravity/skills/seo-optimizer/SKILL.md

---
name: seo-optimizer
description: Analyzes and optimizes content for SEO. Trigger when user asks to "optimize for SEO", "improve ranking", "write meta tags", "check keyword density", or "make this SEO-friendly".
---

# SEO Content Optimizer

## Instructions

1. Analyze the provided content for:
   - Primary keyword placement (title, H1, first 100 words, meta description)
   - Keyword density (target 1–2% — flag if above 3%)
   - Internal linking opportunities
   - Meta title length (50–60 characters)
   - Meta description length (150–160 characters)
   - H1/H2/H3 hierarchy structure
   - Image alt text presence

2. Output a structured audit with:
   - ✅ Passed checks
   - ⚠️ Improvements recommended
   - ❌ Critical issues

3. Provide rewritten versions of the title tag and meta description

## Rules
- Never keyword-stuff — suggest synonyms and LSI keywords instead
- Prioritize readability over keyword density

Skills With Execution Scripts

A skill can go beyond text instructions by bundling executable scripts. By bundling Python or Bash scripts, a Skill can give the agent the ability to perform complex, multi-step actions on the local machine or external networks without the user needing to manually run commands.

Directory Structure for a Script-Backed Skill

.agent/skills/
└── db-health-check/
    ├── SKILL.md          # Instructions and trigger description
    ├── scripts/
    │   └── check.py      # Execution script
    └── references/
        └── schema.sql    # Reference document (optional)

Referencing Scripts Inside SKILL.md

---
name: db-health-check
description: Checks PostgreSQL database health before deployment. Trigger on "check database", "db ready", or "safe to deploy".
---

# Database Health Check

## Instructions

1. Execute the check script: `python {{SKILL_PATH}}/scripts/check.py`
2. Parse the output for ERROR or OK lines
3. Report a clear status to the user

The {{SKILL_PATH}} and {{WORKSPACE_PATH}} template variables are resolved at runtime to the skill's actual directory path. Always use these instead of hardcoded absolute paths — they make skills portable across machines and teammates.

Safety: Auto-Execute Permissions

Because scripts can be destructive, it is a best practice to set your Antigravity Auto-Execute mode to "Ask" or "Off". This ensures the agent asks for permission before running terminal commands.

Configure this in Antigravity: Settings → Terminal Command Auto Execution → Ask Before Running. This way, you review every script the agent wants to execute before it runs — catching mistakes before they cause real damage.

Using Bundles: Role-Based Skill Packs

Bundles are curated recommendations for which skills to start with for a role or domain. Instead of browsing all 1,340 skills and deciding which ones to install, bundles give you a pre-curated starting set tuned for your specific role.

Available Bundles in antigravity-awesome-skills v9.2.0

Antigravity Skills Bundles by Role
Bundle Name	Best For	Key Skills Included
Essentials	Every developer — general use	Git formatter, code reviewer, documentation writer, brainstorming
Web Wizard	Frontend/full-stack developers	UI standardizer, TypeScript refactor, accessibility audit, performance check
Security Engineer	Security-focused developers and DevSecOps	OWASP review, dependency audit, secrets scanner, pen-test scaffold
TDD Architect	Developers who practice test-driven development	Test generator, coverage reporter, mock builder, regression finder
Loki Mode	Autonomous mode power users	Multi-agent orchestration, autonomous deploy, self-healing scripts
Growth & Product	Product managers, growth engineers, SEO	SEO optimizer, analytics scaffold, A/B test generator, content auditor

Install a Bundle

# Install the Essentials bundle
npx antigravity-awesome-skills --bundle essentials

# Install the Web Wizard bundle
npx antigravity-awesome-skills --bundle web-wizard

# Install the Security Engineer bundle
npx antigravity-awesome-skills --bundle security-engineer

Using Workflows: Multi-Skill Execution Chains

Workflows are ordered execution playbooks that show how to combine multiple skills step by step. Where a single skill handles one task, a workflow chains multiple skills together into a full pipeline.

For example, a "Safe Deploy" workflow might chain:

security-review — scan for vulnerabilities
python-test-generator — run full test suite
db-health-check — verify database is healthy
staging-deploy — push to staging environment
smoke-test — run smoke tests against the staging URL

A workflow file lives in .agent/workflows/ and references skills by name:

---
name: safe-deploy
description: Full pre-deploy pipeline — security, tests, DB health check, staging deploy, and smoke test.
---

# Safe Deploy Workflow

## Steps

1. Run skill: security-review on src/
2. Run skill: python-test-generator (execute all tests)
3. Run skill: db-health-check
4. If all steps pass (no ❌): Run skill: staging-deploy
5. Run skill: smoke-test --url https://staging.myapp.com
6. Report final status: ✅ Deploy complete or ❌ Step N failed

Invoke the workflow by asking: "Run the safe deploy workflow" — the agent chains every skill in order, stops on failure, and reports the full result.

Best Practices for Writing High-Quality Skills

Following these patterns separates reliable, production-grade skills from fragile, occasionally-working ones:

1. Keep Skills Atomic

A skill should do one thing well. Instead of a "DevOps" skill, create separate skills for "Staging Deploy," "Log Analysis," and "Health Check." Atomic skills are easier to test, easier to share, and compose cleanly into workflows. A "Swiss Army Knife" skill becomes unpredictable — the agent won't know which capability to activate.

2. Write Precise, Verb-Led Descriptions

Use specific verbs in your descriptions like "Generate," "Analyze," "Execute," or "Validate." Include 2–3 "Few-Shot" example trigger phrases in the description to significantly improve the model's accuracy.

3. Include a Decision Tree for Script-Backed Skills

The description tells the AI when to use the skill. Phrases like "Use this whenever the user asks 'Is it safe to merge?'" act as semantic triggers. Inside the Markdown body, define a decision tree — explicitly telling the AI what to do for each possible script output prevents the AI from making subjective guesses.

4. Use {{SKILL_PATH}} for Portability

Always use the {{SKILL_PATH}} and {{WORKSPACE_PATH}} variables instead of hardcoded absolute paths. This ensures your skill works identically on your machine, your teammate's machine, and in CI environments.

5. Define a Clear End State

Since skills are ephemeral, ensure they don't leave "ghost" instructions in the conversation by clearly defining the "End Task" in the instructions. An ambiguous end state leads to the agent continuing to act after the task is done.

6. Document Dependencies

If your skill requires psql, kubectl, python3, or any external CLI tool, list it in the requires block of the YAML frontmatter. This is documentation — it tells teammates what they need to install before the skill will work.

7. Treat Skills as Living Documents

Because skills are AI-generated or human-authored, they might not work perfectly for your specific environment on the first try. When a skill fails, don't just manually fix it — let the agent figure out the solution, then ask it to update the SKILL.md. Think of these as living documents that actively improve as you build.

Living Skills: Let the Agent Improve Its Own Instructions

One of the most powerful — and underused — patterns in Antigravity skill development is the self-improving skill. The idea: when a skill execution fails or produces a suboptimal result, you ask the agent to diagnose the problem and update the SKILL.md file itself.

Here is the workflow:

A skill executes and produces an unexpected or wrong result
You ask the agent: "This skill didn't work correctly. Here's what went wrong: [describe the issue]. Update the SKILL.md to fix this behavior."
The agent analyzes the failure, identifies the gap in the instructions, and rewrites the relevant section of SKILL.md
The next execution follows the corrected instructions automatically

This is what makes skills genuinely powerful over time. Your personal skill library becomes increasingly tuned to exactly how you work — encoding your team's tribal knowledge, edge cases you've hit, and production lessons you've learned. A skill you wrote in January will be smarter in March than the day you created it.

This "vibe coding" of your agent's behavior — iterating on SKILL.md files the same way you iterate on code — is one of the defining developer patterns in 2026.

Permission Model and Safety Configuration

Giving an AI agent access to your terminal and browser is a double-edged sword. It enables autonomous debugging and deployment but also opens vectors for prompt injection and data exfiltration. Antigravity addresses this through a granular permission system revolving around Terminal Command Auto Execution policies, Allow Lists, and Deny Lists.

Terminal Command Auto Execution Settings

Antigravity Terminal Command Auto Execution Policies
Policy	Behavior	When to Use
Auto	Agent runs all terminal commands without asking	Fully trusted personal machine only — high risk
Ask (recommended)	Agent shows the command and asks permission before running	Daily development — you review each action
Off	Agent cannot run any terminal commands	Read-only review sessions, untrusted contexts

Allow Lists and Deny Lists

Use Allow Lists to whitelist specific commands a skill can run without prompting. Use Deny Lists to permanently block commands that should never run — for example, rm -rf, DROP TABLE, or any command that modifies production data.

Configure in Antigravity: Settings → Security → Terminal Command Policy.

Using Antigravity Skills with Claude Code

The antigravity-awesome-skills library is not exclusive to Google Antigravity. It is built for major agent workflows including Claude Code, Cursor, Codex CLI, Gemini CLI, Antigravity, Kiro, OpenCode, Copilot, and more.

For Claude Code specifically, skills install to a different path:

# Install skills for Claude Code
npx antigravity-awesome-skills --tool claude-code

# Default Claude Code global skills path
~/.claude/skills/

# Workspace path for Claude Code
.claude/skills/

The SKILL.md format is identical — the same file works across tools. You write the skill once and it is compatible with every major AI coding assistant that supports the SKILL.md open format.

For a deeper look at Claude Code's own capabilities and how it compares to other AI coding environments, see our guide on Claude Code vs GitHub Copilot. And if you're using OpenClaw alongside Antigravity, our OpenClaw CLI commands reference covers how to manage OpenClaw skills and plugins from the terminal.

Frequently Asked Questions

What are Antigravity Skills?: Antigravity Skills are modular, file-based extensions that transform the Antigravity AI agent from a simple coding assistant into a functional autonomous engineer. By utilizing a specialized framework centered around a SKILL.md definition file, these skills allow the agent to perform real-world actions — such as executing terminal commands, querying databases, interacting with APIs, and managing local files — with surgical precision.
How do I install Antigravity Skills from GitHub?: Run npx antigravity-awesome-skills in your terminal. This installs 1,340+ pre-built skills to ~/.gemini/antigravity/skills by default. Use the --path flag to install to a custom location. Use --bundle to install only a role-specific curated set.
What is the difference between Workspace Scope and Global Scope?: Workspace Scope skills live in .agent/skills/ inside your project root — project-specific, committable to Git, shared with your team. Global Scope skills live in ~/.gemini/antigravity/skills/ — available across every project on your machine. Use Global for personal productivity patterns; use Workspace for project-specific workflows.
What is the most important field in a SKILL.md file?: The description field in the YAML frontmatter. It is the semantic trigger — the agent matches your natural language against this field to decide which skill to load. Make it precise, use active verbs, and include realistic trigger phrases.
What is the difference between Antigravity Skills and MCP tools?: Skills provide operating instructions — how to perform a workflow. MCP tools provide actions — what external systems to connect to. A skill can call MCP tools as part of its steps. Use skills to encode workflow logic; use MCP for integrations. For more on how AI agents connect to external tools, see our guide on building local AI agents with Python and LangChain.
Can I use Antigravity Skills with Claude Code and Cursor?: Yes. The SKILL.md format is an open, cross-agent standard. The same file works with Claude Code, Cursor, Codex CLI, Gemini CLI, and others. The install path differs per tool — use --tool claude-code or --tool cursor flags with the npx installer.
Do skills work with AI models other than Gemini?: In Google Antigravity, the Gemini 3 family is the default model. However, the skill format itself is model-agnostic. The antigravity-awesome-skills library explicitly supports Claude, GPT, and Gemini-backed agents. Skills are Markdown — any agent that can read Markdown can use them.

Conclusion

Antigravity Skills are the difference between an AI agent that vaguely helps and one that works exactly the way your team does. By encoding your deployment process, code review standards, testing patterns, and project conventions into SKILL.md files, you transform a generalist Gemini model into a specialist that knows your codebase — and gets better with every session.

Here is what to do next, in order:

Run npx antigravity-awesome-skills to install the community library
Pick the bundle that matches your role (Essentials for most developers)
Test three pre-built skills with natural language prompts in Antigravity
Write your first custom skill — start with something simple like a Git commit formatter
Add a skill for your most repetitive daily task — deploy check, PR review, or documentation template
Commit Workspace skills to your team's repository so everyone benefits

The developers who win in 2026 won't be the ones who write the most prompts — they'll be the ones who build the best skill libraries.

Continue exploring on Cloudvyn: