Antigravity Skill Worth Installing in 2026 (Tested)

Skills are a godsend. It's so simple, barely a few markdown files, yet it just eases 40% of your workload instantly.

The internet is filled with random Skill repositories claiming to be useful. However, they can be a huge security risk. And you should do due diligence before any Skills that touch your code base.

I use many tools daily, including Datadog, Linear, GitHub, Slack, and Notion. And there are. a lot of repeated mundane tasks. So, I have compiled some of the Skills that are actually useful for a developer using a code editor like AntiGravity.

Summary

• Composio — One skill that connects your agent to 1000+ SaaS apps with managed auth and zero integration code.

• Context7 — Up-to-date, version-pinned library docs so the agent stops hallucinating APIs.

• Vercel — Deploy what your agent builds and get a live preview URL in seconds.

• Playwright — A real browser the agent can drive to automate any site, even ones without an API.

• Cloudflare — Build and ship edge infrastructure (Workers, D1, R2, Queues) with the right primitive picked for you.

• Exa — Semantic web search built for agents, returning clean content instead of blue links.

• Firecrawl — Turns any URL (including JavaScript-heavy sites) into clean, LLM-ready markdown.

• Datadog — Query logs, metrics, and APM traces directly so the agent can investigate, not just observe.

• Neon — Serverless Postgres with instant database branching for safe agent experimentation.

Best Antigravity Skills in 2026

1. Composio Skill — Connect agents to 1000+ SaaS apps in seconds

If I had to pick one skill to install first, this is it. Not because I work adjacent to it, but because every other skill on this list does one thing. Composio is the connective tissue between them.

Antigravity is great at reasoning and orchestration. What it doesn't do natively is talk to the 1000+ SaaS apps you actually use via MCP and CLI — GitHub issues, Linear tickets, Slack threads, Stripe customers, Salesforce records, Jira sprints. Composio gives your agent a single interface to all of them. No separate auth flows, no token juggling, no rewriting integrations every time an API changes.

What it actually feels like to use:

You install it once:

npx skills add composiohq/skills

Then, in your agent flow, instead of writing a custom GitHub client, you just do:

Find all open PRs in our repo assigned to me, 
summarize them in a Slack message to #eng, and create a 
Linear issue for any that have been open more than 7 days.

That's three tools (GitHub, Slack, Linear), three auth contexts, three response formats. Composio handles all of it. The agent figures out which actions to call, runs them in sequence, and you get the result. No glue code.

What makes it different from rolling your own integrations:

• Auth is solved. OAuth, API keys, refresh tokens, scopes — Composio holds them. Your agent never sees a credential.

• It's framework-agnostic. Works with Antigravity, the Claude Code, Codex, LangChain, and the Vercel AI SDK.

• Triggers, not just actions. Most skills are reactive (you call them). Composio supports event-driven flows — "when a new Stripe payment fails, trigger this agent." That turns Antigravity from something you prompt into something that runs.

• Errors are handled as data. When an API rate limit or a token expires, the agent sees a structured error it can recover from, not a stack trace.

A real workflow I built last week:

I wanted my agent to triage incoming customer questions across three inboxes (Gmail, Intercom, support@), extract the underlying request, check our docs for an existing answer, and either reply with a draft or escalate to Linear with full context. With Composio, it's a single-agent loop that calls 4 tools. Without it, that's a week of integration work and a permanent maintenance burden.

Who should install this:

Anyone whose agent needs to do more than chat. If your workflow touches even two external services, you'll save more time setting this up than you'll spend reading this article.

• Full toolkit list: composio.dev/toolkits

• Read blog post on: How to add MCP to Antigravity

2. Context7 — Up-to-date docs for every library your agent touches

The single most common failure mode in agent-written code is the hallucination of APIs. The agent confidently calls a method that doesn't exist, uses a deprecated parameter, or imports from a path that hasn't existed since v3. It looks right. It doesn't run.

Context7 fixes this by giving your agent live, version-specific documentation for thousands of libraries. Instead of guessing how react-query's useMutation works (and getting it subtly wrong because the agent's training data is from 18 months ago), the agent pulls the current docs for the version you're actually using and writes code against the real API.

Install Context7 CLI

npm install -g ctx7

# Verify installation
ctx7 --version

Use the CLI to discover and install Skills

# Search the registry by keyword
ctx7 skills search pdf
ctx7 skills search "react testing"

# Browse all skills in a specific repository
ctx7 skills info /anthropics/skills

# Install a skill interactively (prompts you to pick)
ctx7 skills install /anthropics/skills

