Communitygithub.com

Générateur de README

Génère des fichiers README.md complets et de haute qualité pour des dépôts de code internes/d'entreprise en analysant le code existant et en posant des questions ciblées.

Qu'est-ce que Générateur de README ?

Cette compétence automatise la création de fichiers README.md professionnels pour les dépôts de code internes ou d’entreprise. Elle est idéale pour les développeurs, chefs de projet ou mainteneurs qui souhaitent documenter rapidement un projet tout en garantissant une couverture complète des informations essentielles (architecture, configuration, utilisation, dépannage). L’outil fonctionne en trois étapes : une analyse structurée en quatre phases du code source (métadonnées, architecture, modules profonds, infrastructure de support) avec attribution de niveaux de confiance ; puis la génération de questions ciblées pour combler les lacunes ; enfin la rédaction du README. La sortie suit un modèle riche incluant diagrammes Mermaid (3 à 6 recommandés), badges shields.io, table des matières imbriquée, tableaux d’environnement, exemples de code exécutables et section de dépannage. La compétence privilégie la spécificité plutôt que le générique, avec des commandes réelles et des chemins de fichiers, et demande confirmation avant d’écraser un README existant. Elle est compatible avec tout dépôt contenant des fichiers source (Python, JavaScript, Go, etc.) et repose sur des outils d’extraction de code natifs aux agents.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/cdcoonce/Portfolio_Website/tree/HEAD/.claude/skills/readme-generator

Demander à votre IA préférée

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

Aperçu

Depuis le README du skill

Langage

Documentation

Que fait Générateur de README ?

Créez des fichiers README.md soignés et complets pour les dépôts de code internes/d'entreprise en analysant le code existant et en posant des questions ciblées.

Pourquoi cette compétence existe

Un bon README est la porte d’entrée d’un code. Pour les projets internes surtout, un README absent ou trop succinct signifie que chaque nouveau membre de l’équipe perd des heures à comprendre ce que fait le projet, comment l’exécuter et où chercher. Cette compétence automatise le gros du travail — elle lit le code, en déduit ce qu’elle peut, demande ce qu’elle ne peut pas déterminer, et produit un README qui rend les développeurs productifs rapidement.

Workflow

Étape 1 : Analyser le code source

Avant de demander quoi que ce soit à l’utilisateur, exécutez une analyse structurée en quatre phases pour rassembler un maximum de contexte. Cela réduit la charge sur l’utilisateur — il ne doit combler que les lacunes, pas décrire ce que vous pouvez déjà voir.

Attribuez à chaque fait un niveau de confiance : [confirmé] (lu dans le source), [inféré-élevé] (preuve forte), [inféré-faible] (preuve partielle), ou [inconnu]. Les trouvailles à faible confiance ou inconnues deviendront des questions de clarification à l’étape 2.

Voir references/analysis-phases.md pour les actions d’outil détaillées, les motifs grep, les listes de vérification d’extraction et les modèles d’enregistrement.

Phase 1 — Analyse des métadonnées du projet : Recherchez globalement les fichiers de gestionnaire de paquets (pyproject.toml, package.json, etc.), les modèles d’env, les Dockerfiles, les configurations CI/CD et les fichiers de chaîne d’outils. Lisez chacun et extrayez : nom/version du projet, langage, dépendances (catégorisées avec leurs rôles), scripts/commandes, variables d’environnement (obligatoires vs optionnelles), étapes CI, licence.

Phase 2 — Analyse de l’architecture : Recherchez globalement tous les fichiers source pour mapper la structure des répertoires. Greppez les marqueurs de point d’entrée (if __name__, main(), etc.) et lisez chaque point d’entrée. Construisez le graphe d’importation en grepant les instructions d’importation dans tous les fichiers source — classez les modules en cœur (fort degré entrant), feuilles ou orchestrateurs. Identifiez le motif architectural (pipeline, MVC, en couches, microservices, événementiel, CLI, monolithe) à l’aide de la liste de vérification des indicateurs. Greppez les motifs de chargement de configuration pour trouver les fichiers de configuration runtime.

Phase 3 — Analyse approfondie des modules : Lisez chaque fichier source significatif (priorité : cœur → point d’entrée → plus volumineux → reste). Pour chacun, extrayez : le rôle (une phrase), les exports clés avec signatures, les notes de conception (décisions non évidentes, cas particuliers, conventions), et les dépendances internes. Tracez le flux de travail principal de bout en bout à travers le graphe d’importation, en étiquetant les types de données qui circulent entre les modules. Pour les codes avec 8 fichiers source ou plus, distribuez des sous-agents parallèles regroupés par clusters de dépendances.

