Scénario pratique avancé · Scénario 2

Se familiariser rapidement avec le projet d’une nouvelle entreprise

Maîtrisez une méthode systématique pour comprendre rapidement de nouveaux projets, de la lecture du code à la compréhension du projet, de la prise en main rapide à la capitalisation des connaissances. Accélérez la lecture et la compréhension du code grâce aux outils d’IA, et intégrez-vous rapidement dans une nouvelle équipe.

Objectifs d'apprentissage

Maîtriser une méthode systématique pour comprendre rapidement de nouveaux projets
Capable d’utiliser des outils d’IA pour accélérer la lecture et la compréhension du code
Dispose de la capacité de capitaliser et de partager les connaissances
Comprendre le cadre de compréhension du projet (compréhension métier → compréhension de l’architecture → compréhension du code)

Méthodologie

Stratégie de lecture du code

De haut en bas (Top-Down)

  • • Scénarios d’application : besoin de comprendre rapidement l’architecture globale et les processus métier
  • • Ordre de lecture: README → documentation d’architecture → fichier d’entrée → modules principaux → implémentation spécifique
  • • Avantages：Établir rapidement une vision d’ensemble et comprendre la logique métier

Ascendant (Bottom-Up)

  • • Scénarios d’application: Nécessite de comprendre en profondeur une fonctionnalité ou un module spécifique
  • • Ordre de lecture: implémentation spécifique → interfaces de module → dépendances des modules → architecture globale
  • • Avantages：Comprendre en profondeur les détails de l’implémentation et maîtriser les aspects techniques

Applications des outils d’IA: utilisez Fast Context de Windsurf ou Cursor Agent pour comprendre rapidement la structure globale et les modules clés d’une grande base de code.

Cadre de compréhension du projet

1
Compréhension métier: Comprendre les objectifs métier, les besoins des utilisateurs, les processus métier et les règles métier
  • • Lire la documentation produit, la documentation des exigences et les user stories
  • • Comprendre les modèles métier et les modèles de données
  • • Utiliser des outils d’IA : NotebookLM pour organiser les documents métier
2
Compréhension de l’architecture：Comprendre l’architecture système, la découpe des modules, la pile technologique et les flux de données
  • • Lire les documents d’architecture et les documents techniques
  • • Comprendre les dépendances entre modules et les flux de données
  • • Utilisation d'outils d'IA : Windsurf analyse la structure du code, Cursor Agent génère des schémas d'architecture
3
Compréhension du code: Comprendre la structure du code, les implémentations clés, les modèles de conception et les bonnes pratiques
  • • Lire le code clé et comprendre la logique d’implémentation
  • • Comprendre le style de code et les modèles de conception
  • • Utiliser les outils d’IA : questions-réponses sur le code avec Cursor Agent, analyse de code avec Zread

Flux de démarrage rapide

Phase 1 : Lecture des documents (1 à 2 jours)

  • • Lire le README, les documents d’architecture et la documentation de l’API
  • • Comprendre les objectifs du projet, la pile technique et le processus de développement
  • • Utiliser des outils d’IA : NotebookLM pour organiser les documents, Fabric pour générer des résumés

Phase 2 : exploration du code (2 à 3 jours)

  • • Exécuter le projet et comprendre le flux de démarrage
  • • Explorer les modules clés et comprendre la structure du code
  • • Utiliser des outils IA : Windsurf pour comprendre rapidement, Cursor Agent pour les questions-réponses sur le code

Phase 3 : Développement de petites fonctionnalités (3 à 5 jours)

  • • Choisir une petite fonctionnalité à développer
  • • Comprendre le processus de développement, les conventions de code et les exigences de test
  • • Utiliser des outils d'IA : Cursor Agent pour l'assistance au développement et la revue de code

Phase 4 : optimisation du refactoring (en cours)

  • • Détecter les problèmes de code et proposer des améliorations
  • • Refactoriser le code pour améliorer sa qualité
  • • Utiliser des outils d’IA : optimisation du code avec Cursor Agent, recommandations de refactorisation

