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
- Analyse de code : Analyser la structure d'un dépôt GitHub, la stack technologique, les patterns architecturaux
- Adaptation au public : Générer du contenu pour les dirigeants, les architectes et les équipes techniques
- Visualisation d'architecture : Créer des diagrammes système, de flux de données et de déploiement
- Quantification d'impact : Extraire et présenter des métriques métier et des réalisations techniques
- 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
-
Demander la source du projet :
- URL/chemin du dépôt GitHub
- Documentation existante
- Notes du projet
-
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 ?
-
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 :
- Fournissez l'accès GitHub si possible (source d'information la plus riche)
- Partagez le « pourquoi » du projet (le contexte métier est important)
- Incluez toutes les métriques que vous avez suivies (même informelles)
- Mentionnez les défis que vous avez surmontés (ils font de bonnes histoires)
- Spécifiez votre public cible (la profondeur technique varie considérablement)
- 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