Communitygithub.com

infinyte/générateur-de-portfolio

Transformez vos projets techniques en pièces de portfolio percutantes avec résumés exécutifs, analyses techniques approfondies, diagrammes d'architecture, métriques d'impact et pages GitHub prêtes à être démontrées. Analyse les dépôts GitHub et les descriptions de projets pour générer des supports de présentation adaptés à chaque public.

Qu'est-ce que générateur-de-portfolio ?

Cette compétence permet de transformer des projets techniques en supports de portfolio professionnels optimisés pour différents publics (recruteurs, responsables du recrutement, architectes, leads techniques). Elle analyse la structure des dépôts GitHub, la stack technologique, les patterns architecturaux et les métriques d'impact. La compétence génère six types de livrables : résumés exécutifs, analyses techniques approfondies, diagrammes d'architecture (Mermaid), analyses de métriques, histoires STAR pour entretiens, et un site complet GitHub Pages. Elle prend en charge les entrées sous forme de dépôt GitHub, notes brutes, spécifications techniques, conversation naturelle ou documentation existante. Les cas d'utilisation incluent la création de portfolios pour candidatures, la préparation d'entretiens techniques, la construction de sites de démonstration professionnels, et l'extraction d'impact métier à partir de réalisations techniques.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add infinyte/portfolio-showcase-generator

Demander à votre IA préférée

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

Documentation

Générateur de Portfolio

Une compétence complète pour transformer des projets techniques en pièces de portfolio professionnelles, optimisées pour différents publics (recruteurs, responsables du recrutement, architectes, leads techniques).

Capacités principales

  1. Analyse de code : Analyser la structure d'un dépôt GitHub, la stack technologique, les patterns architecturaux
  2. Adaptation au public : Générer du contenu pour les dirigeants, les architectes et les équipes techniques
  3. Visualisation d'architecture : Créer des diagrammes système, de flux de données et de déploiement
  4. Quantification d'impact : Extraire et présenter des métriques métier et des réalisations techniques
  5. Sortie multi-format : Résumés exécutifs, analyses techniques approfondies, histoires pour entretiens, pages GitHub

Quand utiliser cette compétence

Utilisez cette compétence lorsque l'utilisateur souhaite :

  • Transformer un projet technique en supports de portfolio
  • Créer des études de cas convaincantes à partir de son travail
  • Générer des supports de préparation aux entretiens (histoires au format STAR)
  • Construire une vitrine professionnelle sur GitHub Pages
  • Extraire l'impact métier de réalisations techniques
  • Créer des résumés de projet adaptés à chaque public

Formats d'entrée

La compétence accepte plusieurs formats d'entrée :

1. Dépôt GitHub

  • URL du dépôt ou chemin local
  • Analyse : structure des fichiers, patterns de code, stack technologique, dépendances, documentation
  • Extraction : patterns architecturaux (DDD, microservices, etc.), frameworks, services cloud

2. Contexte du projet (toute combinaison)

  • Notes brutes / puces : captures rapides des réalisations et détails
  • Spécifications techniques : docs d'architecture, documents de conception
  • Conversationnel : l'utilisateur décrit le projet naturellement
  • Documentation existante : fichiers README, wikis, ADR

3. Contexte métier

  • Objectifs et buts du projet
  • Problèmes résolus
  • Parties prenantes et utilisateurs
  • Calendrier et taille de l'équipe
  • Contraintes et défis

Génération de sortie

1. Résumé exécutif (pour les responsables du recrutement / recruteurs)

Objectif : Aperçu rapide et percutant, axé sur la valeur métier et les résultats.

Structure :

  • Présentation du projet (2-3 phrases) : De quoi s'agit-il, pourquoi c'est important
  • Réalisations clés (3-5 puces) : Impact métier quantifié
  • Points forts techniques (bref) : Technologies/approches notables
  • Calendrier et périmètre : Durée, taille de l'équipe, rôle
  • Métriques d'impact : Gains de performance, économies de coûts, métriques utilisateur

Ton : Professionnel, confiant, axé sur les résultats. Minimisez le jargon. Mettez en avant les résultats.

Longueur : 150-250 mots (lecture de 30 à 60 secondes)

2. Analyse technique approfondie (pour les architectes / leads techniques)

Objectif : Démontrer une réflexion architecturale, une profondeur technique et un jugement d'ingénierie.