Méthodes d’accumulation des connaissances

Notes et documents

  • • Notes d’étude: consigner les concepts clés, les conceptions architecturales, les modèles de code
  • • Journal des problèmes：Consigner les problèmes rencontrés et les solutions
  • • Bonnes pratiques: résumer les meilleures pratiques et les patterns de conception du projet

Création de Skill/Pattern

  • • Cursor Skill：encapsuler les modèles de développement spécifiques au projet sous forme de Skill
  • • Fabric Pattern : encapsuler les schémas de code courants sous forme de Patterns
  • • Partage d’équipe: Les Skills et les Patterns peuvent être partagés et réutilisés au sein de l’équipe

Partage de connaissances

  • • Partage technique: partager au sein de l’équipe les enseignements tirés et les bonnes pratiques
  • • Mise à jour du document: Mettez à jour la documentation du projet et complétez les informations manquantes
  • • Revue de code: Apprendre et partager des connaissances grâce à la revue de code

Applications des outils d’IA

Utiliser Fast Context de Windsurf pour comprendre rapidement de grands dépôts de code

La technologie Fast Context de Windsurf peut analyser rapidement de grandes bases de code et comprendre la structure globale :

  • • Index rapide: indexer automatiquement l’ensemble de la base de code et construire une carte du code
  • • Recherche intelligente : recherche rapide du code et des fichiers pertinents
  • • Compréhension du contexte：Comprendre les dépendances et le flux de données entre le code
  • • Analyse de l'architecture: Analyser automatiquement l’architecture du système et la répartition des modules

Utiliser Cursor Agent pour l’exploration du code et les questions-réponses

Utilisez le mode Agent de Cursor pour comprendre le code via des questions-réponses :

Exemple de question :

  • • « Que fait cette fonction ? »
  • • « À quels autres modules ce module dépend-il ? »
  • • « Comment les données circulent-elles de l’API vers l’UI ? »
  • • « Qu’est-ce que ce modèle de conception ? Pourquoi est-il conçu ainsi ? »
  • • L’IA analyse le code et répond à vos questions
  • • Vous pouvez poser des questions approfondies et comprendre les détails de l’implémentation
  • • Générer des commentaires de code et de la documentation

Utilisez Zread pour analyser des dépôts GitHub

Zread peut analyser rapidement les dépôts GitHub et comprendre la structure du projet :

  • • Aperçu du dépôt：Comprendre rapidement la structure du projet, la pile technologique et les dépendances
  • • Analyse de code: Analyser la qualité du code, la complexité et les modèles de conception
  • • Historique des commits：comprendre l’historique de l’évolution du projet et les changements clés
  • • Identification des problèmes: identifier les problèmes potentiels et les pistes d’amélioration

Utiliser NotebookLM pour l’organisation des documents et l’extraction des connaissances

NotebookLM peut organiser les documents du projet et extraire les informations clés :

  • • Importation de documents: Importer README, documentation d’architecture, documentation API
  • • Extraction de connaissances: Extraire automatiquement les concepts clés, la conception de l’architecture et les interfaces API
  • • Système de questions-réponses: répondre aux questions en se basant sur le contenu du document
  • • Résumé des connaissances: générer un aperçu du projet et un graphe de connaissances

Utiliser Fabric pour générer des résumés de code

Utilisez les Patterns de Fabric pour générer automatiquement des résumés de code :

  • • Résumé de code: générer automatiquement des résumés des fonctions, modules et fichiers
  • • Document d’architecture：Générer une documentation d’architecture à partir du code
  • • Documentation API: Générer la documentation API à partir des commentaires de code
  • • Notes d’étude: Générer des notes d’étude et des résumés de connaissances

Cas pratique

Cas 1 : se familiariser rapidement avec un projet Monorepo

Caractéristiques du projet

  • • Structure de monorepo comprenant plusieurs packages et services
  • • Utiliser pnpm workspaces pour gérer les dépendances
  • • Base de code volumineuse avec des dépendances complexes entre modules

