Git pour un product manager : branche, commit et pull request
Git expliqué à un PM : l'incident qui m'y a fait venir, puis le commit, la branche et la pull request, avec les commandes à connaître.
Pendant quinze ans de produit, j'ai entendu « commit », « merge » et « pull request » des centaines de fois, sur des dizaines de projets menés avec des devs. Je comprenais à peu près ce que ça faisait, mais je rangeais Git parmi les outils de dev pour des problèmes de dev. Ça a changé le jour où j'ai demandé à Claude de réorganiser une trentaine de notes dans mon Obsidian.
J'utilise Obsidian pour tout mon travail de PM : comptes rendus de réunion, contextes de projet, specs en cours, décisions à moitié prises. J'y ai branché Claude, qui croise les projets, repère les incohérences et retrouve ce qui avait été dit trois mois plus tôt. Je lui ai demandé un tri d'initiatives terminées, avec quelques fusions et du nettoyage. Il l'a fait très vite. En réécrivant, il a aussi modifié du contenu : des décisions reformulées, des passages entiers résumés, et le plus important supprimé. Je ne pouvais ni savoir ce qui avait été touché, ni revenir à la version d'avant. J'ai passé le reste de la semaine à essayer de tout reconstruire.
C'est là que je me suis mis à Git sérieusement, et c'est devenu la première chose que j'installe avant de laisser un agent travailler sur des fichiers qui comptent. Cet article suit le chemin que j'ai fait : le commit pour travailler seul, puis la branche et la pull request pour travailler avec une équipe.
Git en local : un dossier versionné
Git est un programme que tu installes sur ta machine et à qui tu désignes un dossier à versionner. Il fonctionne en local, sans compte et sans connexion. Il ne surveille pas ce dossier en continu : c'est une commande qui lui demande d'enregistrer un état.
Il ne fait pas la différence entre du code et du texte : il versionne des fichiers. Des notes Obsidian, un dossier de specs, un prompt que tu peaufines, un script qu'une IA t'a écrit et que tu ne comprends qu'à moitié, Git suit tout ça ligne par ligne.
Le commit : un instantané de tes fichiers avant que l'IA y touche
Le premier mot à comprendre est commit. Un commit est un instantané de l'état de tes fichiers à un moment que tu choisis, avec un titre que tu écris toi-même, par exemple « Avant que l'IA touche aux notes ».
Git n'enregistre rien tout seul, contrairement à Google Docs qui sauvegarde en continu. C'est toi qui décides quand un état mérite d'entrer dans l'historique. Les commits conservent les versions enregistrées tant que tu ne réécris pas cet historique. Une modification jamais commitée n'a pas cette protection.
Faire un premier essai sans toucher à ton travail
Commence dans un dossier d'essai contenant une copie de deux ou trois fichiers sans information sensible. Ouvre le Terminal dans ce dossier et vérifie que Git est installé avec git --version. Si la commande n'est pas reconnue, suis l'installation officielle.
Dans ce dossier :
git init
git status
git add .
git diff --staged
git commit -m "Avant que l'IA touche aux notes"
git status
init prépare le dépôt une seule fois. Le premier status liste les fichiers à examiner, et diff --staged permet de relire ce que tu vas enregistrer. Après le commit, le dernier status doit indiquer qu'il n'y a plus de modification en attente. Si Git demande ton nom et ton adresse, configure ton identité avec la documentation de démarrage, puis relance le commit.
Tu peux maintenant laisser l'agent modifier ces copies, lancer git diff pour voir ses changements et décider de les garder ou de les annuler. Quand tu passeras à tes vrais fichiers, lis la section sur le .gitignore avant le premier git add ..
Je donne les commandes pour utiliser Git dans le Terminal, mais Claude, Codex ou un autre agent les connaît très bien. Il suffit de lui demander de commiter ou de pousser, et il remplit ce rôle.
Pourquoi deux commandes, add et commit
On peut voir ça comme préparer un carton pour La Poste. git add consiste à choisir ce que tu mets dedans, et le carton n'est pas encore fermé. git commit le ferme et le scelle, avec une description écrite dessus. Le titre est écrit pour toi : dans six mois, tu dois comprendre ce commit sans ouvrir les fichiers.
Cette étape intermédiaire existe parce que tu ne veux pas toujours tout enregistrer d'un coup. Si tu as modifié dix fichiers, cinq pour une page d'en-tête et cinq pour un pied de page, tu peux faire deux commits séparés :
git add components/Header.tsx app/header.css
git commit -m "Add Header component"
git add components/Footer.tsx app/footer.css
git commit -m "Add Footer component"
Si le pied de page pose problème, tu peux annuler ce seul commit, sous réserve qu'il n'y ait pas de dépendance entre les deux. Avec un seul gros commit, il faudrait sélectionner et retirer les changements du pied de page à l'intérieur.
Restaurer l'état du dernier commit
Une fois le commit fait, tu peux lâcher l'IA. Si elle part de travers :
git restore .
Lancée à la racine du dépôt, cette ligne remplace les fichiers suivis par leur version dans l'index. Si tu n'as rien ajouté avec git add depuis le dernier commit, tu retrouves donc ce commit. Elle efface les changements concernés sans corbeille : lis git status et git diff avant de la lancer. Si l'agent a déjà fait un git add ou un commit, arrête-toi à la vérification et choisis la bonne opération, décrite dans Vocabulaire Git pour vérifier un agent.
Le commit et le restore suffisent pour travailler seul sur ses propres fichiers. Sous Obsidian, le plugin obsidian-git peut faire les commits à intervalle régulier ; c'est celui que j'ai installé après cet incident.
La branche : une ligne de travail séparée
Dans une équipe, les branches suivent une convention. main ou master désigne souvent la branche principale ; cela ne garantit pas que son contenu soit déployé en production. Certaines équipes utilisent aussi develop, staging ou preprod. Avant de créer ta branche, demande sur laquelle le travail doit partir et dans laquelle il devra revenir.
Une branche est une ligne d'historique qui part d'un commit donné. Tu lui donnes un nom et tu y enregistres tes changements, pendant que la branche partagée continue d'avancer. L'image d'une copie de document aide à comprendre l'intention, mais Git ne duplique pas le dossier : quand tu changes de branche, il met à jour les fichiers dans le même dossier.
J'ai tiré ma première branche un jour où l'équipe était réduite et prise par des sujets structurels du produit. C'est évidemment le moment que le métier a choisi pour demander le redesign d'une page avant une échéance. Je n'ai pas voulu sortir un dev de son chantier pour ça : interrompre quelqu'un qui travaille sur un sujet lourd coûte plus cher que le temps de la tâche demandée, et protéger les devs de ce genre de demandes fait partie de mon travail. J'y suis donc allé moi-même avec l'IA. Un développeur senior de l'équipe a donné son accord à une condition : il relit tout avant que ça entre dans le produit.
git switch -c ma-nouvelle-feature
Mes nouveaux commits appartiennent alors à cette branche, et les devs peuvent continuer leur chantier. La séparation porte sur l'historique : elle n'empêche pas l'agent de modifier d'autres fichiers sur ma machine ou d'agir sur un service auquel il a accès.
Sur mes notes, le commit ne servait qu'à moi. Sur une branche d'équipe, chaque commit devient aussi un instantané que quelqu'un d'autre peut lire. Je commite dès qu'une étape du travail de Claude me semble bonne, ce qui me permet de revenir en arrière quand il part de travers sur la tâche suivante.
Tant que je reste sur ma machine, ma branche n'existe que chez moi. Pour la mettre en ligne, il y a une autre commande :
git remote -v
git push -u origin ma-nouvelle-feature
remote -v montre l'adresse du dépôt distant : vérifie que c'est la bonne avant d'envoyer quoi que ce soit. Ici, origin est le nom habituel de ce dépôt et ma-nouvelle-feature le nom choisi plus haut. -u relie les deux branches ; les envois suivants se font généralement avec git push.
Je pensais qu'en poussant ma branche, je demandais quelque chose à quelqu'un, qu'il y aurait une sonnette quelque part chez la personne qui devait relire. Il n'y a rien du tout. Le push met une copie de mon travail en ligne, la personne peut aller la voir si elle veut, et ça s'arrête là.
La pull request : faire relire ce qui a changé
Cette sonnette existe, et elle s'appelle une pull request (merge request sur GitLab). C'est un écran qui affiche ce qui a changé entre ma branche et develop, fichier par fichier et ligne par ligne. Cet affichage s'appelle un diff : les ajouts en vert, les suppressions en rouge. C'est ce que les devs lisent quand ils relisent quelqu'un, et ils ne lisent souvent que ça.
Sur GitHub ou GitLab, après le push, tu ouvres une pull request en choisissant ta branche et sa destination. Décris le changement, ce que tu as vérifié et ce qui demande une relecture, puis désigne le relecteur avec les fonctions prévues par l'équipe. Le push peut déclencher des tests automatiques, mais il ne remplace pas cette demande de revue.
Le développeur a ouvert la mienne et l'a lue comme celle d'un collègue. Il a laissé ses commentaires directement sur les lignes concernées. Je suis retourné travailler avec l'IA, j'ai commité de nouveau puis poussé les changements, le diff s'est mis à jour, et il a validé la fusion. Ma branche a ensuite rejoint develop.
Pour un PM, savoir lire un diff aide à voir ce qu'un agent a vraiment changé. Ça ne remplace pas la relecture d'un dev, qui sait ce qu'une modification peut casser ailleurs.
Git et GitHub : ce qui reste local, ce qui part en ligne
Git, c'est le mécanisme qui tourne en local, avec les instantanés, les branches et l'historique. Il est gratuit et open source. GitHub et GitLab sont des sites web où tu déposes tout ça pour que d'autres y accèdent. Ton dossier y devient une page avec une adresse, qu'on appelle un repository, ou repo.
Ce qu'il ne faut pas pousser
Sur un dépôt public, tout ce que tu envoies est lisible par n'importe qui. Fais très attention aux fichiers qui contiennent du contexte d'entreprise, des comptes rendus, des mots de passe, des tokens de connexion ou des clés d'API.
Un dépôt peut être privé, et le mien l'est, mais je réfléchis quand même à deux fois avant d'y mettre quelque chose qui parle du travail. Un dépôt privé ne règle pas la question de la confidentialité.
Trois réflexes à garder :
- Ne commite jamais de secrets. Mets-les dans un fichier comme
.env.local, et liste ce fichier dans le.gitignore, ce fichier que tu crées à la main et où tu écris ce que Git ne doit jamais suivre. Si un outil a généré ce fichier pour toi, ouvre-le et vérifie ses règles avant de t'y fier. - Ne commite pas
node_modules/, ces milliers de fichiers que le projet télécharge lui-même. Ajoute aussi ce dossier au.gitignores'il n'y figure pas. - Évite
git push --force, qui écrase l'historique en ligne, sauf si tu sais exactement ce que tu fais.
Le .gitignore écarte seulement les fichiers que Git ne suit pas encore : un fichier déjà ajouté à l'index ne devient pas ignoré par magie. Un secret qui est déjà passé dans un commit reste dans l'historique, même si tu l'ajoutes ensuite au .gitignore.
Explorer un dépôt et le cloner
Prends un projet public, par exemple n8n. La liste des fichiers montre l'état d'une branche du dépôt. Le sélecteur de branche permet d'en choisir une autre et d'explorer les lignes de travail du projet. L'onglet des pull requests liste les demandes de fusion qui attendent une relecture, et tu peux parcourir tout l'historique du projet. Le README, sous la liste des fichiers, est le document que l'auteur écrit pour expliquer à quoi sert son projet : c'est la première chose à lire pour savoir si ça peut t'être utile.
Quand un projet me donne envie de l'essayer, je le télécharge sur mon Mac :
git clone <adresse-du-dépôt>
GitHub est devenu pour moi un terrain de jeu plutôt qu'un site de dev intimidant. Des gens y publient des skills, de petits outils et des configurations entières, en libre accès. Je passe une partie de mes soirées à fouiller des dépôts qui font presque ce dont j'ai besoin, et que j'adapte pour mon usage.
Ce que Git ne règle pas
Le réflexe de commiter au bon moment ne vient pas tout seul. Les premières semaines, j'oubliais une fois sur deux, et c'est justement dans ces cas-là que ça cassait. Maintenant ça se fait tout seul, mais il a fallu l'installer.
git restore . ne ramène que les modifications de fichiers que Git suivait déjà. Un fichier créé par l'agent ne disparaît pas, il faut le repérer et le supprimer toi-même. Git ne remplace pas non plus une sauvegarde complète de ta machine : il garde l'historique des fichiers qu'il suit, et rien d'autre.
Et fouiller du code qu'on ne maîtrise pas entièrement a une limite : adapter un dépôt sans comprendre ce qu'on adapte reste un pari.
Pour aller plus loin, Learn Git Branching propose un terminal interactif pour s'exercer sur les branches. Ce que j'ai décrit ici n'est qu'un point de départ, mais la plupart de ce que je bricole avec l'IA aujourd'hui n'aurait pas commencé sans ce filet.
Repères techniques
Les comportements des commandes sont détaillés dans les manuels git init, git restore et git push. Pour protéger un vrai vault avant son premier commit, la suite est Versionner son vault Obsidian.
À lire ensuite
Recevoir la newsletter
Des tutos, des essais et des retours bruts sur ce que je construis. Le lien pour te désabonner est en bas de chaque édition.
L’inscription se termine sur Substack, dans un nouvel onglet.