Forem: Volodymyr Nehir

How to Build Custom Skills for Antigravity Using Agent Skills Standard

Volodymyr Nehir — Tue, 14 Apr 2026 16:48:53 +0000

While many AI CLI tools rely on manual slash-commands (like /test or /deploy), Antigravity takes a different approach: full autonomy.

In Antigravity, you don't trigger skills manually. Instead, the agent uses progressive disclosure—it reads the metadata of your available skills and autonomously activates the right one at the right time based on your prompt.

To achieve this, Antigravity strictly follows the open Agent Skills standard. Here is how you can build a custom, highly focused skill for your autonomous agent.

1. Choose Where to Save Your Skill

You can create skills that apply to a specific project workspace or globally across your machine.

Workspace-specific (Project Level): Save your skill folder at <workspace-root>/.agents/skills/<skill-folder>/. This is perfect for project-specific workflows like custom testing conventions or deployment pipelines.
Global (User Level): Save your skill at ~/.gemini/antigravity/skills/<skill-folder>/. Use this for general-purpose utilities you want the agent to remember everywhere.

(Note: Antigravity defaults to .agents/skills, but maintains backward compatibility with older .agent/skills directories).

2. Create the Directory Structure

Create a new folder for your skill. While only the SKILL.md file is strictly mandatory, a robust skill folder usually looks like this:

my-autonomous-skill/
├── SKILL.md       # Required: The brain (metadata and instructions)
├── scripts/       # Optional: Executable helper scripts (Bash, Python, Node)
├── examples/      # Optional: Reference implementations for the AI
└── resources/     # Optional: Templates and static assets

3. Write the SKILL.md File

Every skill must begin with a YAML frontmatter block, followed by the main Markdown instructions.

---
name: generate-python-tests
description: Generates unit tests for Python code using pytest conventions.
---

# Instructions
When this skill is activated, follow these specific testing conventions...

🔥 Crucial Step: The description field is the most important part of this file. Because Antigravity operates autonomously, it uses this exact description to decide when to activate the skill. Write it in the third person and use clear keywords.

Below the frontmatter, write the step-by-step guidance, strict rules, checklists, and patterns the agent must follow.

4. Antigravity Best Practices for AI Engineers

To ensure your skill works perfectly without manual intervention, adhere to these architectural guidelines:

Keep skills hyper-focused: A skill should do one thing exceptionally well. Do not create a "do-everything" skill. Break disparate tasks down into multiple smaller skills.
Treat scripts as black boxes: If your skill bundles executable scripts, do not force the AI to read the raw source code. Instruct the agent to run the script with a --help flag first. This saves context tokens and keeps the AI focused on execution.
Provide decision trees: For complex skills, include a decision tree in your Markdown body (e.g., "If error X occurs, do Y. If state Z is true, do W"). This gives the autonomous agent a clear path to resolve blockers without asking you for help.

How to Trigger It? You Don't.

You do not need to manually trigger the skill. When a conversation starts, Antigravity automatically discovers available skills and activates the full instructions whenever it deems the skill relevant to your prompt.