Étape 1 : utiliser Windsurf pour comprendre rapidement la structure (1 jour)

  • • Ouvrez Windsurf et chargez l’ensemble du Monorepo
  • • Utiliser Fast Context pour analyser la structure du projet
  • • Comprendre les dépendances entre les packages
  • • Identifier les packages principaux et les modules clés

Étape 2 : utilisez Cursor Agent pour explorer les modules clés (2 jours)

  • • Sélectionnez les packages principaux et utilisez Cursor Agent pour les questions-réponses sur le code
  • • Comprendre les responsabilités et les interfaces des modules
  • • Comprendre le flux de données et la chaîne d'appels
  • • Générer la documentation des modules et les schémas d’architecture

Étape 3 : développer une petite fonctionnalité (3 jours)

  • • Choisir une petite fonctionnalité à développer
  • • Comprendre le flux de développement et les conventions de code
  • • Utiliser Cursor Agent pour assister le développement
  • • Soumettre le code et effectuer une revue de code

Étape 4 : capitalisation des connaissances (continue)

  • • Créer un Cursor Skill pour encapsuler des modes de développement spécifiques au projet
  • • Mettre à jour la documentation du projet et compléter les informations manquantes
  • • Partager les apprentissages au sein de l’équipe

Cas 2 : se familiariser rapidement avec un système hérité

Caractéristiques du projet

  • • Systèmes hérités, qualité du code inégale
  • • La documentation est manquante ou incomplète
  • • La pile technologique est ancienne et nécessite de comprendre la conception historique

Étape 1 : utiliser Zread pour analyser le dépôt GitHub (une demi-journée)

  • • Utiliser Zread pour analyser la structure du dépôt
  • • Comprendre la pile technologique et les dépendances
  • • Consulter l’historique des commits pour comprendre l’évolution du projet
  • • Identifier les fichiers et modules clés

Étape 2 : utiliser NotebookLM pour organiser les documents (1 jour)

  • • Importer les documents existants et le README
  • • Utiliser NotebookLM pour extraire les informations clés
  • • Générer une vue d’ensemble du projet et un graphe de connaissances
  • • Questions-réponses basées sur le contenu du document

Étape 3 : utiliser Cursor Agent pour comprendre le code (2 à 3 jours)

  • • Sélectionner les modules clés et utiliser Cursor Agent pour les questions-réponses sur le code
  • • Comprendre la logique métier et les détails d’implémentation
  • • Identifier les problèmes de code et les pistes d'amélioration
  • • Générer des commentaires de code et de la documentation

Étape 4 : refactorisation et optimisation (en continu)

  • • Identifier les problèmes de code et proposer des améliorations de refactorisation
  • • Utiliser Cursor Agent pour aider au refactoring
  • • Mettre à jour la documentation et consigner le processus de refactoring
  • • Créer une documentation des meilleures pratiques

Liste de contrôle des acquis d’apprentissage

Maîtriser les stratégies de lecture de code (descendant vs ascendant) et choisir la stratégie appropriée selon la situation
Comprendre le cadre de compréhension de projet (compréhension métier → compréhension de l’architecture → compréhension du code) et être capable d’appréhender systématiquement de nouveaux projets.
Maîtrisez le flux de travail de prise en main rapide (lecture de la documentation → exploration du code → développement de petites fonctionnalités → optimisation par refactorisation)
Pouvoir comprendre rapidement de grandes bases de code grâce à Fast Context de Windsurf
Pouvoir utiliser Cursor Agent pour l’exploration de code et les questions-réponses
Être capable d’analyser des dépôts GitHub avec Zread
Capable d’utiliser NotebookLM et Fabric pour l’organisation des documents et l’extraction de connaissances
Avoir la capacité d’accumuler et de partager des connaissances, de créer des Skills/Patterns et de mettre à jour la documentation
Terminer au moins un cas pratique (projet Monorepo ou système hérité)