# Install a specific skill by name
ctx7 skills install /anthropics/skills pdf

# Get suggestions based on your project's dependencies
ctx7 skills suggest

What makes it different from the agent searching the docs itself:

• Version-pinned. You tell it "Next.js 15", and it gives you Next.js 15 docs — not a Next.js 13 tutorial that's been ranking on Google for two years.

• Library-aware, not URL-aware. Most fetch tools need a URL. Context7 needs a library name. The agent says "Stripe Python SDK" and gets the SDK docs, not the marketing page.

• Includes code examples. Returns the actual snippets from official docs, which the agent uses as templates rather than reinventing.

• Covers thousands of libraries. Not just the famous ones. Niche packages, internal company docs (if you index them), framework plugins.

Pairs naturally with GitHub: GitHub gives the agent your code. Context7 gives it the docs for the libraries that code depends on. Together, the agent stops making things up.

Who should install this:

Every developer using Antigravity to write code. If the agent imports anything from npm, pip, or cargo, you want this on. Probably top-three priority alongside Composio and GitHub.

Resources: Docs | GitHub

3. Cloudflare — From code to globally deployed

The official Cloudflare skill collection covers Workers, R2 storage, D1 (SQLite at the edge), KV, Durable Objects, Queues, Pages, and the security/networking surface — the full stack of edge infrastructure, with up-to-date patterns the agent uses to make architectural decisions.

The reason this matters: most agents writing infrastructure code default to whatever pattern was popular two years ago. Cloudflare's stack moves fast, and the skill keeps the agent's mental model current so it picks the right primitive for the job.

Install

npx skills add cloudflare/skills

Then,

Build an API that takes a webhook from Stripe, validates the signature, writes the event to D1, and queues a follow-up email via Resend. Deploy it to Workers.

The agent picks Workers (right tool for a webhook endpoint), generates the signature validation code (using the current Stripe SDK pattern, not a deprecated one), provisions a D1 database with the right schema, sets up a Queue for the async work, wires it to Resend (via the Resend skill), and runs wrangler deploy.

The webhook URL comes back in the response. Total time: a few minutes for code that would normally be an afternoon of context-switching between five doc sites.

What makes it different from the agent just reading Cloudflare docs:

• It picks the right primitive. Cloudflare offers many services, and the names aren't obvious (KV vs D1 vs Durable Objects vs R2). The skill encodes the decision tree — the agent doesn't put session state in KV or transactional data in Durable Objects.

• Wrangler-aware. The agent knows how to scaffold a project, write a wrangler.toml, configure bindings, manage secrets, and deploy — not just write Worker code in a vacuum.

• Bindings, not API calls. When a Worker needs to talk to D1 or R2, Cloudflare's binding model means no auth tokens need to be managed. The skill writes code that uses bindings correctly, which is faster, cheaper, and more secure than the alternative.

• Security and networking included. WAF rules, Zero Trust policies, rate limiting, page rules — the agent can configure the protective layer, not just the application layer.

Pairs naturally with several other skills:

• Vercel for projects where Cloudflare is overkill (most static sites and Next.js apps)

• Supabase or Neon when you need a real Postgres and D1's SQLite isn't enough