(If you ever need to force its activation, simply mention the skill's name in your natural language prompt).

How to Build Custom Commands for Claude Code Using Agent Skills Standard

Volodymyr Nehir — Mon, 13 Apr 2026 16:55:07 +0000

If you are using Claude Code, you might have noticed a major shift: custom commands have officially been merged into the open Agent Skills standard.

While legacy commands placed in .claude/commands/ will still work, the recommended approach is to build your custom tools as Skills. Why? Because this standard allows you to bundle supporting files, executable scripts, and use advanced configurations like pre-processing shell commands before the LLM even sees them.

Here is a definitive, step-by-step guide to building powerful custom commands (slash-commands like /deploy) using the new standard.

1. Choose a Location and Create the Directory

First, decide whether your command should be global (across all projects) or project-specific:

Personal (Global): ~/.claude/skills/<skill-name>/
Project-specific: .claude/skills/<skill-name>/

Let's create a deploy command. Open your terminal and run:

mkdir -p .claude/skills/deploy/

2. Create the SKILL.md File (The Brain)

Every command requires a SKILL.md file. The top of this file must include a YAML frontmatter block to define metadata.

Here is what you need to know about the fields:

name: This dictates your console command. Setting name: deploy creates the /deploy command.
description: Crucial for the AI to understand the tool's purpose.
disable-model-invocation: true: Do not skip this. This prevents Claude from running the workflow on its own initiative, ensuring it only executes when you explicitly type the /slash-command.
argument-hint: Shows up in the UI autocomplete (e.g., [branch-name]).

3. Write the Task Content & Handle Arguments

Below the frontmatter, write the Markdown instructions. For custom commands, these are usually step-by-step instructions.

You can dynamically handle user input using variables:

$ARGUMENTS: Injects everything typed after the slash command. (e.g., If you run /deploy staging, $ARGUMENTS becomes staging).
Index-based variables: Use $0, $1, etc., to grab specific words from the input.

4. 🤯 The Killer Feature: Dynamic Context (The `!` syntax)

This is where the Agent Skills standard shines. If your command needs real-time data before Claude starts processing, you can use the ! command syntax.

When you include a shell command preceded by an exclamation mark (e.g., ! git log -1), Claude Code executes the command immediately in the background and substitutes the placeholder with the actual terminal output before sending the prompt to the model. This saves tokens, reduces latency, and prevents hallucinations.

5. Add Supporting Scripts (Optional)

Unlike legacy commands, Skills allow you to bundle multiple files. You can keep your SKILL.md clean and place complex logic in subdirectories like scripts/, references/, or assets/.

💡 Pro Tip for Scripts: Use the ${CLAUDE_SKILL_DIR} variable in your instructions. This ensures the path to your script is resolved correctly, regardless of which directory the user was in when they invoked the command.

Example: A Complete Deployment Command

Here is what a production-ready .claude/skills/deploy/SKILL.md file looks like:

---
name: deploy
description: Builds the project and deploys it to the specified environment.
disable-model-invocation: true
argument-hint: [environment-name]
allowed-tools: [Bash]
---

You are executing my custom deploy command.
Target environment: $ARGUMENTS

Step 1: Run the bundled build script.
Execute the following: `bash ${CLAUDE_SKILL_DIR}/scripts/build.sh $0`

Step 2: Read the latest commit to verify what we are deploying: 
`! git log -1 --oneline`

Step 3: Confirm the build was successful, analyze the git log, and summarize the deployment process for the user.

Once this file is saved, Claude Code automatically discovers it. You can immediately jump into your terminal and run /deploy production.

Are you migrating your legacy CLI scripts to Agent Skills yet? Let me know what custom commands you are building in the comments!

How to Build Custom Commands for Codex Using Agent Skills Standard

Volodymyr Nehir — Sun, 12 Apr 2026 22:43:53 +0000

If you are using Codex (whether the CLI, IDE extension, or the standalone app), building custom commands relies on the open Agent Skills framework. This framework allows you to package instructions, resources, and optional scripts to extend Codex with highly specific capabilities.

In the Codex ecosystem, custom commands and skills are essentially the same thing. Here is the step-by-step process for building one.

1. Create the Directory Structure

A skill is defined by a dedicated folder. You have two options to create it:

The Easy Way: Use Codex's built-in creator by running $skill-creator in your prompt. It will interactively ask you what the skill does, when it should trigger, and generate the folder for you.
The Manual Way: If you prefer setting it up yourself, your directory can contain the following structure:

my-skill/
├── SKILL.md             # Required: Contains metadata and AI instructions
├── scripts/             # Optional: Executable code (e.g., Node.js, bash)
├── references/          # Optional: Documentation context for the AI
├── assets/              # Optional: Templates and static resources
└── agents/openai.yaml   # Optional: Appearance and dependency configs

2. Write the SKILL.md File

The SKILL.md file is the brain of your command. It requires metadata at the top (Name and Description) followed by instructions.

💡 Pro Tip: Understand "Progressive Disclosure"
Codex uses a technique called progressive disclosure. It reads only the descriptions of all available skills first to decide if a skill matches your current prompt. Write descriptions with clear boundaries and strict scopes so Codex knows exactly when to trigger it without wasting token context!

Here is how you structure it:

---
name: my-skill
description: "Strict scope description of what this command does."
---

# Instructions
When this command is invoked, follow these exact steps...

3. Choose Where to Save the Command

Codex automatically detects skill changes based on where you save the folder. Choose the scope that fits your workflow:

Project/Repo Level: Save in $CWD/.agents/skills, $CWD/../.agents/skills, or $REPO_ROOT/.agents/skills. Perfect for repository-specific scripts (like a microservice deployer).
User Level (Global): Save in $HOME/.agents/skills. This makes the command available to you personally across any project you open.
Admin/System Level: Save in /etc/codex/skills. This makes the command available as a default tool to every user on that specific machine.

4. Configure Invocation Behavior (Optional)

By default, Codex can trigger your skill either explicitly (when you call its name) or implicitly (when your natural language prompt matches the description).

If you want this to act strictly as a manual command (preventing the AI from running it autonomously), create an agents/openai.yaml file inside your skill directory:

# agents/openai.yaml
allow_implicit_invocation: false

5. Use Your Command

Once your files are saved, Codex detects them automatically (restart Codex if it doesn't). You can now trigger your workflow:

Explicitly (Manual): Run /skills to see your list, or type $ followed by your skill name (e.g., $my-skill) directly in your prompt.
Implicitly (Autonomous): If allow_implicit_invocation is true, simply type a prompt that matches your SKILL.md description, and Codex will seamlessly load the instructions and execute the task!

How to Build Custom Commands for Gemini CLI and Antigravity

Volodymyr Nehir — Sun, 12 Apr 2026 15:45:20 +0000

In the rapidly evolving world of AI CLI tools like Gemini CLI and Antigravity, the way we interact with autonomous agents is changing. Instead of writing complex, platform-specific plugins, custom commands are now officially merged with and built as Agent Skills.

This means that to create a custom command (which you can trigger via a slash command like /my-command), you simply need to create a skill using the open Agent Skills standard. Because tools like Gemini CLI and Antigravity share this open standard, you can build your command once in a global directory, and all compatible agents will be able to discover and use it.

Here is a step-by-step guide on how to build a custom command using this modern approach.

Create the Directory Structure Commands are defined by a directory containing a SKILL.md file. You can create this folder either locally for a specific project or globally for cross-agent compatibility.

For a project-specific command:

mkdir -p .gemini/skills/my-command/

For a global command (available to all compatible agents on your machine):

mkdir -p ~/.agents/skills/my-command/

For a antigravity:

mkdir -p ~/.gemini/antigravity/skills/my-command/

Create the SKILL.md Definition File Inside your new directory, create a SKILL.md file. To define how the command is invoked, you must start the file with a YAML frontmatter block.

The name field in this block is what dictates your slash command. For example, setting name: my-command creates the /my-command console command.

Here is the exact boilerplate you need:

---
name: my-command
description: "A brief description of what this command does."
argument-hint: [optional-arguments]
disable-model-invocation: true
---

# Instructions
You are helping to execute my custom command.
User input: $ARGUMENTS

Step 1. Do the following tasks...

Pro Tip: Setting disable-model-invocation: trueis highly recommended for custom commands. This prevents the AI agent from triggering the workflow on its own and ensures the script only runs when you explicitly type the command. You can also use the $ARGUMENTS variable to automatically pass anything you type after the slash command directly into the agent's prompt.

Add Execution Logic (Optional) If your command requires the agent to execute specific code (like an audit script, a database migration, or a deployment script), you can bundle those scripts inside a scripts/ subfolder within your command's directory.

For instance, you could create .gemini/skills/my-command/scripts/action.js. You can then instruct the agent in your SKILL.md file to execute that specific file using built-in agent tools like run_shell_command.

Verify and Use Your Command AI CLI tools like Gemini CLI automatically scan your directories to discover new skills and commands on the fly.

To verify that your new command was registered successfully, simply type the following in your terminal:

/skills list

To run your custom command, just type /my-command (or whatever name you defined in the YAML block) directly in the chat session.

Have you started building custom Agent Skills for your CLI workflows yet? Let me know what commands you are creating in the comments below!