Antigravity now supports Skills in its new version, handling project-specific tasks through different skill configurations. This approach is more convenient than setting up Rules and Workflows.

The Skills feature mentioned in the official documentation (antigravity.google/docs/skills) is an extremely powerful capability. It allows us to solidify prompts that would otherwise need to be repeatedly entered into the Agent’s “Procedural Knowledge.”

I used Skills in Antigravity to generate a frontend page by decomposing frontend development into two roles: “Architect” and “Artist,” making the Agent’s output more precise and professional.

What are Antigravity Skills?

Simply put, Skills are the Agent’s SOPs (Standard Operating Procedures). In Antigravity, you don’t need complex configurations—just create a .agent/skills directory in your project, and the Agent will automatically retrieve and learn the capabilities within.

Hands-On: Building a “Architecture + Aesthetics” Dual-Engine Skill

To demonstrate this concept, I created a Skill specifically designed for generating high-quality frontend pages in a blank project. Instead of cramming all instructions into a single file, I adopted a modular design approach.

1. Directory Structure Design

My .agent/skills directory structure is as follows:

1
2
3
4
5
.agent/skills/frontend-composer/
├── SKILL.md              # Entry file (core instructions)
├── layout-architect.md   # Architect perspective: responsible for HTML structure and layout
└── style-artist.md       # Artist perspective: responsible for CSS style and visual specifications

SKILL.md: This is the Agent’s main entry point. It coordinates tasks, telling the Agent when to think through the “Architect” lens and when to switch to the “Artist” perspective.
layout-architect.md: Defines strict requirements for HTML semantics, responsive layouts (Grid/Flex), and component structure.
style-artist.md: Defines the visual language. For example, here I detailed the design specifications for Glassmorphism, including specific parameters for blur, transparency, and gradients.
This Separation of Concerns design effectively prevents the Agent from losing focus when handling complex tasks, ensuring both clean code and beautiful design.

  1. Execution Mechanism: The Agent’s Thought Process
    When I issued the command “create a login page” in the dialog box, to observe the effect, I specifically requested it to “only create a work plan, do not execute directly.”
    Through the Agent’s Thought logs, we can clearly see its thinking process:
    Agent Thought:
    The user wants to create a login page… The user currently has the SKILL.md file open…
    This is a task that requires planning, I should:
    First view the SKILL.md file to understand the skill requirements
    Create task.md and implementation_plan.md (work plan)
    Let the user review the plan
    This step is crucial. The Agent recognized the preset Skill I created and realized it must first go through the “planning” phase rather than acting rashly.

  2. Output Results: Artifacts (Planning)
    Since I emphasized “Planning First” in the Skill, the Agent generated a detailed Implementation Plan that directly referenced my two sub-skill files:

image-20260114165305475

From the screenshot, you can see that the Agent perfectly decomposed the task:
Phase 1: Structural Analysis (The Architect) - Design HTML structure based on layout-architect.md.
Phase 2: Aesthetic Injection (The Artist) - Apply Glassmorphism design style based on style-artist.md.
In the plan, it clearly stated that it would use “purple gradient background + frosted glass cards” along with “Tailwind CSS.” The LLM understood the knowledge in style-artist.md and converted it into actual code.

image-20260114170457575

  1. Summary
    Using Skills in Antigravity is not simply about saving a prompt. Through modular and role-based file organization, we can:
    Reduce context pollution: Let the Agent focus on structure when handling structure, and focus on style when handling style.
    High reusability: Next time when developing a Dashboard or personal homepage, I can still reuse this “Architect + Artist” Skill set, just tweaking the parameters.
    Standardized output: No matter how the project changes, the underlying code structure specifications and visual style can maintain high consistency.
    If you’re also using Antigravity, I strongly recommend trying this Skills orchestration approach—it will elevate your AI pair programming experience to a new level.