Structure :

  • Contexte et contraintes : Exigences, contraintes, systèmes existants
  • Décisions architecturales : Choix de conception clés avec justification
  • Implémentation technique :
    • Architecture système
    • Stack technologique et pourquoi
    • Patterns appliqués (DDD, CQRS, event sourcing, etc.)
    • Points d'intégration
  • Défis et solutions : Problèmes techniques et comment vous les avez résolus
  • Échelle et performance : Métriques, stratégies d'optimisation
  • Sécurité et qualité : Tests, observabilité, mesures de sécurité
  • Compromis : Ce que vous avez optimisé, ce que vous avez sacrifié, pourquoi

Ton : Technique mais accessible. Expliquez le raisonnement, pas seulement les choix. Montrez le jugement.

Longueur : 800-1500 mots (lecture de 4 à 6 minutes)

3. Diagrammes d'architecture (Mermaid)

Générer les diagrammes appropriés en fonction du type de projet :

Diagramme d'architecture système :

graph TB
    Client[Application Client]
    API[Passerelle API]
    Service1[Nom du Service]
    Service2[Nom du Service]
    DB[(Base de données)]
    Cache[(Cache)]
    
    Client --> API
    API --> Service1
    API --> Service2
    Service1 --> DB
    Service1 --> Cache

Diagramme de flux de données :