Phase 4 — Analyse de l’infrastructure de support : Recherchez globalement les fichiers de test et les fixtures. Lisez les 30 à 50 premières lignes de chaque fichier de test pour établir une correspondance test-à-module. Greppez les classes d’exception personnalisées et les instructions raise pour cartographier la hiérarchie des erreurs. Analysez les modèles, ressources et documents existants. Extrayez les scénarios d’erreur courants pour le tableau de dépannage.

Étape 2 : Poser des questions de clarification

Après l’analyse, demandez à l’utilisateur ce que vous n’avez pas pu déduire avec confiance. Restez ciblé — ne posez pas de questions sur des choses que vous savez déjà. Les lacunes courantes incluent :

  • Objectif du projet : Quel problème cela résout-il ? Qui l’utilise ? (si pas évident à partir du code)
  • Pièges de configuration : Y a-t-il des prérequis non évidents, des exigences VPN, des registres de paquets internes ou des étapes de configuration de base de données ?
  • Flux de travail clés : Quelles sont les 2-3 choses qu’un développeur fait le plus souvent avec ce projet ?
  • Déploiement : Comment/où cela est-il déployé ? (si pas clair à partir des configurations CI/CD)
  • Conventions d’équipe : Y a-t-il des conventions de nommage, des stratégies de branche ou des modèles à signaler ?
  • Contact : Qui possède/mainient ce projet ? (nom + email pour la section Contact)

Présentez vos questions de manière concise. Si le code est simple et que vous êtes confiant dans votre analyse, vous n’aurez besoin que de 1-2 questions — voire aucune. Faites preuve de discernement.

Étape 3 : Générer le README.md

Rédigez le README en utilisant la structure et les directives ci-dessous.

Structure du README

Utilisez ceci comme modèle. Incluez toutes les sections, mais adaptez la profondeur à la complexité du projet. Utilisez des règles horizontales --- entre chaque section principale pour une respiration visuelle.

# Nom du Projet

