Communitygithub.com

majiayu000/registre-des-compétences-code-flow-visu

Pour organiser et visualiser le flux de code, générer des diagrammes ASCII clairs, des diagrammes de flux de données et des analyses tabulaires. Idéal pour comprendre le code existant, concevoir de nouvelles fonctionnalités et rédiger une documentation technique.

Qu'est-ce que registre-des-compétences-code-flow-visu ?

Cette compétence fournit un ensemble de modèles et de méthodes réutilisables pour analyser le flux de code, concevoir des fonctionnalités et générer une documentation technique visuelle. Elle est particulièrement utile pour les développeurs qui travaillent sur des applications CLI, des architectures en couches (CLI → Flow → Data → DB/API) et qui ont besoin d'expliquer ou de planifier le comportement d'un système. La compétence prend en charge plusieurs plates-formes (Claude Code, Cursor, Codex, etc.) via un langage naturel et des diagrammes ASCII. Elle propose cinq modèles principaux : un diagramme de flux complet pour les comparaisons multi-scénarios, un schéma de structure de base de données, un diagramme d'appel en couches simplifié, un tableau d'analyse de classes de données pour évaluer leur nécessité, et un tableau d'annotation des points métier clés. L'accent est mis sur la visualisation, l'explication des décisions de conception et l'évitement des anti-modèles comme les descriptions purement textuelles de flux ou les tableaux sans contexte métier. L'utilisateur peut suivre un processus en quatre étapes : définir l'objectif, choisir le modèle, remplir le contenu avec des symboles ASCII standardisés, et ajouter une analyse comparative. Un exemple complet montre comment analyser un module de gestion des limites (limit management). La compétence collabore avec d'autres compétences comme ***code-style*** et ***architecture*** pour garantir la cohérence et la conformité avec la conception architecturale.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/majiayu000/claude-skill-registry-data/tree/HEAD/analysis/code-flow-viz-mmorit00-fund-portfolio-bot-2

Demander à votre IA préférée

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

Documentation

Spécifications de visualisation du flux de code

Cette compétence fournit un ensemble de modèles et de méthodes réutilisables pour analyser le flux de code et générer une documentation visuelle.

Principe fondamental : Expliquer clairement avec du texte et des diagrammes ASCII "d'où viennent les données, par quelles couches elles passent et où elles aboutissent".

Quand l'utiliser

Utilisez cette compétence dans les contextes suivants :

  • L'utilisateur demande "comment fonctionne une fonctionnalité"
  • Une nouvelle fonctionnalité nécessite une conception du flux de données
  • Avant une refactorisation, vous devez comprendre la logique existante
  • Rédaction de documentation technique ou d'explications architecturales
  • Pendant une revue de code, besoin de visualiser la chaîne d'appels

Modèles principaux

1. Diagramme de flux complet (comparaison multi-scénarios)

Convient pour : analyser les différents scénarios d'utilisation d'une fonctionnalité (par exemple manuel vs automatique, succès vs échec)

┌─────────────────────────────────────────────────────────────────────┐
│                    Nom de la fonctionnalité (ex : Cycle de vie      │
│                    complet de la gestion des limites)               │
└─────────────────────────────────────────────────────────────────────┘

═══════════════════════════════════════════════════════════════════════
Scénario 1 : Nom du scénario (ex : Interrogation automatique de l'état
             des limites)
═══════════════════════════════════════════════════════════════════════

  Commande utilisateur
     │
     ▼
