Dar a los agentes un "cerebro profesional": cómo escribir un complemento de habilidades de agente personalizado para Antigravity

La semana pasada, un miembro de mi equipo me preguntó por enésima vez: “¿Cuál es el proceso de autenticación para esta API?”

Abrí la polvorienta página de Confluence y descubrí que se actualizó por última vez hace seis meses. La documentación y el código vuelven a estar desincronizados. Suspirando, comencé a escribir las instrucciones que me habían explicado innumerables veces.

Esa noche, cuando estaba jugando con Antigravity, descubrí accidentalmente el sistema de Habilidades. En pocas palabras, le permite implantar un “cerebro profesional” en el Agente de IA, permitiéndole recordar conocimientos específicos, realizar procesos específicos y llamar a herramientas específicas.

Pasé dos horas escribiendo una habilidad para nuestra API interna. Al día siguiente, cuando un nuevo miembro del equipo hizo la misma pregunta, escribí directamente en Antigravity: “Verifique el proceso de autenticación de nuestro servicio de usuario”.

El Agente llamó a mi Habilidad y dio una instrucción precisa con ejemplos de código treinta segundos después. El recién llegado asintió y se puso a trabajar solo.

En ese momento me di cuenta: El sistema de habilidades no es sólo una expansión, está remodelando la forma en que los equipos colaboran.

Este artículo trata sobre cómo escribir habilidades personalizadas para Antigravity. Desde conceptos básicos hasta casos prácticos, incluyendo cómo integrar API externas y cómo conectarse a bases de conocimiento privadas.

¿Qué son las habilidades antigravedad?

Primero aclare el concepto.

El sistema Skill de Antigravity es un formato de extensión abierto y ligero. Puede considerarlo como una “aplicación” instalada para el Agente de IA: cada habilidad define un conjunto específico de habilidades que permiten al Agente desempeñarse de manera más profesional en ciertos escenarios.

Según Google Codelabs, Skills es un paquete de estructura de directorio que permite a los agentes analizar y ejecutar de manera confiable a través de formatos estandarizados. Una habilidad típica incluye:

Railway - Plataforma de despliegue moderna, sin ops complejas, en producción en minutos

Empezar ahora →Anuncio

• skill.yaml: define metadatos de habilidades, descripción de capacidades y escenarios de uso.
• README.md: Descripción detallada de las funciones de Skill y métodos de uso
• scripts/: El script realmente ejecutado (Python, Bash, etc.)
• templates/: plantilla de solicitud o plantilla de salida

Las habilidades se pueden definir en dos ámbitos:

• Alcance global (~/.gemini/antigravity/skills/): disponible en todos los proyectos, como “JSON formateado”, “Revisión de código universal”
• Alcance del proyecto (.agent/skills/): solo disponible en el proyecto actual, como “especificación API de nuestro equipo”, “plantilla de código para negocios específicos”

Este diseño en capas es muy considerado: se centra en la situación general para fines generales y se centra en proyectos relacionados con el negocio.

Escribe tu primera habilidad

Bien, tiempo práctico.

Comencemos con un ejemplo simple: una Skill que formatea automáticamente los mensajes de confirmación de Git.

Paso 1: crear una estructura de directorios

mkdir -p ~/.gemini/antigravity/skills/git-commit-formatter

Paso 2: escribe Skill.yaml

name: git-commit-formatter
description: Format Git commit messages following Conventional Commits spec
version: 1.0.0
author: your-name
triggers:
  - commit
  - git message
  - format commit
actions:
  - name: format_commit
    description: Format a raw commit message to Conventional Commits format
    input:
      raw_message: string
      type: enum[feat, fix, docs, style, refactor, test, chore]
    output:
      formatted_message: string

Este YAML define la información básica de la habilidad, las palabras clave de activación y los formatos de entrada y salida.

Paso 3: escribir el script de ejecución

Cree scripts/format_commit.py en el directorio:

#!/usr/bin/env python3
import sys
import re

def format_commit(raw_message, commit_type):
    # Analizar el mensaje original
    scope_match = re.search(r'\(([^)]+)\)', raw_message)
    scope = f"({scope_match.group(1)})" if scope_match else ""

    # Extraer la descripción
    desc = re.sub(r'\([^)]+\):?\s*', '', raw_message).strip()

    # Formatear
    formatted = f"{commit_type}{scope}: {desc}"
    return formatted

if __name__ == "__main__":
    raw = sys.argv[1]
    ctype = sys.argv[2]
    print(format_commit(raw, ctype))

Paso 4: Prueba

