{
  "title": "Une Année avec Cursor : Comment Mon Workflow a Évolué d'Agent à Architecte",
  "excerpt": "Mon parcours avec Cursor reflète la maturation de l'outil lui-même : d'un simple agent à un partenaire architectural sophistiqué. Cet article détaille comment mon workflow a évolué à travers les mentions @, MCP, le Mode Plan et les commandes personnalisées.",
  "content_html": "<p>Cela fait plus d'un an que j'ai fait de Cursor mon IDE principal, et il est difficile de surestimer l'impact qu'il a eu sur mon travail. En tant qu'ingénieur en machine learning développant des plateformes d'IA conversationnelle chez Dylog et expérimentant avec des infrastructures agentiques sur mes projets personnels, j'ai vécu l'évolution du développement natif par l'IA. Mon parcours avec Cursor reflète la maturation de l'outil lui-même : d'un simple agent à un partenaire architectural sophistiqué.</p><p>Cet article est une réflexion sur ce parcours, détaillant comment mon workflow a évolué et comment j'en suis venu à m'appuyer sur une combinaison puissante de Mode Plan, de commandes personnalisées et d'ingénierie du contexte pour construire plus vite, plus intelligemment et avec plus de clarté.</p><h2>Phase 1 : L'Agent Prend le Volant</h2><p>Quand j'ai commencé, mon utilisation était simple. Je traitais Cursor comme un autocomplétion survitaminé. J'écrivais un commentaire, j'appuyais sur <code>Cmd+K</code>, et je laissais l'agent générer le code. C'était magique, mais c'était aussi une boîte noire. J'étais passager, et l'agent conduisait.</p><p>Puis sont venues les <strong>mentions @</strong>. C'était ma première expérience de donner à l'agent un contexte réel. Au lieu d'espérer qu'il comprenne ma base de code, je pouvais lui dire explicitement quoi regarder :</p><ul><li><code>@file</code> pour référencer un fichier spécifique</li><li><code>@folder</code> pour inclure un répertoire entier</li><li><code>@codebase</code> pour lui permettre de chercher dans tout le projet</li><li><code>@web</code> pour intégrer de la documentation externe</li><li><code>@docs</code> pour référencer la documentation officielle des bibliothèques</li></ul><p>C'était un bond en avant considérable. Soudainement, l'agent ne devinait plus ; il travaillait avec le même contexte que moi. Je pouvais dire « refactorise cette fonction pour correspondre au pattern dans <code>@file:utils/helpers.ts</code> » et il comprenait vraiment.</p><img src=\"/assets/images/cursor-at-mentions.png\" alt=\"Cursor @ mention context\" class=\"post-img\" width=\"1639\" height=\"935\" /><span class=\"post-img-caption\">Le menu déroulant des mentions @ dans Cursor, affichant les options de contexte comme @file, @folder, @codebase, @web et @docs qui permettent un contrôle explicite du contexte</span><p>Mais même avec un meilleur contexte, je me retrouvais souvent dans un cycle de génération, débogage et régénération. L'agent manquait de vision architecturale pour les tâches plus importantes.</p><h2>Phase 2 : MCP Change Tout</h2><p>L'introduction du <strong>Model Context Protocol (MCP)</strong> a marqué le moment où les choses sont devenues sérieuses. MCP m'a permis de connecter Cursor à des outils et sources de données externes, transformant l'agent d'un générateur de code en un véritable assistant ayant accès à l'ensemble de mon workflow.</p><p>J'ai commencé à intégrer des MCPs pour :</p><ul><li><strong>GitHub</strong> pour intégrer directement les issues et PR dans le contexte</li><li><strong>Linear</strong> pour l'intégration de la gestion des tâches</li><li><strong>Slack</strong> pour le contexte de communication d'équipe</li><li><strong>MCPs personnalisés</strong> pour les APIs et bases de données internes</li></ul><p>Avec MCP, je pouvais dire « implémente la fonctionnalité décrite dans l'issue Linear #234 » et l'agent récupérait l'issue, comprenait les exigences et commençait à construire. Il ne s'agissait plus seulement de code ; il s'agissait de connecter les points à travers tout mon écosystème de développement.</p><img src=\"/assets/images/cursor-mcp-integrations.png\" alt=\"MCP integrations in Cursor\" class=\"post-img\" width=\"1639\" height=\"935\" /><span class=\"post-img-caption\">Panneau de configuration MCP affichant les intégrations connectées comme GitHub, Linear, Slack et des serveurs personnalisés qui étendent les capacités de Cursor à travers l'écosystème de développement</span><h2>Phase 3 : L'Essor du Planificateur</h2><p>L'introduction du <strong>Mode Plan</strong> a été le prochain tournant décisif. C'était la première fois que j'avais l'impression de collaborer avec l'IA, plutôt que de simplement lui déléguer des tâches. Inspiré par les workflows de développeurs comme Ray Fernando, j'ai commencé à utiliser un processus en deux étapes :</p><ol><li><strong>Planifier avec Opus :</strong> J'utilisais un modèle puissant comme Claude Opus pour générer un plan d'implémentation détaillé, étape par étape. Je lui donnais l'objectif de haut niveau, et il le décomposait en une série de tâches concrètes, avec les noms de fichiers, les signatures de fonctions et la logique.</li><li><strong>Exécuter avec Sonnet/GPT :</strong> Je remettais ensuite ce plan à un modèle plus rapide et moins coûteux comme Sonnet ou GPT-5.2 pour exécuter chaque étape. Le modèle moins cher n'avait pas besoin d'être un architecte brillant ; il devait juste être un constructeur diligent.</li></ol><p>Ce workflow représentait une amélioration massive. Il séparait le « quoi » du « comment », et il me donnait un artefact révisable — le plan — que je pouvais modifier et approuver avant qu'une seule ligne de code soit écrite. Cela permettait aussi d'économiser énormément sur les tokens.</p><img src=\"/assets/images/cursor-plan-mode.png\" alt=\"Cursor Plan Mode workflow\" class=\"post-img\" width=\"1639\" height=\"935\" /><span class=\"post-img-caption\">Une vue partagée montrant un plan d'implémentation détaillé dans un fichier <code>.cursor/plans/</code> à gauche, et le code généré correspondant à droite, illustrant la séparation de l'architecture et de l'exécution</span><h2>Phase 4 : L'Architecte Émerge (Commandes + Planification)</h2><p>C'est là où j'en suis aujourd'hui. Bien que le Mode Plan reste central dans mon workflow, j'y ai superposé un ensemble de <strong>commandes personnalisées</strong> et de <strong>règles</strong> pour affiner le processus et intégrer mes principes architecturaux directement dans l'IDE.</p><h3>Ma Configuration Actuelle</h3><p><strong>Règles (<code>.cursorrules</code>) :</strong> J'ai un ensemble de règles qui définissent mes standards de codage, mes patterns préférés et mes contraintes architecturales. L'agent les lit avant chaque tâche, assurant la cohérence à travers la base de code.</p><p><strong>Commandes Personnalisées :</strong> J'ai construit des commandes qui encapsulent mes workflows les plus courants :</p><ul><li><code>/plan</code> - Génère un plan d'implémentation détaillé avec Opus</li><li><code>/refactor</code> - Prend un fichier et le refactorise selon des instructions</li><li><code>/test</code> - Génère une suite de tests pour une fonction donnée</li><li><code>/review</code> - Révise le code par rapport à mes règles et suggère des améliorations</li></ul><p><strong>Messages en File d'Attente :</strong> J'utilise <code>Ctrl+Enter</code> pour mettre en file d'attente des instructions de suivi pendant que l'agent travaille. Cela me permet d'anticiper et de maintenir l'élan sans interrompre la tâche en cours.</p><img src=\"/assets/images/cursor-custom-commands.png\" alt=\"Cursor custom commands and rules\" class=\"post-img\" width=\"1639\" height=\"935\" /><span class=\"post-img-caption\">La palette de commandes Cursor affichant les commandes personnalisées comme /plan, /refactor, /test et /review, aux côtés d'un fichier <code>.cursorrules</code> qui définit les standards de codage et les contraintes architecturales</span><h2>L'Évolution en un Coup d'Œil</h2><table><thead><tr><th>Phase</th><th>Fonctionnalité Clé</th><th>Ce qui a Changé</th></tr></thead><tbody><tr><td>1</td><td>Agent Mode + Mentions @</td><td>Le contexte est devenu explicite, non deviné</td></tr><tr><td>2</td><td>Intégration MCP</td><td>Les outils et données externes sont devenus accessibles</td></tr><tr><td>3</td><td>Mode Plan</td><td>L'architecture a été séparée de l'exécution</td></tr><tr><td>4</td><td>Commandes + Règles</td><td>Les workflows sont devenus reproductibles et personnalisés</td></tr></tbody></table><h2>Pourquoi C'est Important</h2><p>Cette évolution d'agent à architecte est bien plus qu'un simple hack de productivité personnelle. C'est un aperçu de l'avenir du développement logiciel. Nous passons d'un monde où nous écrivons du code à un monde où nous <strong>décrivons des systèmes</strong>. Notre rôle est d'être l'architecte, de définir le plan directeur, et de laisser les agents faire la construction.</p><p>Cursor, plus que tout autre outil que j'ai utilisé, comprend ce changement. Il ne s'agit pas seulement de générer du code ; il s'agit de gérer la complexité, de maintenir le contexte et de donner aux développeurs l'effet de levier nécessaire pour construire à une échelle qui était auparavant inimaginable.</p><p>Si vous utilisez encore l'IA comme un simple générateur de code, je vous encourage à explorer les mentions @, MCP, le Mode Plan et les commandes personnalisées. C'est un voyage qui vous transformera d'un développeur qui utilise l'IA en un architecte qui la dirige.</p>",
  "source_hash": "sha256:28f88bf2defdd63f9461e06dc7a0d3d6066e0a7aec0f54068b058ced00879783",
  "model": "claude-sonnet-4-6",
  "generated_at": "2026-05-08T19:46:35.143556+00:00"
}