• GitHub for the deploy-on-push workflow (Cloudflare's git integration is solid)

Who should install this:

Anyone building APIs, webhooks, edge functions, or anything latency-sensitive. Especially valuable if you've been intimidated by Cloudflare's surface area — the skill is essentially a senior platform engineer's mental map of the stack, on tap.

Resources: GitHub

4. Playwright — A real browser that the agent can drive

Most agents reason about the web. Playwright lets them use it. With this skill, your Antigravity agent can open a real browser, click buttons, fill forms, scroll, take screenshots, and handle anything that requires JavaScript execution or human-style interaction.

This is the skill that turns an agent from "thing that calls APIs" into "thing that uses software the way you do."

Install

npm install -g @playwright/cli@latest
playwright-cli --help

Then,

playwright-cli install --skills

This installs skill files locally, so your coding agent can reference them for context about available commands and workflows.

What skills provide

The installed skill includes detailed reference guides for common tasks:

• Running and Debugging Playwright tests — run, debug and manage Playwright test suites

• Request mocking — intercept and mock network requests

• Running Playwright code — execute arbitrary Playwright scripts

• Browser session management — manage multiple browser sessions

• Storage state (cookies, localStorage) — persist and restore browser state

• Test generation — generate Playwright tests from interactions

• Tracing — record and inspect execution traces

• Video recording — capture browser session videos

• Inspecting element attributes — get element attributes not visible in snapshots

What makes it different from API-based tools:

• Works with anything. No API? No problem. If it has a UI, the agent can use it. Legacy admin panels, vendor portals, internal tools, nobody has time to API-ify — all suddenly automatable.

• Selectors that don't break. Use semantic selectors (getByRole('button', { name: 'Save' })) instead of brittle CSS paths. When the UI redesigns, the agent still works.

• Screenshot and video recording. When something fails, you get a visual trace of exactly what the agent saw.

Pairs naturally with Firecrawl: Firecrawl is best for reading pages. Playwright is best for interacting with them. Use Firecrawl for "extract content from this URL." Use Playwright for "do this thing on this site."

Who should install this:

Anyone whose workflow includes a tool that doesn't have an API, or any kind of QA / browser testing. Also: anyone who's ever said, "I wish I could automate this dashboard."

Resources: Docs

5. Vercel — Deploy what the agent builds

The hardest part of agent-built software isn't the building. It's the shipping. Code that lives on the agent's filesystem doesn't help anyone. The Vercel skill closes that loop — your agent can deploy what it just built, get a real URL back, and iterate against a live preview.

Installation

npx skills add vercel-labs/agent-skills

Usage

Skills are automatically available once installed. The agent will use them when relevant tasks are detected.

Examples:

Deploy my app
Review this React component for performance issues
Help me optimize this Next.js page

Skill Structure

Each skill contains:

• SKILL.md - Instructions for the agent

• scripts/ - Helper scripts for automation (optional)

• references/ - Supporting documentation (optional)

The agent generates the code, commits it, triggers a Vercel deployment, waits for the build, and returns the preview URL. From idea to live URL in one prompt.

What makes it different:

• Preview deploys per change. Every iteration gets its own URL. The agent can deploy three variations and let you pick — A/B testing without infrastructure.

• Git-integrated. The agent commits to a branch, Vercel auto-deploys it. The flow matches how humans deploy, so the agent can hand off to a developer reviewing the work cleanly.

• Environment variables and secrets. The agent can configure deployments without you having to hand over plaintext credentials.

• Edge functions and serverless. When the agent builds something that needs a backend (a form handler or an API route), Vercel deploys it too in the same shot.

Who should install this:

Anyone whose agent generates web code. Frontend, full-stack, marketing pages, internal tools. If the output is "a website," Vercel is the shipping lane.

Resources: GitHub

6. Sentry — Errors the agent can actually fix

Most error tracking ends with "an alert fired in Slack." Then a human reads it, opens the stack trace, finds the file, makes a guess, and opens a PR. With the Sentry skill, your agent gets the entire loop: it sees the error, reads the stack trace, looks at the offending code (via GitHub), forms a hypothesis, and either drafts a fix or escalates with real context.

This is the skill that turns Antigravity from "a thing that helps you write code" into "a thing that helps you maintain code."

Installing a particular skill

npx skills add getsentry/sentry-for-ai --skill sentry-fix-issues

To install all the skills

npx skills add getsentry/sentry-for-ai

The agent queries Sentry for the new error cluster, reads the stack traces, identifies that all errors trace to a single function, pulls that file via GitHub, sees that a recent commit changed an assumption about a nullable field, writes the null check, opens a PR, and links it to the Sentry issue. You wake up to a fix waiting for review instead of an alert waiting for action.

What makes it different from "the agent reads error logs":

• Grouped, deduplicated errors. Sentry has already done the hard work of clustering 10,000 occurrences into one issue with one signature. The agent reasons about issues, not log lines.

• Source maps and stack traces. The agent sees real file paths and line numbers, not minified gibberish. Pairs with the GitHub skill so it can read the offending code in context.

• Release tracking. The agent can correlate errors with deploys, which is usually 80% of the diagnosis.

• User context, not just stack traces. Which user hit it, what browser, what they were trying to do, what input they gave. The agent can reproduce the bug, not just see it..

Pairs with GitHub and Context7: Sentry sees the error. GitHub provides the code. Context7 provides the library docs. Together, the agent has everything a human would have when debugging — and often more.

Who should install this: Any team running production software. If you have users hitting bugs and a Sentry account collecting them, this skill closes the loop between "we know about it" and "we fixed it."

Resources: Docs

7. Datadog — Logs, metrics, and APM, the agent can actually query

Most observability skills are read-only: the agent sees an alert, but can't dig in. Datadog Labs ships an official skill collection (built around their Rust-based pup CLI) that gives your Antigravity agent real query access to logs, metrics, monitors, APM traces, and even LLM observability data. The agent can investigate.

This is the skill that turns 3 AM pages into "fix waiting for review when I wake up."

Install

brew tap datadog-labs/pack
brew install datadog-labs/pack/pup
pup auth login

# Then install the skills
npx skills add datadog-labs/agent-skills \
  --skill dd-pup \
  --skill dd-monitors \
  --skill dd-logs \
  --skill dd-apm \
  --skill dd-docs

The collection is modular — install the skills you need:

• dd-pup — the core CLI, required for the others

• dd-logs — search and filter logs with full Datadog query syntax

• dd-monitors — manage and triage monitors

• dd-apm — query APM traces and spans

• dd-docs — LLM-optimised Datadog docs lookup

• dd-llmo-* — four skills for analysing your own LLM app traces (eval bootstrapping, root-cause analysis, session classification, experiment analysis)

Example

Latency spiked on the checkout API at 14:00. Pull the slowest traces, 
find the bottleneck, and tell me which deploy caused it.

The agent queries APM for slow traces in that window, reads the span tree to find the slow call (a downstream Postgres query), checks the deploy tracking to correlate with releases, and reports back: "Deploy checkout-api@4.2.1 at 13:47 introduced a query that's missing an index on orders.user_id." With GitHub installed, it can open the fix as a PR in the same flow.

What makes it different from "the agent reads dashboards":

• Real query access, not screenshots. The agent runs actual Datadog queries (service:checkout @http.status_code:5*), not vibes from a chart.

• Auth handled cleanly. The pup auth login flow uses OAuth, and the agent never sees your API keys. Site/org-aware (works with datadoghq.eu, custom orgs).

• APM trace reasoning. The agent can walk a distributed trace tree and identify which service in a 12-hop request is the slow one — the kind of triage that takes humans 20 minutes of clicking.

• LLM Observability is built in. The dd-llmo Skills are unique: if your product has its own LLM features, the agent can analyse production traces, classify failure modes, and automatically bootstrap evaluators. Meta but useful — agents debugging agents.

• Maintained by Datadog. Not a community wrapper. Updates ship with the platform.

Pairs with GitHub and Sentry: Datadog catches infrastructure and performance issues. Sentry catches application errors. GitHub provides the code. Together, the agent has the full stack-to-source map most engineers wish they had at 3 AM.

Who should install this: Any team running production software on Datadog. The on-call rotation alone is reason enough — the dd-llmo skills are a bonus if you're building LLM features and need eval infrastructure.

• Site: https://www.datadoghq.com/

• Docs: https://docs.datadoghq.com/

• GitHub: https://github.com/datadog-labs/agent-skills

8. Exa — Semantic web search built for agents

Most agents reach for Google when they need to know something. That's a mistake. Google is built for humans skimming blue links. Exa is built for agents reading content.

When you ask your Antigravity agent "what's the latest on OpenAI's pricing?", a regular search wrapper gives it a list of URLs and lets it figure out which one isn't garbage. Exa returns the actual content of the most semantically relevant pages, ranked by how well they match the query's meaning, not by keyword density. It's the difference between handing your agent a phone book and handing it to a research analyst.

Install Exa MCP

claude mcp add --transport http exa "https://mcp.exa.ai/mcp

Exa handles Skills via their MCP server. Then you can use their Skills to perform actions. Read more on here: Exa Agent Skills

Exa handles the semantic ranking and returns clean, parsed content. The agent doesn't need a separate "fetch and clean HTML" step.

What makes it different:

• Neural search, not keyword. It understands "posts about agent memory patterns" the way a human would, not as a TF-IDF match.

• Contents API. Search results come with the actual page content already extracted — no second round-trip to scrape.

• Date filtering that works. "Find articles from the last 30 days" actually returns articles from the last 30 days. Try that on Google.

• Structured output. Title, author, date, content — all typed, all consistent. Your agent can reason over the structure.

Who should install this:

Any agent that needs to know what's happening now — competitive intel, research assistants, news digests, anything where stale knowledge is a bug.

• Exa: https://exa.ai/

• Docs: Docs

9. Firecrawl — Turn any URL into clean markdown

Exa handles search. Firecrawl handles the moments where you already have a URL and just need to read it.

The web is hostile to agents. Pages have nav bars, cookie banners, popups, ads, footer links, and third-party scripts. Firecrawl strips all of that and gives your agent clean, LLM-ready markdown.

Here's how to install Exa Skills

npm install -g firecrawl-cli

Or set up everything in one command (install CLI globally, authenticate, and add skills across all detected coding editors):

npx -y firecrawl-cli@1.16.2 init -y --browser

• -y runs setup non-interactively

• --browser Opens the browser for Firecrawl authentication automatically

• skills are installed globally to every detected AI coding agent by default

Set up Skills and MCP

If you are using an AI coding agent like Claude Code, you can also install the skills manually with:

firecrawl setup skills

This installs skills globally across all detected coding editors by default. Use --agent <agent> it to scope it to one editor.

The agent fetches via Firecrawl, gets back structured markdown with the pricing table intact, and reasons over it. No "ignore the cookie banner" prompt engineering, no HTML parsing, no hallucinated prices because the agent got confused by an ad.

What makes it different:

• JavaScript-rendered pages work. Most fetch tools die on SPAs. Firecrawl runs a real browser, so React/Vue/Next sites render properly before extraction.

• Crawl, not just scrape. Point it at a docs site root, and it'll fetch the whole tree, respecting depth and filters. Useful when an agent needs to ingest documentation, not just one page.

• Schema extraction. Pass it a JSON schema ("I want product name, price, and feature list"), and it'll return structured data rather than just text.

• PDF and image handling. Most pages link to PDFs. Firecrawl reads them.

10. Serverless Postgres for the agent itself

Neon ships an official skill collection that does something different: it gives the agent the judgment of a staff Postgres engineer — which driver to pick for which runtime, when to branch the database, how to handle migrations safely, when to use the serverless driver vs. a connection pool.

The pitch on Neon itself is serverless Postgres with instant database branching. Your agent can fork production into a writable branch the same way you fork a git branch. The skill teaches the agent how to use that primitive correctly.

This is the skill that turns "let the agent touch the database" from a terrifying idea into a normal Tuesday.

Install

# All Neon skills at once
npx skills add neondatabase/agent-skills

# Or just the main one
npx skills add neondatabase/agent-skills --skill neon-postgres

# Easiest path: let neonctl wire everything up
npx neonctl@latest init

The neonctl init flow handles OAuth, creates an API key, configures the MCP server, installs the IDE extension where applicable, and adds the skills at the project level — all in one command.

The collection is modular — install the skills you need:

• neon-postgres — the core skill: connection methods, drivers (serverless, WebSocket, pooled), Neon Auth, the Data API, CLI, and Platform API

• claimable-postgres — provision instant temporary databases via neon.new with no signup or credit card (perfect for ephemeral test environments)

• neon-postgres-egress-optimizer — diagnose and fix excessive Postgres egress when your data transfer bills go sideways

Example

Spin up a new Neon branch from prod, run this migration, test it 
against our query workload, and tell me if anything regressed.

The agent creates a branch (a full copy-on-write Postgres instance in seconds, not hours), applies the migration, runs the test queries, compares performance against the parent branch, and reports back. If it looks bad, the branch gets deleted. If it looks good, you merge it. Zero risk to prod.

What makes it different from "the agent reads the Postgres docs":

• Picks the right driver for the runtime. The skill encodes the decision tree — @neondatabase/serverless HTTP for edge functions, WebSocket for long-running, pg Pool for traditional servers. Most agents pick wrong by default.

• Knows when to branch, not just how. Schema migrations, performance experiments, per-PR preview environments — the skill teaches the agent which problems branching solves and which it doesn't.

• Egress-aware. The dedicated egress optimizer skill catches the #1 cause of surprise Neon bills (overfetching, missing indexes, chatty ORMs) before the bill arrives.

• Maintained by Neon. The official neondatabase/agent-skills repo is the source of truth. The older ai-rules repo has been archived and folded into this one.

Pairs with Supabase and GitHub: Use Supabase for the app's primary backend (auth + realtime + storage); use Neon when you need raw Postgres power, branching, or per-environment compute scaling. With GitHub installed, the agent can spin up a Neon branch for each PR in preview environments.

Who should install this:

Anyone whose agent touches a database — schema changes, migrations, data transformations, background pipelines. Especially valuable if you don't trust the agent enough to point it at prod yet — branching gives you a safe sandbox that's identical to production.

Resources: Site · Docs · Skill repo

Conclusion

Once you start using skills like these, Antigravity stops feeling like just another tool and becomes a system that can actually get things done end to end.

You do not need all of them at once. The real value comes from picking the ones that match your workflow and slowly building around them. Over time, you end up with flows that are cleaner, more reliable, and require less manual effort.

If you are already using Antigravity, even trying a couple of these skills can change how you approach building.

If you're looking for individual toolkits, Composio has a managed repository of 1000+ apps with MCP and CLI options.