Reinicie Antigravity e intente escribir:

“Utilice git-commit-formatter para formatear esta confirmación: se corrigió el error de inicio de sesión del usuario”

Si todo es normal, el Agente llamará a su Skill y el resultado será similar a: fix(auth): Se corrigió el error de inicio de sesión del usuario

Sencillo ¿verdad? Este es el esqueleto básico de la Habilidad.

Integración de API externa: GitHub + Jira en la práctica

Las habilidades independientes son sólo juguetes. Lo realmente útil son las Skills que se pueden conectar a sistemas externos.

Ven, desarrollemos una habilidad que pueda manejar automáticamente las órdenes de trabajo de Jira.

Escenario: el equipo dedica mucho tiempo a actualizar el estado y registrar las horas de trabajo en Jira todos los días. Dejemos que Agent nos ayude con estas tareas repetitivas.

Paso 1: Prepárese para la certificación API

Necesita el token API y el nombre de dominio de Jira. Se recomienda utilizar variables de entorno para almacenar información confidencial:

export JIRA_API_TOKEN="your-token"
export JIRA_DOMAIN="your-domain.atlassian.net"
export JIRA_EMAIL="[email protected]"

Paso 2: Escribir configuración de habilidades

name: jira-assistant
description: Automate Jira workflows - search issues, update status, add worklogs
triggers:
  - jira
  - ticket
  - issue
  - worklog
actions:
  - name: search_issues
    description: Search Jira issues by JQL query
  - name: add_worklog
    description: Add time spent to an issue
  - name: transition_issue
    description: Move issue to a different status

Paso 3: escribir scripts principales

#!/usr/bin/env python3
import os
import requests
from base64 import b64encode

class JiraClient:
    def __init__(self):
        self.domain = os.getenv('JIRA_DOMAIN')
        self.email = os.getenv('JIRA_EMAIL')
        self.token = os.getenv('JIRA_API_TOKEN')
        self.auth = self._get_auth()

    def _get_auth(self):
        credentials = f"{self.email}:{self.token}"
        return b64encode(credentials.encode()).decode()

    def search(self, jql):
        url = f"https://{self.domain}/rest/api/2/search"
        headers = {
            "Authorization": f"Basic {self.auth}",
            "Content-Type": "application/json"
        }
        response = requests.get(url, headers=headers, params={"jql": jql})
        return response.json()

    def add_worklog(self, issue_key, time_spent, comment):
        url = f"https://{self.domain}/rest/api/2/issue/{issue_key}/worklog"
        headers = {
            "Authorization": f"Basic {self.auth}",
            "Content-Type": "application/json"
        }
        data = {
            "timeSpent": time_spent,
            "comment": comment
        }
        return requests.post(url, headers=headers, json=data)

# Punto de entrada CLI
if __name__ == "__main__":
    import sys
    client = JiraClient()

    if sys.argv[1] == "search":
        result = client.search(sys.argv[2])
        for issue in result.get('issues', []):
            print(f"{issue['key']}: {issue['fields']['summary']}")

    elif sys.argv[1] == "worklog":
        client.add_worklog(sys.argv[2], sys.argv[3], sys.argv[4])
        print(f"Worklog added to {sys.argv[2]}")

Paso 4: Usar

Ahora en Antigravity puedes decir:

“Consulta todos los tickets de In Progress Jira que tengo”

“Registra 2 horas de trabajo para PROJ-123 y escribe en los comentarios ‘Reconstrucción completa del módulo de usuario’”

“Cambiar el estado de PROJ-456 a Listo”

El Agente llamará automáticamente a la API de Jira y ya no necesitará abrir la interfaz lenta de Jira.

Alibaba Cloud - Opción preferida para desarrolladores, 15 % de descuento exclusivo en Lighthouse

Obtener 15% dto. →Anuncio

La integración de GitHub es similar, solo use la biblioteca PyGithub o use solicitudes directamente para ajustar la API de GitHub. Puede crear una habilidad para crear relaciones públicas automáticamente, verificar el estado de CI e incluso realizar revisiones de código.

Conéctese a una base de conocimientos privada: NotebookLM + Antigravity

Esta es la parte que más me entusiasma.

Hay un caso particularmente interesante en XDA Developers: el autor introdujo los documentos del proyecto en NotebookLM, luego le permitió generar especificaciones técnicas y luego convirtió estas especificaciones en Antigravity Skill. El resultado es que el Agente puede escribir código directamente basado en los documentos del proyecto.

Ideas de implementación:

NotebookLM tiene una función de exportación que puede exportar conversaciones a documentos estructurados. Podemos:

1. Cree una base de conocimientos del proyecto (documentos de diseño, especificaciones API, decisiones arquitectónicas) en NotebookLM
2. Utilice la función de preguntas y respuestas de NotebookLM para compilar “resúmenes de conocimientos”
3. Convierta estos resúmenes en contexto o plantillas de habilidades.

O más directamente, use MCP (Protocolo de contexto modelo) para conectar NotebookLM a Antigravity.

Existe un proyecto de código abierto notebooklm-antigravity-skill en GitHub, que implementa esta integración a través de nlm CLI:

name: notebooklm-knowledge
description: Query project knowledge from NotebookLM
triggers:
  - buscar documentación
  - revisar especificaciones
  - conocimiento del proyecto
actions:
  - name: query_knowledge
    description: Query NotebookLM for project-specific knowledge

Al utilizar el script para llamar a la API de NotebookLM, el Agente puede consultar su base de conocimientos privada en tiempo real.

Imagina este escenario:

Recién llegado: “¿Cuáles son los estándares de manejo de errores de nuestro proyecto?”
Tú: (en Antigravity) “Verifica las especificaciones de manejo de errores en NotebookLM”
Agente: “Según la documentación del proyecto, las especificaciones de manejo de errores son las siguientes: 1. Usar clases de excepción personalizadas… 2. Los registros deben contener rastreo… 3. Los errores visibles por el usuario deben internacionalizarse…”

Los documentos ya no tienen polvo y se convierten en el “cerebro profesional” del Agente.

Habilidades avanzadas: combinación de reglas y habilidades.

Además de las Habilidades, Antigravity también tiene un sistema de “Reglas”. La combinación de los dos es más poderosa.

Las reglas son restricciones de comportamiento globales o a nivel de proyecto, como por ejemplo:

# .agent/rules/code-review.md

Al hacer revisión de código:
1. Verificar si hay suficiente cobertura de pruebas unitarias
2. Confirmar que no haya información sensible hardcodeada
3. Validar que el manejo de errores sea adecuado
4. Comprobar que cumple las normas TypeScript del equipo

La regla define “qué hacer y cuándo” y la habilidad define “cómo hacerlo específicamente”.

KiloClaw - OpenClaw gestionado para empresas: orquestación de agentes IA y enrutamiento inteligente

Empezar →Anuncio

Los desarrolladores de Atlassian compartieron un caso práctico en su blog: definieron reglas de “implementación de aplicaciones” para Antigravity y utilizaron Jira Skills para implementar un proceso de implementación automatizado.

Cuando el Agente detecta que el código está fusionado en la rama principal:

1. Activador de regla: “Realizar verificación previa a la implementación”
2. Llamada de habilidad: verifique el estado del ticket asociado en Jira
3. Llamada de habilidad: ejecute el conjunto de pruebas
4. Llamada de habilidad: si se aprueba, actualice el estado de Jira y registre el registro de implementación

Después de esta serie de golpes combinados, el proceso que originalmente requería más de una docena de pasos manuales ahora se puede activar con una sola frase.

Conclusión

Habiendo dicho todo esto, el núcleo es solo una frase: Las habilidades convierten a Antigravity de una “herramienta universal” a un “asistente profesional”.

La IA general puede escribir código, pero no comprende su negocio. Con Skills, puede incorporar conocimientos empresariales, normas de equipo y herramientas internas al Agente, convirtiéndolo en un verdadero miembro del equipo.

Comencé escribiendo el primer formateador de confirmación de Git y ahora el equipo ha acumulado más de veinte habilidades internas. Consulta de documentos API, verificación de especificaciones de código, procesamiento de órdenes de trabajo de Jira e incluso incorporación de nuevos empleados: estas tareas repetitivas se entregan lentamente al Agente.

No significa que nos hayamos vuelto perezosos, sino que podemos centrar nuestra energía en cosas más valiosas. Diseñar arquitectura, resolver problemas, crear nuevos productos: esto es lo que se supone que debe hacer la gente. ¿Consultas de conocimientos y operaciones de procesos repetitivas? Deja que el Agente lo haga.

Si tú también quieres probarlo, se recomienda comenzar con un pequeño punto doloroso. Encuentra la pregunta que se ha hecho innumerables veces en el equipo, o el proceso que debe repetirse diez veces al día, y escribe una Habilidad para resolverlo.

Descubrirá que Agent no es sólo una herramienta, es una extensión del equipo.

Y las Skills son las claves que le confieren capacidades profesionales.