Google ADK × Antigravity: Build Custom Agent Skills to Extend Your AI

Antigravity's Agent Skills system lets you extend what AI agents can do — far beyond the built-in capabilities. With Google's Agent Development Kit (ADK), you can package your own workflows, domain knowledge, and tool integrations into reusable skills that any agent can invoke. This guide walks you through everything: from ADK fundamentals to building and deploying a production-ready GitHub Issues triage skill.

What Is Google's Agent Development Kit (ADK)?

ADK is the framework Google introduced in late 2025 to standardize how agent skills are structured and distributed. Think of it as a convention for bundling everything an AI agent needs to accomplish a specialized task: instructions, scripts, and static resources — all in a single, portable folder.

The key insight behind ADK skills is that the agent reads and follows instructions rather than executing hardcoded logic. This makes skills flexible, auditable, and easy to iterate on without redeploying code.

ADK skills have four defining characteristics:

SKILL.md-driven instructions — the agent reads this file when the skill is invoked and follows the steps inside
Script automation — shell or Python scripts in the scripts/ directory handle computationally intensive tasks, so the agent doesn't need to reason about low-level operations
Bundled resources — templates, configs, and reference data live in resources/ alongside the skill
Portability — skills are plain directories that can be version-controlled, shared via Git, and installed with a single command

ℹ️

**Prerequisites**: Antigravity 1.18 or later is required. Check your version with `antigravity --version`.

Skill Directory Structure

Every ADK skill follows this directory layout:

my-skill/
├── SKILL.md          # Agent instructions (required)
├── scripts/
│   ├── setup.sh      # One-time setup script (optional)
│   └── run.py        # Main processing script (optional)
└── resources/
    ├── template.json # Template files (optional)
    └── config.yaml   # Configuration (optional)

A skill can be as minimal as a single SKILL.md, but more sophisticated workflows benefit from the full structure.

Writing an Effective SKILL.md

SKILL.md is the instruction manual your agent reads every time the skill is triggered. It uses YAML frontmatter for metadata and Markdown for step-by-step instructions.

---
name: github-issues-triage
description: Automatically triage GitHub Issues and apply priority labels
---
 
## Scope of this article
Fetch open Issues from a specified GitHub repository, analyze their
content, and apply P0/P1/P2 priority labels automatically.
 
## Steps
 
### Step 1: Fetch Issues
Run: `gh issue list --repo {REPO} --state open --json number,title,body,labels`
to retrieve all open Issues in JSON format.
 
### Step 2: Classify Priority
For each Issue, apply the following rules:
- P0 (Critical): production outages, security vulnerabilities, data loss
- P1 (High): major feature bugs, performance regressions
- P2 (Medium/Low): minor bugs, feature requests, documentation
 
### Step 3: Apply Labels
Run: `gh issue edit {NUMBER} --add-label "{PRIORITY}"`
for each Issue based on its classification.
 
### Step 4: Output Summary
Print a table of processed Issues with their assigned priorities.

💡

**Best practice**: Number your steps clearly (`Step 1`, `Step 2`, etc.) and include concrete commands with placeholder variables like `{REPO}`. Avoid vague language — the more precise your instructions, the more reliably the agent performs the task.

Tutorial: Building a GitHub Issues Triage Skill

Let's build a real, working skill from scratch.

1. Create the Skill Directory

mkdir -p ~/.antigravity/skills/github-issues-triage/scripts
mkdir -p ~/.antigravity/skills/github-issues-triage/resources

2. Implement the Processing Script

# scripts/triage.py
# Fetches GitHub Issues and calculates a priority score for each one.
# Output: JSON array with number, title, and priority fields.
 
import json
import subprocess
import sys
 
def get_issues(repo: str) -> list[dict]:
    """Fetch open Issues via the gh CLI."""
    result = subprocess.run(
        ["gh", "issue", "list", "--repo", repo,
         "--state", "open", "--limit", "50",
         "--json", "number,title,body,labels,createdAt"],
        capture_output=True, text=True
    )
    if result.returncode != 0:
        print(f"Error: {result.stderr}", file=sys.stderr)
        sys.exit(1)
    return json.loads(result.stdout)
 
def classify_priority(issue: dict) -> str:
    """Keyword-based priority classification."""
    text = (issue.get("title", "") + " " + issue.get("body", "")).lower()
 
    # P0: production / security incidents
    p0_keywords = ["production", "outage", "security", "vulnerability",
                   "data loss", "crash", "critical", "urgent"]
    if any(kw in text for kw in p0_keywords):
        return "P0"
 
    # P1: functional bugs and regressions
    p1_keywords = ["bug", "broken", "regression", "performance",
                   "not working", "error", "fail"]
    if any(kw in text for kw in p1_keywords):
        return "P1"
 
    # Default to P2 (feature requests, improvements)
    return "P2"
 
