Communitygithub.com

ProdaZhang/aigd

Concevez des jeux avec l'IA et transmettez le résultat à une autre IA pour construction directe — avec des vérificateurs de cohérence déterministes.

Qu'est-ce que aigd ?

AIGD (AI Game Design) est une méthodologie portable de développement de jeux assisté par IA, couvrant le brainstorming, la conception de systèmes, l'itération de playtest et la finalisation pour remise. Elle produit un package de remise indépendant de la plateforme, qu'une autre IA peut utiliser directement pour implémenter le jeu. Le package se compose d'un orchestrateur central (aigd) et de six sous-compétences spécialisées (concept, système, itération, remise, synchronisation, capture UI). Chaque opération lit et écrit dans une 'colonne vertébrale' centralisée (charte de projet + manifeste) pour garantir la cohérence et la réentrance entre sessions ou IA. L'objectif est de livrer un package de conception complet (règles, contrats, prototypes, tests) sans s'occuper du choix technique ou de l'implémentation finale, qui est laissée à une compétence aval. Le flux inclut un système de transitions d'état non linéaire avec rebonds, rollback et rechecks pour gérer les changements de périmètre ou les incompatibilités découvertes tardivement.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add ProdaZhang/aigd

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

AIGD · orchestrateur

AIGD = AI Game Design (Conception de Jeux par IA). Un package méthodologique portable de développement de jeux assisté par IA, couvrant : brainstorming → conception système → itération playtest → finalisation & remise, produisant un package de remise (indépendant de la plateforme) qu'"une autre IA peut utiliser directement pour développer". La concrétisation de l'implémentation (choix d'une stack technique pour écrire le client/serveur) ne fait pas partie de ce package et est laissée à une future compétence de landing dédiée.

Statut : v0 (pré-release) — validé de bout en bout (démonstrations réelles + le walkthrough examples/ exécutable dans le README du dépôt). patterns/ est un pack de démarrage qui continue de s'enrichir (voir references/README.md).

Modèle central (les détails renvoient à references/)

  • Deux couches : ① la couche projet (colonne vertébrale) — project charter (concept / plateforme / utilisateurs cibles / genre / style / conventions de nommage) + manifest (liste des systèmes + graphe de dépendances + index transversal + registre de gel + registre de plages numériques), continuellement révisés ; ② la boucle de production par système.
  • Source de vérité centralisée : les énumérations / numérotations / contrats d'interface / tables de configuration appartiennent à la couche projet ; doubles copies (système + global) : acceptation / besoins en ressources / prototype ; couche système uniquement : règles / algorithmes backend.
  • Chaque opération : lire la colonne vertébrale → effectuer le travail → réécrire dans la colonne vertébrale. Les découvertes de couche inférieure (nouveau système / nouvelle dépendance / nouvelle énumération / concept modifié) remontent vers la couche supérieure.
  • Source de vérité de la méthodologie : references/methodology.md, references/README.md.

Routage : déclencher une sous-compétence selon "ce que vous voulez faire cette fois"

Ce que vous voulez faireSous-compétence
Concept / boucle centrale / plateforme / utilisateurs cibles / découpage en systèmesaigd-concept
Concevoir un système (règles + données de test de configuration + prototype HTML)aigd-system
Optimiser un système après playtest (règles/config/prototype, répétable)aigd-iterate
Finaliser un système → contrat / acceptation / documentation client-serveur / checklist d'acceptation orientée concepteuraigd-handoff
Resynchroniser la spécification globale / le prototype global / le guide maître d'implémentation ; marquer un recheck en cas de modification d'élément partagéaigd-sync
Capture d'écran UI → DSL UI (construire la base de connaissances des paradigmes UI, pour la récupération et la référence lors de la conception)aigd-ui-capture

Utilisation

  1. Lire d'abord la colonne vertébrale (charte de projet + manifeste) pour juger : à quelle étape le projet est-il arrivé, quel est l'état du système en cours, ce qui manque.
  2. Pas de colonne vertébrale → démarrer le projet avec aigd-concept d'abord (construire la colonne vertébrale).
  3. Choisir la sous-compétence correspondante et l'invoquer avec l'outil Skill pour l'exécuter ; chaque sous-compétence lit et écrit la même colonne vertébrale, la maintenant cohérente et réentrante (peut être reprise entre sessions ou par une autre IA).
  4. Parcours typique : concept (une fois) → par système {système → itérer… (répété) → remise finalisation} → synchronisation (continue). iterate ne va pas directement dans sync — l'admission dans sync nécessite que le système soit déjà Final, et seule handoff peut finaliser ; l'ordre n'est pas imposé, acheminez selon les besoins.

Quand il n'y a pas de colonne vertébrale (première utilisation sur un projet, project charter / manifest n'existent pas encore) : "lire la colonne vertébrale" échoue → router directement vers aigd-concept pour démarrer la colonne vertébrale ; c'est normal, pas une erreur.

