Communitygithub.com

ProdaZhang/aigd

Faça brainstorming de design de jogos com IA; entregue o resultado diretamente para outra IA construir — com verificadores determinísticos de consistência.

O que é aigd?

AIGD é uma metodologia portátil de desenvolvimento de jogos com IA que cobre todo o ciclo: brainstorming → design de sistemas → iteração de playtest → finalização e handoff. O pacote produz um 'handoff package' agnóstico de plataforma que outra IA pode usar diretamente para implementar o jogo, sem se preocupar com a escolha de tech stack (que fica para uma skill dedicada posterior). Suporta ambientes como Claude Code, Cursor e Codex, e organiza o trabalho em uma estrutura de duas camadas: a camada de projeto (spine) com charter e manifesto, e a camada de produção por sistema. Cada operação lê o spine, faz o trabalho e escreve de volta, garantindo consistência e reentrância entre sessões e IAs diferentes. A metodologia inclui roteamento inteligente por sub-skills (conceito, sistema, iteração, handoff, sincronização, captura de UI) e transições de estado não lineares com rollback, mantendo um log de mudanças e verificações de consistência como conflitos de numeração e ciclos no grafo de dependências.

Funciona com✓Claude Code~Codex CLI~Cursor
npx skills add ProdaZhang/aigd

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

AIGD · orchestrator

AIGD = AI Game Design (Design de Jogos com IA). Um pacote portátil de metodologia de desenvolvimento de jogos com IA, cobrindo: brainstorming → design de sistemas → iteração de playtest → finalização e handoff, produzindo um pacote de handoff (agnóstico de plataforma) que "outra IA pode desenvolver diretamente"; a implementação final (escolha de tech stack para escrever o cliente/servidor) não está neste pacote e fica para uma skill de 'landing' dedicada no futuro.

Status: v0 (pré-lançamento) — validado de ponta a ponta (demonstrações reais + o passo a passo executável em examples/ no README do repositório). patterns/ é um kit inicial que continua crescendo (veja references/README.md).

Modelo principal (detalhes em references/)

  • Duas camadas: ① a camada de projeto (spine) — project charter (conceito / plataforma / usuários-alvo / gênero / estilo / convenções de nomenclatura) + manifest (lista de sistemas + grafo de dependências + índice entre camadas + registro de congelamento + registro de faixas numéricas), continuamente revisado; ② o loop de produção por sistema.
  • Fonte centralizada de verdade: enums / numeração / contratos de interface / tabelas de configuração pertencem à camada de projeto; cópias duais (sistema + global): aceitação / necessidades de recursos / protótipo; apenas na camada do sistema: regras / algoritmos de backend.
  • Toda operação: leia o spine → faça o trabalho → escreva de volta no spine. Descobertas de camada inferior (novo sistema / nova dependência / novo enum / conceito alterado) escrevem de volta para a camada superior.
  • Fonte de verdade da metodologia: references/methodology.md, references/README.md.

Roteamento: despache uma sub-skill por "o que você quer fazer desta vez"

O que você quer fazerSub-skill
Conceito / loop principal / plataforma / usuários-alvo / divisão em sistemasaigd-concept
Projetar um sistema (regras + dados de teste de configuração + protótipo HTML)aigd-system
Otimizar um sistema após playtest (regras/config/protótipo, repetível)aigd-iterate
Finalizar um sistema → contrato / aceitação / documentos cliente-servidor / checklist de aceitação voltado ao designeraigd-handoff
Sincronizar de volta a especificação global / protótipo geral / guia mestre de implementação; marcar re-verificação em mudanças de itens compartilhadosaigd-sync
Captura de tela de UI → DSL de UI (construir a base de conhecimento de paradigmas de UI, para recuperação e referência durante o design)aigd-ui-capture