flowchart LR
    Source[Source de données] --> Ingestion[Couche d'ingestion]
    Ingestion --> Traitement[Traitement]
    Traitement --> Stockage[(Stockage)]
    Stockage --> API[Couche API]
    API --> Consommateur[Consommateur]

Diagramme de déploiement :

graph TB
    subgraph Azure
        subgraph VNet
            AppService[App Service]
            Fonction[Azure Functions]
        end
        DB[(Base de données SQL)]
        Stockage[(Stockage Blob)]
    end
    
    AppService --> DB
    Fonction --> Stockage

Directives :

  • Utilisez le type de diagramme approprié au contenu
  • Gardez les diagrammes ciblés (5 à 12 nœuds maximum)
  • Utilisez des étiquettes claires et descriptives
  • Incluez une légende si nécessaire pour les couleurs/formes
  • Générez plusieurs diagrammes si le projet est complexe

4. Analyse des métriques et de l'impact

Extraire et présenter les réalisations quantifiables :

Métriques techniques :

  • Améliorations de performance (temps de réponse, débit, etc.)
  • Réalisations en matière d'évolutivité (utilisateurs supportés, transactions/s)
  • Qualité du code (couverture de tests, réduction des défauts)
  • Fiabilité (disponibilité, MTTR, taux d'erreur)
  • Améliorations de la sécurité (vulnérabilités corrigées, conformité atteinte)

Métriques métier :

  • Économies de coûts (infrastructure, temps de développement)
  • Impact sur le chiffre d'affaires (nouvelles capacités, expansion du marché)
  • Gains d'efficacité (automatisation, réduction du travail manuel)
  • Satisfaction utilisateur (NPS, taux d'adoption)
  • Délai de mise sur le marché (vitesse de livraison, fréquence des versions)

Format : Présenter sous forme de chiffres concrets avec contexte :

  • "Réduction du temps de réponse API de 60 % (450 ms → 180 ms)"
  • "Réduction des coûts cloud de 24 000 $/an grâce à l'optimisation des ressources"
  • "Évolutivité multipliée par 10, de 1 000 à 10 000 utilisateurs simultanés"

5. Préparation aux entretiens (format STAR)

Générer 2 à 4 histoires convaincantes au format STAR :

Structure :

  • Situation : Contexte, problème, contraintes (2-3 phrases)
  • Tâche : Votre responsabilité spécifique (1-2 phrases)
  • Action : Ce que vous avez fait, décisions techniques, implémentation (3-5 phrases)
  • Résultat : Résultats, métriques, impact (2-3 phrases)

Longueur : Chaque histoire doit durer 90 à 120 secondes à l'oral

Focus : Différentes histoires doivent mettre en avant :

  • La résolution de problèmes techniques
  • La prise de décision architecturale
  • Le leadership / l'influence
  • La gestion des contraintes / compromis

6. Site GitHub Pages

Générer une structure de site statique complète :

Page d'accueil (index.html) :

  • Section héros avec le nom du projet et le slogan
  • Statistiques rapides (stack technologique, calendrier, métriques d'impact)
  • Navigation vers les sections
  • Capture d'écran / démo si disponible

Page d'architecture (architecture.html) :

  • Présentation du système
  • Diagrammes d'architecture (Mermaid intégré)
  • Détails de la stack technologique
  • Décisions de conception

Page d'impact (impact.html) :

  • Résultats métier
  • Réalisations techniques
  • Visualisation des métriques
  • Comparaisons avant/après

Page de démonstration (demo.html - si applicable) :

  • Démo interactive ou visite guidée
  • Captures d'écran annotées
  • Scénarios d'utilisation
  • Intégration vidéo si disponible

Style :

  • Design propre et professionnel
  • Adapté aux mobiles
  • Chargement rapide (dépendances minimales)
  • Accessible (conforme WCAG)
  • Optionnel : Utiliser Primer CSS de GitHub ou Tailwind CDN

Workflow

Étape 1 : Collecter les entrées

  1. Demander la source du projet :

    • URL/chemin du dépôt GitHub
    • Documentation existante
    • Notes du projet
  2. Comprendre le contexte :

    • Quel problème a été résolu ?
    • Pour qui ?
    • Quel était votre rôle ?
    • Qu'est-ce qui était difficile ?
    • Quels ont été les résultats ?
  3. Clarifier les sorties :

    • De quels livrables ont-ils besoin ?
    • Exigences spécifiques (longueur, domaines d'intérêt) ?
    • Détails sur le public cible ?

Étape 2 : Analyser (si un dépôt GitHub est fourni)

Utiliser les outils bash/view pour analyser le dépôt :

# Analyser la structure du dépôt
find /chemin/vers/depot -type f -name "*.cs" -o -name "*.csproj" | head -20
find /chemin/vers/depot -type f -name "*.yml" -o -name "*.yaml"

# Vérifier les docs d'architecture
find /chemin/vers/depot -type f -name "*.md" | grep -i "architecture\|design\|adr"

# Analyser les dépendances
cat /chemin/vers/depot/*.csproj
cat /chemin/vers/depot/package.json
cat /chemin/vers/depot/requirements.txt

# Vérifier la configuration
find /chemin/vers/depot -name "appsettings*.json" -o -name "*.config"

Extraire :

  • Stack technologique : Langages, frameworks, bases de données, services cloud
  • Patterns : DDD, microservices, event-driven, CQRS, etc.
  • Architecture : Monolithe, microservices, serverless, etc.
  • Infrastructure : Fournisseur cloud, stratégie de déploiement
  • Pratiques qualité : Tests, CI/CD, monitoring

Étape 3 : Générer le contenu

Générer chaque type de sortie demandé en suivant les structures ci-dessus.

Principes clés :

  • D'abord le public : Adaptez la profondeur et le jargon au public
  • Basé sur les preuves : Ancrez les affirmations dans le code/la documentation lorsque c'est possible
  • Quantifiez : Essayez toujours d'inclure des chiffres et des métriques
  • Piloté par l'histoire : Mettez l'accent sur défis → solutions → impact
  • Honnêteté : Reconnaissez les contraintes et les compromis

Étape 4 : Créer les artefacts

Pour les documents (résumés, analyses approfondies) :

  • Utilisez le format markdown
  • Incluez des sections claires avec des en-têtes
  • Ajoutez des extraits de code si nécessaire
  • Intégrez des diagrammes

Pour GitHub Pages :

  • Générez des fichiers HTML complets
  • Incluez du CSS en ligne ou référencez un CDN
  • Assurez l'adaptabilité aux mobiles
  • Ajoutez des balises méta pour le SEO

Pour les diagrammes :

  • Utilisez l'outil Mermaid Chart pour le rendu
  • Fournissez à la fois la source Mermaid et l'image rendue
  • Assurez-vous que les diagrammes sont explicites

Étape 5 : Emballer les livrables

Organiser les sorties en fonction des besoins de l'utilisateur :

Pour les candidatures :

  • Résumé exécutif (prêt à copier/coller)
  • 2-3 histoires STAR
  • Liste des métriques clés

Pour le site portfolio :

  • Structure complète de GitHub Pages
  • Tous les actifs organisés
  • Instructions de déploiement

Pour les entretiens :

  • Histoires STAR (imprimées/PDF)
  • Diagramme d'architecture (pour référence au tableau blanc)
  • Aide-mémoire des métriques

Considérations particulières

Projets .NET/Azure

  • Mettre en avant : Patterns DDD, principes SOLID, patterns async/await
  • Souligner : Zero Trust, conformité InfoSec, patterns d'entreprise
  • Stack technologique : version .NET, services Azure utilisés, patterns de conception

Projets de Machine Learning / Vision par ordinateur

  • Se concentrer : Cadrage du problème, justification du choix du modèle, métriques de performance
  • Mettre en avant : Approche d'entraînement, pipeline de données, optimisation de l'inférence
  • Métriques : Précision, rappel, F1, latence d'inférence

Projets d'intégration

  • Souligner : Conception API, gestion des erreurs, cohérence des données
  • Mettre en avant : Intégrations tierces, limitation de débit, patterns de résilience
  • Métriques : Fiabilité (disponibilité), précision des données, débit

Projets d'entreprise / à grande échelle

  • Contexte : Échelle, exigences de conformité, contraintes héritées
  • Mettre en avant : Stratégies de migration, rétrocompatibilité, atténuation des risques
  • Métriques : Chiffres d'échelle, performance sous charge, optimisation des coûts

Format de sortie

Lors de la génération de plusieurs sorties, organisez comme suit :

# Portfolio : [Nom du projet]

## Référence rapide
- **Stack technologique** : [Liste]
- **Durée** : [Calendrier]
- **Rôle** : [Votre rôle]
- **Impact** : [Top 1-2 métriques]

## Sorties générées

### 1. Résumé exécutif
[Contenu]

### 2. Analyse technique approfondie
[Contenu]

### 3. Histoires STAR
#### Histoire 1 : [Titre]
[Contenu]

#### Histoire 2 : [Titre]
[Contenu]

### 4. Diagrammes d'architecture
[Diagrammes avec explications]

### 5. Tableau de bord des métriques
[Métriques formatées]

### 6. Fichiers GitHub Pages
[Structure des fichiers et contenu]

Liste de contrôle qualité

Avant de livrer, assurez-vous :

  • Toutes les métriques sont spécifiques et quantifiées
  • Les termes techniques sont expliqués ou justifiés pour le public
  • Les diagrammes sont clairs et correctement étiquetés
  • Les histoires STAR sont complètes (tous les 4 éléments)
  • Le résumé exécutif réussit le test de « l'argumentaire éclair »
  • L'analyse technique approfondie démontre une réflexion architecturale
  • Les pages GitHub sont adaptées aux mobiles et accessibles
  • Aucune erreur grammaticale ou faute de frappe
  • Terminologie cohérente dans l'ensemble
  • Les réalisations sont présentées comme un impact, pas seulement des tâches

Exemples de prompts

Simple : "Crée une vitrine de portfolio pour mon projet DocFlow sur GitHub"

Détaillé : "J'ai construit un tableau de bord d'état des vols en utilisant .NET 8, DDD et Azure. C'était la première application déployée dans notre environnement Zero Trust. J'ai besoin d'un résumé exécutif pour les recruteurs et d'une analyse technique approfondie pour l'entretien, ainsi que des diagrammes d'architecture."

Conversationnel : "Je souhaite mettre en avant mon projet de scanner IA de documents. Il utilise la vision par ordinateur pour extraire des données de tableaux blancs et s'intègre à plusieurs systèmes. Peux-tu m'aider à créer des supports pour mon site portfolio ?"

Conseils pour les utilisateurs

Pour obtenir les meilleurs résultats :

  1. Fournissez l'accès GitHub si possible (source d'information la plus riche)
  2. Partagez le « pourquoi » du projet (le contexte métier est important)
  3. Incluez toutes les métriques que vous avez suivies (même informelles)
  4. Mentionnez les défis que vous avez surmontés (ils font de bonnes histoires)
  5. Spécifiez votre public cible (la profondeur technique varie considérablement)
  6. Notez ce qui vous a rendu fier ou ce que vous avez appris (les détails authentiques résonnent)

Erreurs courantes à éviter :

  • Être trop modeste (le portfolio n'est pas le lieu de la modestie)
  • Lister des tâches au lieu de réalisations ("J'ai construit une API" vs "J'ai conçu une API qui a réduit la latence de 40 %")
  • Utiliser du jargon sans contexte pour les publics non techniques
  • Oublier de quantifier l'impact
  • Donner l'impression qu'il s'agit d'un rapport d'équipe plutôt que de votre contribution

Skills associés