playbooks

home / skills / cocacha12 / agent-skills / skill-antigravity

skill-antigravity skill

/skills/skill-antigravity

This skill helps you create and manage modular Antigravity skills with concise, discoverable instructions, checklists, and reliable error handling.

npx playbooks add skill cocacha12/agent-skills --skill skill-antigravity

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
2.5 KB
---
name: skill-antigravity
description: Provides core knowledge and instructions for creating, documenting, and managing Antigravity Skills. Use this skill when you need to extend your capabilities by creating new modular skills.
version: 1.0.0
author: Muze AI
license: MIT
---

# Antigravity Skills Master

This skill empowers Antigravity agents to extend their own capabilities through the creation and management of modular skills.

## Core Principles
1. **Modularity**: Each skill should focus on a single, well-defined task or domain.
2. **Context Efficiency**: Keep instructions concise to minimize token usage while maintaining clarity.
3. **Discoverability**: Use precise, keyword-rich descriptions in the frontmatter to help the agent identify relevance.
4. **Reliability**: Provide checklists and error-handling logic for critical tasks.
5. **Singular Naming**: Always use `.agent` (singular), never `.agents` (plural), for the root configuration directory to ensure automatic tool detection.

## Anatomy of a Skill
A standard Antigravity skill follows this structure:
- `SKILL.md`: (Required) The core instruction set with YAML metadata.
- `metadata.json`: (Recommended) Structured metadata for the `skills` CLI.
- `scripts/`: (Optional) Automation scripts or helper tools.
- `examples/`: (Optional) Reference implementations.
- `resources/`: (Optional) Static assets, templates, or rulesets.

## Guidelines for Creating Skills
1. **Identify the Need**: Create a skill when a task is repetitive, complex, or requires specialized domain knowledge.
2. **Setup Folder**: Create a directory in `.agent/skills/` (local) or your skills repository.
3. **Define Metadata**: Ensure the `name` matches the folder name and the `description` is actionable.
4. **Draft Instructions**:
   - Use clear sections (Goal, Requirements, Steps, Verification).
   - Include GitHub-style alerts for critical warnings or tips.
   - Add Mermaid diagrams for complex workflows.

## Managing the Skills Ecosystem
- **Local Workspace**: Store project-specific skills in `.agent/skills/`.
- **Global Library**: Use `npx skills add` to import skills from shared repositories.
- **Versioning**: Update the `version` in frontmatter/metadata when making significant changes.

## Verification Checklist
- [ ] Does the folder name match the `name` in `SKILL.md`?
- [ ] Is the `description` clear enough for discovery?
- [ ] Are all external dependencies (scripts) referenced correctly?
- [ ] Has the skill been tested in a real-world scenario?

Overview

This skill helps Antigravity agents create, document, and manage modular skills that extend agent capabilities. It codifies principles for modular design, concise context use, discoverable metadata, and reliable verification. Use it to standardize skill development and ensure consistent behavior across local and shared skill libraries.

How this skill works

It provides a compact playbook for building a skill folder inside the .agent configuration, including metadata, instruction structure, optional automation scripts, examples, and static resources. The skill defines naming conventions, discovery-friendly descriptions, error-handling checklists, and versioning guidance so agents can detect, load, and validate new capabilities automatically. It also outlines workspace patterns for local and shared libraries and a verification checklist for release readiness.

When to use it

  • You need to modularize repeated or complex tasks into reusable agent capabilities.
  • You want to publish a skill to a local or shared skills library with consistent metadata.
  • You are onboarding domain experts to author agent extensions with clear, minimal context.
  • You need a checklist and error-handling patterns for mission-critical agent tasks.
  • You want to enforce naming and discovery rules so tools detect skills automatically.

Best practices

  • Design each skill to solve a single, well-defined task or domain to maximize reusability.
  • Keep instructions concise and structured (Goal, Requirements, Steps, Verification) to reduce token usage.
  • Write precise, keyword-rich metadata to improve discoverability by other agents.
  • Include checklists and explicit error-handling or rollback steps for critical workflows.
  • Use singular .agent as the root configuration directory so automatic tool detection works reliably.
  • Bump the version in metadata when you make breaking or significant updates.

Example use cases

  • Create a data-extraction skill that parses invoices and returns structured JSON for downstream agents.
  • Build a deployment skill that runs automated checks and scripts to publish a model or website.
  • Write a compliance-check skill that enforces policy rules and produces a verification report checklist.
  • Assemble a language-specific helper skill with templates, examples, and test cases for rapid reuse.

FAQ

How should I name skill folders?

Match the folder name to the metadata name and store skills under .agent/skills for local use.

What metadata is essential for discovery?

Include a short actionable description, clear name, version, and relevant keywords so agents can rank relevance quickly.