Uso

  1. Leia o spine primeiro (project charter + manifest) para avaliar: em qual etapa o projeto está, em que estado está o sistema desta vez, o que está faltando.
  2. Sem spine → inicie o projeto com aigd-concept primeiro (construa o spine).
  3. Escolha a sub-skill correspondente e invoque-a com a ferramenta Skill para executar; cada sub-skill lê e escreve no mesmo spine, mantendo-o consistente e reentrante (pode ser retomado entre sessões / por outra IA).
  4. Caminho típico: conceito (uma vez) → por sistema {sistema → iterar… (repetido) → handoff finalizar} → sincronizar (contínuo). iterate não vai direto para sync — a admissão em sync exige que o sistema já esteja Final, e apenas handoff pode finalizar; a ordem não é imposta, encaminhe conforme necessário.

Quando não há spine (primeira vez usando em um projeto, project charter / manifest não existem): "leia o spine" retorna vazio → encaminhe diretamente para aigd-concept para iniciar o spine; isso é normal, não um erro.

Autoverificação de abertura (executada em toda entrada em /aigd — proativamente avance, não espere o usuário adivinhar)

  1. O spine existe? Sim → leia project-charter.md + manifest.md; Não → encaminhe para aigd-concept para iniciar o projeto.
  2. Quais sistemas têm status ≠ Final? Liste-os, pergunte ao usuário qual deseja avançar desta vez.
  3. Algum sistema com Recheck? Lembre-se de verificar novamente primeiro (algum item compartilhado mudou) → encaminhe para aigd-sync para resolver (passa na re-verificação → volta para Final / falha → retorna).
  4. Conflitos de faixa numérica / ciclos no grafo de dependências? Verifique e reporte.

Transições de estado (não lineares · com rollback)

concept ──→ design do sistema ⇄ iteração de playtest ──→ finalizar ──→ integração
 ▲             │              │            │(rebater)
 │             │              │            ▼
 │             └─fronteira mal desenhada──┴────→ voltar ao playtest / voltar ao concept
 └────────── integração encontra incompatibilidade / precisa re-divisão ──────────┘
  • Qualquer rebatida / re-divisão registra uma entrada no "log de rollback" do manifest, e conforme as "regras de rebatida" consulta reversamente depended-on-by, marcando sistemas downstream já finalizados como Recheck (veja aigd-handoff / aigd-sync).
  • Modelos: references/templates/ (project charter / manifest / guia mestre de implementação, fortemente tipados).

Estrutura do pacote (instale o pacote inteiro, não o divida)

aigd (este orquestrador, contendo a metodologia references/ e modelos) + 6 sub-skills aigd-concept / system / iterate / handoff / sync / ui-capture, instaladas no mesmo nível do diretório de skills deste ambiente (seguindo o agente host, ex. .claude/skills/ do Claude Code). Os corpos das sub-skills usam ../aigd/references/ para buscar a metodologia → aigd/ deve existir no mesmo nível (aigd-ui-capture passa por ../aigd/references/ui-dsl-spec.md e scripts/, da mesma forma). Fonte única de verdade, não copie individualmente; se depois quiser distribuir independentemente, atualize para um plugin (veja references/README.md "Empacotamento & portabilidade").

Recomendações de ambiente do projeto

  • Arquivos do spine (project charter / manifest) e artefatos de design são recomendados para serem colocados sob Git/SVN; o orquestrador deve verificar o status da versão antes de cada operação.
  • CHANGELOG (registro de alterações) complementa o controle de versão: VCS registra "o que mudou", CHANGELOG registra "por que + qual modelo" (este fluxo é assistido por IA, registrar o modelo ajuda a rastrear de onde veio uma determinada mudança).

Limite

  • Vai até "um pacote de handoff que uma IA pode desenvolver diretamente" (agnóstico de plataforma: regras / contrato / configuração / aceitação / protótipo / necessidades de recursos).
  • Escolha de tech stack e implementação cliente/servidor = downstream, não neste pacote.

Habilidades Relacionadas