![Langage](https://img.shields.io/badge/...) ![Framework](https://img.shields.io/badge/...) ![Outil](https://img.shields.io/badge/...)

Description brève et claire. Utilisez **gras** pour mettre en évidence la technologie clé ou le type de produit.

---

## Table des Matières

Générez une table des matières imbriquée et complète qui inclut TOUS les titres ## et ###. Indentez les sous-sections sous leurs parents pour que les lecteurs puissent voir la structure complète d’un coup d’œil. C’est particulièrement important pour les README longs — la TdM sert à la fois d’outil de navigation et de plan du document entier.

Exemple de la profondeur attendue :

- [Aperçu](#aperçu)
- [Architecture](#architecture)
  - [Architecture de Haut Niveau](#architecture-de-haut-niveau)
  - [Structure des Dossiers](#structure-des-dossiers)
  - [Graphe des Dépendances des Modules](#graphe-des-dépendances-des-modules)
- [Pour Commencer](#pour-commencer)
  - [Prérequis](#prérequis)
  - [Installation](#installation)
  - [Exécution des Tests](#exécution-des-tests)
- [Variables d’Environnement](#variables-denvironnement)
- [Utilisation](#utilisation)
  - [Exemple : Cas d’Utilisation Principal](#exemple-cas-dutilisation-principal)
  - [Exemple : Cas d’Utilisation Secondaire](#exemple-cas-dutilisation-secondaire)
- [Référence API](#référence-api)
  - [Ressource A](#ressource-a)
  - [Ressource B](#ressource-b)
- [Dépannage](#dépannage)
- [Contact](#contact)
- [Licence](#licence)

Chaque titre ### dans le document doit apparaître comme une entrée indentée sous son titre ## parent. Ne sautez pas de sous-sections — tout l’intérêt d’une TdM complète est que les lecteurs peuvent accéder directement à n’importe quelle partie du document.

---

## Aperçu

Développez la description. Mettez en gras les termes clés. Utilisez des listes numérotées pour les processus en plusieurs étapes.

---

## Architecture

### Architecture de Haut Niveau

```mermaid
graph TD
    ...
```

Structure des Dossiers

dossier-racine/
├── src/           # Brève annotation
├── tests/         # Brève annotation
└── ...

[Flux de Données / Pipeline / Dépendances des Modules — diagrammes supplémentaires]

...

Pour Commencer

Prérequis

Installation

Exécution des Tests


Variables d’Environnement

VariableRequiseDescription
DB_URLOuiChaîne de connexion PostgreSQL

Utilisation

Exemples de code réels pour les 2-3 opérations les plus courantes.


Référence API


Dépannage

SymptômeCause ProbableCorrection
message d’erreurQuel est le problèmeComment le résoudre

Contact

Pour toute question ou assistance, contactez :


Licence

Usage Interne Uniquement – Nom de l’Entreprise Logiciel propriétaire. © [Année] [Entreprise]. Tous droits réservés.


## Badges Shields.io

Incluez toujours des badges shields.io juste après le titre `# Titre` (3 à 6 badges couvrant le langage, le framework, la bibliothèque clé, le gestionnaire de paquets, la base de données, l’infrastructure). Voir [references/badge-reference.md](references/badge-reference.md) pour le format, les exemples et les suggestions de couleurs par catégorie.

## Directives pour les Diagrammes Mermaid

Utilisez généreusement les diagrammes Mermaid — ils rendent l’architecture, les flux de données et les processus immédiatement compréhensibles. Un README typique devrait contenir **3 à 6 diagrammes** ; les projets complexes (pipelines de données, systèmes multi-services) peuvent en avoir **6 à 10 ou plus**. Voir [references/mermaid-guidelines.md](references/mermaid-guidelines.md) pour savoir quand utiliser chaque type de diagramme, les bonnes pratiques et les recommandations spécifiques au type de projet.

## Directives de Rédaction

- **Soyez spécifique plutôt que générique.** « Exécutez `npm run dev` » vaut mieux que « Démarrez le serveur de développement. » Incluez les commandes réelles, les chemins de fichiers et les noms de variables.
- **Écrivez pour le nouveau membre de l’équipe.** Supposez des compétences générales en ingénierie mais aucun contexte sur le projet.
- **Mettez en gras les termes clés et les noms de produits** lors de la première mention et dans les aperçus. Cela aide les lecteurs à scanner.
- **Utilisez des listes numérotées pour les processus séquentiels.** « 1. **Extrait** les données de X. 2. **Transforme** ces données. 3. **Charge** dans Y. » — mettez le verbe en gras.
- **Les exemples de code doivent être exécutables.** Copiez depuis le code source réel lorsque c’est possible.
- **Les tableaux de variables d’environnement sont non négociables.** Listez chaque variable.
- **Dépannage sous forme de tableau** (Symptôme | Cause Probable | Correction) — lisible et cohérent.
- **Les annotations de la structure des dossiers doivent être brèves.** Une courte phrase par répertoire.
- **Incluez toujours une section Contact.** Demandez à l’utilisateur qui maintient le projet. Format : `**Nom** — [email protected]`.
- **Utilisez des règles horizontales `---`** entre toutes les sections principales pour une structure visuelle.

## Sortie

Sauvegardez le README sous le nom `README.md` dans la racine du dépôt (ou le répertoire de travail courant si aucune racine de dépôt n’est identifiable). Si un fichier `README.md` existe déjà, confirmez avec l’utilisateur avant d’écraser — il pourrait vouloir en conserver des parties.

Individual skills in this repo

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

cdcoonce/Portfolio_Website

Git commit workflow with enforced conventional commit style. Use when Claude needs to stage and commit changes, craft commit messages, or the user asks to commit, make a commit, or save their work. Ensures consistent commit message format, proper scoping, and atomic commits across the project.

cdcoonce/Portfolio_Website

AI-powered code quality analysis for Python, Markdown, and Mermaid diagrams. Use this skill when: (1) reviewing code for quality issues, (2) checking Python files for PEP8 violations, unused code, missing type hints, docstring problems, complexity issues, or potential runtime errors, (3) validating Markdown documentation for broken links, heading structure, or formatting issues, (4) validating Mermaid diagram syntax, (5) the user asks for a "code review" or "quality check", (6) analyzing code snippets pasted in conversation, or (7) suggesting and applying fixes for code quality issues.

cdcoonce/Portfolio_Website

Deploy the portfolio chat agent Lambda function to AWS. Use when the user asks to deploy, redeploy, push to Lambda, update the chat agent, or after updating context files or lambda_function.py. Rebuilds the knowledge base, packages dependencies, and deploys to AWS Lambda.

cdcoonce/Portfolio_Website

Generate multiple radically different interface designs for a module using parallel sub-agents. Use when user wants to design an API, explore interface options, compare module shapes, or mentions "design it twice".

cdcoonce/Portfolio_Website

Orchestrate the full GitHub-issues-driven development lifecycle. 7-phase pipeline from brainstorm through PR with state tracking and cross-conversation resume. Use when user says "dev cycle", "development workflow", "full development pipeline", or invokes /dev-cycle.

cdcoonce/Portfolio_Website

Production Python coding standards with automatic version detection (3.10-3.13). Use when writing, reviewing, or refactoring Python to ensure adherence to modern type syntax, LBYL exception handling, pathlib operations, ABC-based interfaces, and production-tested patterns. Not Dagster-specific - applies to any Python project.

cdcoonce/Portfolio_Website

Set up Claude Code hooks to block dangerous git commands (push, reset --hard, clean, branch -D, etc.) before they execute. Use when user wants to prevent destructive git operations, add git safety hooks, or block git push/reset in Claude Code.

cdcoonce/Portfolio_Website

GitHub CLI (gh) integration for managing issues, pull requests, branches,

cdcoonce/Portfolio_Website

Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".

cdcoonce/Portfolio_Website

Explore a codebase to find opportunities for architectural improvement, focusing on making the codebase more testable by deepening shallow modules. Use when user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more AI-navigable.

cdcoonce/Portfolio_Website

CEO/founder-mode plan review. Rethink the problem, find the 10-star product, challenge premises, expand scope when it creates a better product. Three modes: SCOPE EXPANSION (dream big), HOLD SCOPE (maximum rigor), SCOPE REDUCTION (strip to essentials). Use when the user asks for a plan review, CEO review, mega review, or wants a plan challenged/stress-tested before implementation.

cdcoonce/Portfolio_Website

Break a PRD into independently-grabbable GitHub issues using tracer-bullet vertical slices. Use when user wants to convert a PRD to issues, create implementation tickets, or break down a PRD into work items.

cdcoonce/Portfolio_Website

Turn a PRD into a multi-phase implementation plan using tracer-bullet vertical slices, saved as a local Markdown file in docs/plans/. Use when user wants to break down a PRD, create an implementation plan, plan phases from a PRD, or mentions "tracer bullets".

cdcoonce/Portfolio_Website

Generate or update the `.claude/docs/project.md` file that gives Claude project-specific context. Use this skill when the user asks to create, update, regenerate, or refresh project context, or says things like "update project.md", "generate project context", "this repo needs a project.md", or "Claude doesn't know about this project". Also trigger when onboarding Claude to a new repository for the first time.

cdcoonce/Portfolio_Website

Create a detailed refactor plan with tiny commits via user interview, then file it as a GitHub issue. Use when user wants to plan a refactor, create a refactoring RFC, or break a refactor into safe incremental steps.

cdcoonce/Portfolio_Website

Set up pre-commit hooks for the current repo. Use when user wants to add pre-commit hooks, configure commit-time linting, formatting, type checking, or testing. Triggers on "pre-commit", "git hooks", "linting hooks", or /setup-pre-commit.

cdcoonce/Portfolio_Website

Test-driven development with red-green-refactor loop. Use when user wants to build features or fix bugs using TDD, mentions "red-green-refactor", wants integration tests, or asks for test-first development.

cdcoonce/Portfolio_Website

Triage a bug or issue by exploring the codebase to find root cause, then create a GitHub issue with a TDD-based fix plan. Use when user reports a bug, wants to file an issue, mentions "triage", or wants to investigate and plan a fix for a problem.

cdcoonce/Portfolio_Website

Rewrites the prose sections of wiki pages in-place. Reads source files to understand current context, then updates only the content inside <!-- claude:prose --> ... <!-- claude:prose:end --> markers. Never touches <!-- generated:start --> ... <!-- generated:end --> blocks. Supports targeting a single page with /update-wiki {PageName}.

cdcoonce/Portfolio_Website

Create a PRD through user interview, codebase exploration, and module design, then submit as a GitHub issue. Use when user wants to write a PRD, create a product requirements document, or plan a new feature.

Skills associés