convez.ai
SkillIntegração & APIsIntermediário
ekkx

Google AIP Skills

ekkx/google-aip-skills

Specs Google AIP atualizadas em tempo real para agentes de IA

Ver no GitHub
InicialPluginScore · de 0 a 100

Bundel completo e atualizado diariamente das especificações Google AIP (padrões de design para APIs REST e gRPC) integrada nativamente em agentes de IA como Claude Code, Codex e Cursor. Fornece contexto estruturado offline com convenções, padrões de recursos, tratamento de erros e paginação.

Instalação

$npx convez-ai ekkx/google-aip-skills

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 1 dia
Versão
—
Issues abertas
0
Contribuidores
2

Casos de uso

  • Design de APIs REST seguindo padrões Google AIP
  • Desenvolvimento de APIs gRPC com convenções consolidadas
  • Evitar inconsistências ao usar agentes de código para criar APIs
  • Referência offline de especificações sem latência de rede

Veredito

Solução técnica bem pensada que resolve um problema real: agentes de IA geralmente ignoram convenções de API consolidadas. Mantém a especificação Google AIP sempre atual no contexto local, sem dependência de rede ou conhecimento desatualizado. Essencial para times que padronizam em Google AIP.

README

A tradução para o português deste README ainda está na fila.

google-aip

The problem. Ask an LLM to design a REST or gRPC API and it'll happily invent its own conventions — ignoring AIP-121's resource-oriented patterns, making up error shapes, skipping pagination tokens. The Google AIP spec is public, but it lives on an HTML site that agents can't reliably cite from, and the training cutoff already missed the latest revisions.

The fix. Ship the full, current AIP text into the agent's context — offline, structured, always current.

The same markdown tree is exposed as three entry points so whichever agent you happen to use can consult the actual upstream spec without a network call:

  • Claude Code plugin
  • Codex AGENTS.md
  • Cursor rule

Other agents (Cline, Continue, plain @file mentions, etc.) can read the same markdown directly. CI re-syncs daily from aip-dev/google.aip.dev so the bundle never lags the upstream spec.

Install

The same references/ tree powers every agent. Each agent just gets its own entry point file.

Claude Code

This repository is both a Claude Code marketplace and the plugin it serves:

/plugin marketplace add ekkx/google-aip-skills
/plugin install google-aip@google-aip-skills

Updates land automatically — the marketplace tracks this repository's default branch, which is refreshed daily by CI from the upstream AIP spec.

Codex CLI (and any AGENTS.md-aware agent)

Add this repository to your project as a git submodule (or vendor it however you prefer), then point AGENTS.md at the bundled one:

git submodule add https://github.com/ekkx/google-aip-skills vendor/google-aip-skills
ln -s vendor/google-aip-skills/AGENTS.md AGENTS.md      # or copy it

Codex picks up AGENTS.md hierarchically — if you'd rather scope it to a subdirectory, drop it there instead of the repo root.

Cursor

Same submodule trick, symlinked into Cursor's rules directory:

git submodule add https://github.com/ekkx/google-aip-skills vendor/google-aip-skills
mkdir -p .cursor/rules
ln -s ../../vendor/google-aip-skills/.cursor/rules/google-aip.mdc .cursor/rules/google-aip.mdc

The rule uses alwaysApply: false and a description, so Cursor only attaches it when the conversation actually involves API design.

Keeping the submodule up to date

Git submodules are pinned to a specific commit, so the Codex / Cursor copies do not follow upstream automatically. When you want the latest AIPs:

# Update only this submodule (don't touch your other submodules).
git submodule update --remote vendor/google-aip-skills
git add vendor/google-aip-skills
git commit -m "chore: bump google-aip-skills"

The path argument is important — running git submodule update --remote without it would update every submodule in your repo. If you'd like this fully automated, point Renovate or Dependabot at the submodule.

Other agents (Cline, Continue, etc.)

Anything that can read Markdown from your repository works. Point the agent at vendor/google-aip-skills/skills/google-aip/SKILL.md (or AGENTS.md) and let it follow the links from there.

What you get

Once installed, the google-aip skill auto-loads whenever Claude detects an API-design context (resource names, standard methods, pagination, errors, LRO, versioning, or a specific AIP-NNN reference).

Skill contents:

skills/google-aip/
├── SKILL.md           # trigger description + scope navigation
├── SOURCE.md          # upstream commit SHA + import timestamp
└── references/
    ├── general/INDEX.md
    ├── general/resource-design/0121.md
    ├── general/resource-design/0122.md
    ├── ...
    ├── cloud/INDEX.md
    ├── auth/INDEX.md
    └── ...

Each AIP file is a verbatim copy from aip-dev/google.aip.dev, including its YAML frontmatter (id, state, created, placement, …).

Only AIPs with state: approved are included — drafts are intentionally excluded so Claude does not recommend unsettled guidance.

How freshness is guaranteed

.github/workflows/sync.yml runs daily, rebuilds skills/google-aip/ from the upstream master, and commits the result iff anything changed. The upstream commit SHA used for each build is recorded in skills/google-aip/SOURCE.md, so every snapshot is traceable.

How AIPs are organized

The upstream repository defines scopes (aip/general/, aip/cloud/, aip/auth/, …) and, inside each scope, categories declared in scope.yaml (e.g. resource-design, errors, design-patterns).

The build mirrors that structure verbatim:

  • references/<scope>/<category>/<NNNN>.md — the AIP itself
  • references/<scope>/INDEX.md — generated table of contents for that scope
  • SKILL.md — top-level scope selector

If an AIP has no placement.category (some scopes have none declared), it falls into an auto-created misc bucket so nothing is silently dropped.

Building locally

Requirements: Go 1.24+ and git.

# Clone upstream, regenerate the skill in place.
go run ./cmd/build

# Use an existing local checkout of google.aip.dev instead of cloning:
go run ./cmd/build -source /path/to/google.aip.dev

# Custom output directory:
go run ./cmd/build -out /tmp/google-aip-skill

The build is fully deterministic for a given upstream commit — re-running it without upstream changes produces an identical tree.

Repository layout

google-aip-skills/
├── .claude-plugin/
│   ├── marketplace.json     # this repo is a marketplace
│   └── plugin.json          # ... and also the plugin it ships
├── skills/google-aip/       # the shared payload (SKILL.md + references/)
├── AGENTS.md                # entry point for Codex / generic agents
├── .cursor/rules/
│   └── google-aip.mdc       # entry point for Cursor
├── cmd/build/main.go        # the importer
├── .github/workflows/sync.yml
├── go.mod / go.sum
└── README.md

Licensing

The build tooling in this repository is MIT-licensed (see LICENSE). The AIP texts under skills/google-aip/references/ are copies from aip-dev/google.aip.dev and remain under that project's license.

Ver o original no GitHub

Bom para

Relacionados