Auto-vérification d'ouverture (exécutée à chaque entrée dans /aigd — avancer proactivement, ne pas attendre que l'utilisateur devine)

  1. La colonne vertébrale existe-t-elle ? Oui → lire project-charter.md + manifest.md ; Non → router vers aigd-concept pour démarrer le projet.
  2. Quels systèmes ont un statut ≠ Final ? Les lister, demander à l'utilisateur lequel pousser cette fois.
  3. Des systèmes Recheck ? Rappeler de rechecker d'abord (un élément partagé a changé) → router vers aigd-sync pour régler (passage du recheck → retour à Final / échec → rebondir).
  4. Conflits de plages numériques / cycles dans le graphe de dépendances ? Vérifier et signaler.

Transitions d'état (non linéaires · avec rollback)

concept ──→ conception système ⇄ itération playtest ──→ finalisation ──→ intégration
 ▲             │              │            │(rebond)
 │             │              │            ▼
 │             └─périmètre mal tracé──┴────→ retour à playtest / retour à concept
 └────────── l'intégration trouve une incompatibilité / nécessite un re-découpage ──────────┘
  • Tout rebond / re-découpage enregistre une entrée dans le "journal de rollback" du manifeste, et selon les "règles de rebond" recherche en arrière depended-on-by, marquant les systèmes aval déjà finalisés comme Recheck (voir aigd-handoff / aigd-sync).
  • Modèles : references/templates/ (charte de projet / manifeste / guide maître d'implémentation, fortement typés).

Structure du package (installer le package entier, ne pas le diviser)

aigd (cet orchestrateur, contenant la méthodologie references/ et les modèles) + 6 sous-compétences aigd-concept / system / iterate / handoff / sync / ui-capture, installées au même niveau dans le répertoire skills de cet environnement (selon l'agent hôte, par exemple .claude/skills/ de Claude Code). Les corps des sous-compétences utilisent ../aigd/references/ pour récupérer la méthodologie → aigd/ doit exister au même niveau (aigd-ui-capture passe par ../aigd/references/ui-dsl-spec.md et scripts/, de même). Source unique de vérité, ne copiez pas individuellement ; si vous souhaitez plus tard le distribuer indépendamment, mettez-le à niveau en tant que plugin (voir references/README.md "Packaging & portability").

Recommandations pour l'environnement du projet

  • Les fichiers de la colonne vertébrale (project charter / manifest) et les artefacts de conception sont recommandés pour être placés sous gestion Git/SVN ; l'orchestrateur devrait jeter un coup d'œil sur l'état de version avant chaque opération.
  • CHANGELOG (journal des modifications) complète le contrôle de version : VCS enregistre "ce qui a changé", CHANGELOG enregistre "pourquoi + quel modèle" (cette méthodologie est un flux assisté par IA, enregistrer le modèle aide à tracer l'origine d'un changement).

Périmètre

  • Va jusqu'à "un package de remise qu'une IA peut utiliser directement pour développer" (indépendant de la plateforme : règles / contrat / configuration / acceptation / prototype / besoins en ressources).
  • Choix de la stack technique et implémentation client/serveur = aval, pas dans ce package.

Skills associés