~/.gemini/antigravity/skills/. Antigravity loads a skill automatically whenever your task context matches the skill’s description — no commands required. Once loaded, the skill governs how the agent approaches that task.
How skills work
Every skill is a markdown file with aname and description in its frontmatter. When you start a task, Antigravity checks all skill descriptions against your current context. If one matches, it loads the full skill content and the agent follows its process.
The bootstrap block in GEMINI.md enforces a mandatory skill-check protocol:
Before every response, Antigravity announces “Checking applicable skills…” — even for clarifying questions, even when no skill applies. Silence is not a valid skill check.
The mandatory skill-check protocol
Theusing-superantigravity skill establishes the rule: if you think there is even a 1% chance a skill might apply, you must let Antigravity load and read it. The check is complete only when the agent has either announced which skill was loaded or stated explicitly that no skill matched.
Common rationalizations that indicate the protocol is being skipped:
| Thought | Reality |
|---|---|
| ”This is just a simple question” | Questions are tasks. Check for skills. |
| ”I need more context first” | Skill check comes before clarifying questions. |
| ”I already know this skill” | Skills evolve. Let Antigravity load the current version. |
| ”The skill is overkill” | Simple things become complex. Use it. |
Skill priority
When multiple skills could apply, follow this order:- Process skills first —
brainstormingandsystematic-debuggingdefine how to approach the task before any implementation begins. - Implementation skills second —
architecture-design,deep-research, and similar skills guide execution once the approach is clear.
- “Let’s build X” → load
brainstormingfirst, then implementation skills - “Fix this bug” → load
systematic-debuggingfirst, then domain-specific skills
Skill types
Rigid skills must be followed exactly, step by step. Deviating from the process defeats its purpose:test-driven-development— the red-green-refactor cycle is non-negotiablesystematic-debugging— the four phases must complete in order
Conversation modes
Antigravity has two conversation modes. Skills tell you which to use:- Planning Mode — required for
brainstorming,writing-plans,deep-research, andsystematic-debugging - Fast Mode — recommended for
executing-plans,test-driven-development, and batch implementation
Workflow pipeline skills
Adapted from Superpowers. These 12 skills form the full development pipeline from idea to merged branch.| Skill | Fires when… |
|---|---|
brainstorming | You want to build something new or add a feature |
writing-plans | You have an approved design ready to implement |
executing-plans | You have a written implementation plan to execute in a separate session |
subagent-driven-development | Executing plans with fresh subagents per task in the current session |
test-driven-development | You are implementing any feature or bug fix |
systematic-debugging | You encounter a bug, test failure, or unexpected behavior |
verification-before-completion | You are about to claim something is done |
requesting-code-review | Completing a task or feature and need a review before proceeding |
receiving-code-review | You receive code review feedback to evaluate and implement |
finishing-a-development-branch | Implementation is complete and all tests pass |
dispatching-parallel-agents | You have 2+ independent tasks that can be worked on simultaneously |
writing-skills | Creating or editing Antigravity skills |
Specialist skills
Adapted from SuperClaude. These skills fire based on the nature of the task rather than its position in the pipeline.| Skill | Fires when… |
|---|---|
deep-research | The task needs external information before proceeding |
architecture-design | You are designing systems, APIs, or significant features |
security-review | Code touches auth, input handling, or sensitive data |
performance-optimization | Code needs profiling and optimization |
confidence-check | You are about to implement and want to verify readiness |
browser-agent | Testing UI flows, verifying web app behavior, browser automation |
dependency-management | Adding, updating, auditing, or evaluating project dependencies |
Documented skills
The following 13 skills have dedicated reference pages with full process details:Brainstorming
Turns ideas into approved designs before any code is written.
Writing plans
Converts approved designs into bite-sized, TDD-ready implementation tasks.
Executing plans
Runs implementation plans in batches with checkpoints between each batch.
Test-driven development
Enforces red-green-refactor for every feature and bug fix.
Systematic debugging
Four-phase root cause investigation before any fix is attempted.
Verification before completion
Requires running verification commands before any completion claim.
Deep research
Multi-source research with source quality ranking and confidence levels.
Architecture design
Constraint-first option evaluation with documented decision records.
Security review
OWASP Top 10 checklist for every security-sensitive code change.
Performance optimization
Measure-first profiling before any optimization is applied.
Confidence check
Self-assessment gating before implementation begins.
Browser agent
Delegates UI testing and browser automation to Antigravity’s built-in browser subagent.
Dependency management
Deliberate evaluation criteria for every dependency decision.
Additional installed skills
Six more workflow pipeline skills are installed and fire automatically. They are documented inline within their workflow context:| Skill | Purpose |
|---|---|
subagent-driven-development | Executes plans by dispatching a fresh subagent per task with two-stage review (spec compliance then code quality). Used within the /implement workflow when staying in the same session. |
requesting-code-review | Dispatches a code-reviewer subagent to review a completed task against the plan. Fires after each task in subagent-driven development. |
receiving-code-review | Governs how to receive and evaluate code review feedback — requires technical verification before implementing suggestions, not blind agreement. |
finishing-a-development-branch | Presents four structured options when implementation is complete: merge locally, push and create a PR, keep the branch, or discard. Runs tests before offering options. |
dispatching-parallel-agents | Guides dispatching independent problems to separate agents that work concurrently. Use when 3+ test files fail with different root causes, or when multiple subsystems are broken independently. |
writing-skills | Teaches how to create new Antigravity skills using TDD-for-documentation. Includes frontmatter format, description writing, and testing methodology. |
Inspecting skills
Skills live in~/.gemini/antigravity/skills/. You can read any skill file directly to see the exact process the agent follows:
writing-skills skill (available after installing SuperAntigravity).