┌─────────────────────────────────────────────────────────────────┐
│  uv run python -m src.cli.xxx ...                               │
└────────────────┬────────────────────────────────────────────────┘
                 │
                 ▼
        ┌────────────────┐
        │  Couche CLI      │   Appelle la fonction Flow
        │  _do_xxx()        │ ────────────────────┐
        └────────────────┘                      │
                                                ▼
                                   ┌──────────────────────────┐
                                   │  Couche Flow              │
                                   │  xxx_flow()               │
                                   └───────┬──────────────────┘
                                           │
                                           ▼
                              ┌─────────────────────────────┐
                              │  Couche Data                 │
                              │  XxxRepo / XxxClient         │
                              └────────┬─────────────────────┘
                                       │
                                       ▼
                          ┌────────────────────────────┐
                          │  Système externe / Base de  │
                          │  données                    │
                          │  (SQLite / API / etc)       │
                          └──────────┬─────────────────┘
                                     │ Renvoie les données
                                     ▼
                    ┌──────────────────────────────────┐
                    │  Traitement des données          │
                    │  (Parsing / Transformation)      │
                    └─────────────┬────────────────────┘
                                  │
                                  ▼
                        ┌──────────────────────┐
                        │  Classe de données    │  ← Explique pourquoi on la   │
                        │  de retour            │    conserve / simplifie     │
                        │  (Result / Item / ...)│
                        └──────────┬───────────┘
                                   │
                                   ▼
                        ┌──────────────────────┐
                        │  Formatage de sortie  │
                        │  par la couche CLI    │
                        └──────────────────────┘
                                   │
                                   ▼
    ╔══════════════════════════════════════════════════╗
    ║  Exemple de sortie terminal                       ║
    ║  (Entouré de bordures pour mettre en évidence     ║
    ║   le résultat vu par l'utilisateur final)         ║
    ╚══════════════════════════════════════════════════╝

═══════════════════════════════════════════════════════════════════════
Scénario 2 : Un autre scénario
═══════════════════════════════════════════════════════════════════════
(Répéter la structure ci-dessus, en mettant en évidence les différences)

2. Explication de la structure de la table de base de données

Convient pour : expliquer les tables de base de données impliquées dans une fonctionnalité

CREATE TABLE nom_table (
    id INTEGER PRIMARY KEY AUTOINCREMENT,  -- ← Explique le rôle de la clé primaire
    champ1 TEXT NOT NULL,                  -- Explique la signification du champ
    champ2 TEXT,                           -- Signification métier de NULL
    ...
);

-- Index (explique pourquoi cet index est nécessaire)
CREATE INDEX idx_xxx ON nom_table(champ1, champ2);

Exemple de données :

idchamp1champ2champ3Description
42valeur1valeur2valeur3Explique la signification métier de cet enregistrement
43............

Requête typique :

-- Explication du scénario : quand faut-il interroger de cette façon ?
SELECT * FROM nom_table 
WHERE condition1 = ? 
  AND (condition2 IS NULL OR condition2 >= ?);

3. Diagramme de chaîne d'appels en couches (version simplifiée)

Convient pour : expliquer rapidement les relations d'appel entre fonctions

Couche CLI (_do_xxx)
    │
    └─> Couche Flow (xxx_flow)
            │
            ├─> Data/Repo (xxx_repo.get)
            │       │
            │       └─> SQLite (SELECT ...)
            │
            └─> Data/Client (xxx_client.fetch)
                    │
                    └─> API externe (HTTP GET ...)

4. Tableau d'analyse de conception des classes de données

Convient pour : évaluer si les classes de données intermédiaires sont nécessaires

Nom de la classeNombre de champsUtilisationVerdictRaison
XxxResult6Agrégation multi-champs + affichage CLI✅ ConserverSatisfait au "principe de nécessité minimale"
XxxWrapper1Emballage d'un seul champ❌ SupprimerEmballage excessif, retourner directement le type original
XxxItem3Élément de détail d'une liste✅ ConserverA une signification métier

Exemple de comparaison :

# ❌ Emballage excessif
@dataclass
class XxxResult:
    champ: SomeType  # Un seul champ

def xxx_flow() -> XxxResult:
    return XxxResult(champ=valeur)

# ✅ Simplifié
def xxx_flow() -> SomeType:  # Retour direct
    return valeur

5. Annotation des points métier clés

Convient pour : mettre en évidence les règles métier et les décisions de conception

┌─────────────────────────────────────────────────────────────┐
│                      Points métier clés                     │
├──────────────────────┬──────────────────────────────────────┤
│   Pourquoi cette     │          Décision spécifique         │
│   conception ?       │                                      │
├──────────────────────┼──────────────────────────────────────┤
│ • Précision des      │ Montants en Decimal, 2 décimales     │
│   données            │                                      │
│ • Idempotence        │ Contrainte d'unicité sur             │
│                      │ (fund_code, date)                    │
│ • Traçabilité        │ record_id comme identifiant unique   │
│                      │ global                               │
└──────────────────────┴──────────────────────────────────────┘

Comment utiliser

Étape 1 : Définir l'objectif de l'analyse

Répondez aux questions suivantes :

  1. De quelle fonctionnalité l'utilisateur souhaite-t-il comprendre le flux ?
  2. Combien de scénarios cette fonctionnalité a-t-elle ? (Succès/échec, manuel/automatique, etc.)
  3. Quelles couches sont impliquées ? (CLI → Flow → Data → DB/API)
  4. Quelles sont les classes de données clés ? Pourquoi sont-elles conçues ainsi ?

Étape 2 : Choisir le modèle approprié

  • Comparaison multi-scénarios → Modèle 1 (Diagramme de flux complet)
  • Flux unique → Modèle 3 (Diagramme d'appel en couches)
  • Conception de base de données → Modèle 2 (Structure de table + données exemple)
  • Évaluation des classes de données → Modèle 4 (Tableau d'analyse)

Étape 3 : Remplir le contenu

Principes :

  • Utiliser des diagrammes ASCII plutôt que de longs textes
  • Utiliser des flèches (│ ▼ ┐ ┘ └ ├ ─) pour relier les flux de données
  • Utiliser des bordures (┌ ┐ └ ┘ │ ─) pour séparer les couches
  • Utiliser des bordures doubles (╔ ╗ ╚ ╝ ║ ═) pour mettre en évidence les parties visibles par l'utilisateur
  • Ajouter des commentaires aux nœuds clés (← Explication)

Conventions d'utilisation des symboles :

SymboleUtilisationExemple
│ ▼Flux verticalDonnées de haut en bas
→ ←Explication horizontalerecord_id: int ← Clé primaire de la base
┌ ┐ └ ┘Bordure simpleEncadrer les blocs de code, les commandes
╔ ╗ ╚ ╝Bordure doubleMettre en évidence la sortie terminal, les résultats importants
═══Ligne de séparationSéparer différents scénarios

Étape 4 : Ajouter une analyse comparative

Avant vs Après (scénario de refactorisation) :

# Avant (version problématique)
...code...

# Problèmes :
# - Emballage excessif
# - Champs redondants
# - Augmente la charge cognitive

# Après (version améliorée)
...code...

# Améliorations :
# - Retour direct d'un type significatif
# - Réduction des couches intermédiaires
# - Coût de maintenance réduit

Exemples concrets

Exemple 1 : Flux de gestion des limites (version complète)

(Voir l'exemple du modèle 1 ci-dessus, développant le flux complet des 4 scénarios)

Exemple 2 : Évaluation des classes de données (module fund_restriction)

FonctionRetour précédentRetour actuelVerdictRaison
add_restrictionAddRestrictionResult (6 champs)Conserver✅Le CLI a besoin d'afficher tous les champs
end_restrictionEndRestrictionResult (4 champs)bool❌Seulement besoin de succès/échec
check_trading_statusCheckStatusResult (2 champs)ParsedRestriction | None❌Simple emballage

Liste de vérification (Checklist)

Lors de la génération d'un document de visualisation de flux, assurez-vous d'inclure :

  • Aperçu de haut niveau (objectif de la fonctionnalité, modules impliqués)
  • Énumération des scénarios (succès/échec, manuel/automatique, etc.)
  • Diagramme de flux en couches (CLI → Flow → Data → Externe)
  • Structure de la table de base de données (si impliquée)
  • Données d'exemple et requêtes (pour faciliter la compréhension)
  • Explication des classes de données clés (pourquoi conservées/simplifiées)
  • Raison de la conception (pourquoi cette approche ?)
  • Points d'extension futurs (TODO ou interfaces réservées)

Anti-modèles (à ne pas faire)

❌ Description purement textuelle du flux

D'abord, la couche CLI appelle la fonction _do_xxx, puis _do_xxx appelle la fonction xxx_flow de la couche Flow,
ensuite xxx_flow appelle la méthode xxx_repo.get de la couche Data...

✅ Utilisation d'un diagramme ASCII

CLI (_do_xxx) → Flow (xxx_flow) → Data (xxx_repo.get) → SQLite

❌ Tableau sans point clé

ChampType
idint
namestr

✅ Mise en évidence de la signification métier

ChampTypeDescriptionContrainte métier
idintClé primaireGénéré automatiquement, unique globalement
namestrNom du fondsNon nul, utilisé pour l'affichage

❌ SQL sans explication de scénario

SELECT * FROM table WHERE id = ?;

✅ Avec scénario métier

-- Scénario : L'utilisateur consulte le détail d'un enregistrement de restriction
SELECT * FROM fund_restrictions WHERE id = ?;

-- Scénario : Lors de l'analyse DCA, vérifier si un jour donné est limité
SELECT * FROM fund_restrictions
WHERE fund_code = ? AND start_date <= ? AND (end_date IS NULL OR end_date >= ?);

Collaboration avec d'autres compétences

  • code-style : Suivre les conventions de codage lors de l'écriture d'exemples de code
  • architecture : Les diagrammes de flux doivent respecter les contraintes d'architecture en couches
  • dev-workflow : Lire le code et la documentation pertinents avant d'analyser le flux

Résumé

La valeur fondamentale de cette compétence :

  1. Modèles réutilisables : Réduit le temps de démarrage à partir de zéro
  2. Style visuel unifié : Diagrammes ASCII + tableaux + bordures
  3. Perspective métier : Pas seulement le flux de code, mais aussi le "pourquoi"
  4. Analyse comparative : Avant/après refactorisation, comparaison multi-scénarios
  5. Vérification par liste : Assure qu'aucune information clé n'est omise

Fréquence d'utilisation : Chaque fois qu'il est nécessaire d'expliquer "comment fonctionne une fonctionnalité".

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

majiayu000/claude-skill-registry-data

Edit existing BMAD agents while maintaining compliance

majiayu000/claude-skill-registry-data

Edit existing BMAD agents while maintaining compliance

majiayu000/claude-skill-registry-data

Edit existing BMAD modules while maintaining coherence

majiayu000/claude-skill-registry-data

Edit existing BMAD modules while maintaining coherence

majiayu000/claude-skill-registry-data

Analyzes current state and user query to answer BMad questions or recommend the next workflow or agent. Use when user says what should I do next, what do I do now, or asks a question about BMad

majiayu000/claude-skill-registry-data

Build AI agents with Google ADK Python (Agent Development Kit). Use for multi-agent systems, workflow agents (sequential/parallel/loop), Vertex AI deployment, tool integration, human-in-the-loop.

majiayu000/claude-skill-registry-data

Build AI agents with Google ADK Python (Agent Development Kit). Use for multi-agent systems, workflow agents (sequential/parallel/loop), Vertex AI deployment, tool integration, human-in-the-loop.

majiayu000/claude-skill-registry-data

Portfolio allocation and rebalancing optimizer. Manages asset allocation across stocks/cash/bonds, performs periodic rebalancing, and ensures diversification according to market regime and risk tolerance.

majiayu000/claude-skill-registry-data

Create a hilarious and ultra-realistic video of an anthropomorphic animal acting like a human vlogger in a real-world setting.

majiayu000/claude-skill-registry-data

Speech-to-text transcription and translation via OpenAI Audio API -- models, response formats, timestamps, prompting, streaming, chunking, and diarization

majiayu000/claude-skill-registry-data

This skill should be used when the user asks about libraries, frameworks, API references, or needs code examples. Activates for setup questions, code generation involving libraries, or mentions of specific frameworks like React, Vue, Next.js, Prisma, Supabase, etc.

majiayu000/claude-skill-registry-data

小省导购员数字人带货版即梦视频提示词生成系统,基于四大智能体协同(提示词生成师、质量管控师、知识库运维师、跨环节适配师),按照"主体+运动+场景+(镜头语言+光影+氛围)"公式输出中英文双版提示词,适配5s短视频。确保人物一致性、视觉连贯性、情绪连贯性,支持知识库智能复用和跨工具适配(Suno音乐、AI绘画),为数字人带货视频提供高质量提示词生成服务。

majiayu000/claude-skill-registry-data

Upload and manage files using Google Gemini File API via scripts/. Use for uploading images, audio, video, PDFs, and other files for use with Gemini models. Supports file upload, status checking, and file management. Triggers on "upload file", "file API", "upload image", "upload PDF", "upload video", "file management".

majiayu000/claude-skill-registry-data

Analyze images/audio/video with Gemini API (better vision than Claude). Generate images (Imagen 4), videos (Veo 3). Use for vision analysis, transcription, OCR, design extraction, multimodal AI.

majiayu000/claude-skill-registry-data

Analyze images/audio/video with Gemini API (better vision than Claude). Generate images (Imagen 4), videos (Veo 3). Use for vision analysis, transcription, OCR, design extraction, multimodal AI.

majiayu000/claude-skill-registry-data

Skill for discovering and researching autonomous AI agents, tools, and ecosystems using the AgentFolio directory.

majiayu000/claude-skill-registry-data

Conduct domain and industry research. Use when the user says "lets create a research report on [domain or industry]

majiayu000/claude-skill-registry-data

Conduct market research on competition and customers. Use when the user says "create a market research report about [business idea]".

majiayu000/claude-skill-registry-data

Conduct technical research on technologies and architecture. Use when the user says "create a technical research report on [topic]".

majiayu000/claude-skill-registry-data

Builds, edit or validate Agent Skill through conversational discovery. Use when the user requests to "Create an Agent", "Optimize an Agent" or "Edit an Agent".

Skills associés