def main():
    repo = sys.argv[1] if len(sys.argv) > 1 else "owner/repo"
    issues = get_issues(repo)
 
    results = []
    for issue in issues:
        priority = classify_priority(issue)
        results.append({
            "number": issue["number"],
            "title": issue["title"],
            "priority": priority
        })
 
    # Output JSON for the agent to consume
    print(json.dumps(results, ensure_ascii=False, indent=2))
 
if __name__ == "__main__":
    main()

Expected output:

[
  { "number": 42, "title": "Production server is crashing", "priority": "P0" },
  { "number": 38, "title": "Login redirect bug after OAuth flow", "priority": "P1" },
  { "number": 35, "title": "Add dark mode support", "priority": "P2" }
]

3. Write the Complete SKILL.md

---
name: github-issues-triage
description: Automatically triage GitHub Issues and apply P0/P1/P2 priority labels
---
 
## Scope of this article
Analyze open Issues in a GitHub repository and automatically assign
P0 (Critical), P1 (High), or P2 (Medium/Low) priority labels.
 
## Pre-flight Checks
- Confirm GitHub authentication: `gh auth status`
- Ask the user for the target repository name (owner/repo format)
 
## Step 1: Run the Triage Script
```bash
python3 scripts/triage.py {REPO} > /tmp/triage_result.json

Step 2: Review Results

Read /tmp/triage_result.json and group Issues by priority.

Step 3: Apply Labels

For all P0 and P1 Issues, run:

gh issue edit {NUMBER} --repo {REPO} --add-label "{PRIORITY}" --add-label "needs-attention"

Step 4: Print Summary

Output a summary in this format:

🚨 P0 Issues: {COUNT} | 🔴 P1: {COUNT} | 🟡 P2: {COUNT}


### 4. Register and Invoke the Skill

```bash
# Register the skill with Antigravity
antigravity skill add ~/.antigravity/skills/github-issues-triage

# Verify registration
antigravity skill list

# Invoke the skill from the Antigravity chat interface:
# "Use the github-issues-triage skill to triage masakihirokawa/myapp"

⚠️

**Security note**: Never embed API keys, tokens, or secrets inside `SKILL.md` or your scripts. Use environment variables or Antigravity's built-in Secrets management for sensitive credentials.

Sharing and Distributing Skills

ADK skills are plain directories — making them trivial to share via Git.

# Publish your skill to GitHub
cd ~/.antigravity/skills/github-issues-triage
git init && git add . && git commit -m "Initial release"
git remote add origin https://github.com/yourname/antigravity-skill-github-triage.git
git push -u origin main
 
# Anyone can install your skill with one command
antigravity skill install https://github.com/yourname/antigravity-skill-github-triage.git
 
# Install a specific version using a Git tag
antigravity skill install https://github.com/yourname/antigravity-skill-github-triage.git@v1.2.0

For broader distribution, you can submit your skill to the Antigravity Plugin Registry — making it discoverable by the entire community.

Skill Ideas to Inspire You

The following skill concepts represent common automation patterns that map well to ADK's structure:

Skill Name	What It Does	Domain
`daily-standup`	Generate a standup summary from yesterday's commits	Productivity
`security-audit`	Scan dependencies for known CVEs and report findings	Security
`api-docs-sync`	Regenerate API documentation when source code changes	Documentation
`deploy-rollback`	Detect anomalies and trigger an automatic rollback	DevOps
`i18n-generator`	Extract translatable strings from components into locale files	Localization

Wrapping Up

Google ADK makes it possible to transform any repeatable workflow into a reusable, shareable agent skill. The combination of a clear SKILL.md instruction file and purpose-built scripts gives your agent everything it needs to execute complex tasks autonomously — without guessing.

Start with the GitHub Issues triage skill from this tutorial, then adapt it to your own workflows: code reviews, deployment checklists, release notes generation, or anything else your team does repeatedly.

Related Articles

Google ADK × Antigravity: Build Custom Agent Skills to Extend Your AI

What Is Google's Agent Development Kit (ADK)?

Skill Directory Structure

Writing an Effective SKILL.md

Tutorial: Building a GitHub Issues Triage Skill

1. Create the Skill Directory

2. Implement the Processing Script

3. Write the Complete SKILL.md

Step 2: Review Results

Step 3: Apply Labels

Step 4: Print Summary

Sharing and Distributing Skills

Skill Ideas to Inspire You

Wrapping Up

Thank You for Reading

Related Articles