Des articles approfondis sur les technologies qui façonnent l'avenir.

Développeur vs architecte : qui gagne et quand

Développeur vs architecte ne se joue pas sur les titres mais sur qui décide de l'architecture. ADR, couplage et réversibilité pour votre promotion surprise.

Illustration en vue de dessus d'un bureau avec deux chemins de lumière divergents, l'un emmêlé et l'autre net.
La partie frappe est devenue rapide. La partie décision, c'est désormais le travail.

Le mois dernier, j'ai relu un diff où un assistant de code IA avait écrit une chaîne de blocs try/catch pour journaliser les nouvelles installations d'une extension de navigateur. Il essayait d'abord de récupérer l'e-mail de l'utilisateur. Si ça plantait, il revenait à un identifiant utilisateur. Si ça plantait aussi, il journalisait un haussement d'épaules : quelqu'un a installé, on ne sait pas qui. Le code fonctionnait. Il était pourtant faux, car la plateforme venait de restreindre les données d'identité qu'une extension peut demander. La question développeur vs architecte se cache dans des diffs comme celui-ci, et personne ne t'a envoyé le mémo sur le côté où tu te trouves désormais.

La bonne réponse n'était pas un meilleur bloc catch. Il fallait journaliser un horodatage, afficher un écran de bienvenue et dire au marketing qu'il n'aura pas l'e-mail au moment de l'installation, sauf si l'utilisateur le donne plus tard. Aucun modèle ne prend cette décision, parce qu'il ne connaît ni tes utilisateurs, ni les politiques de ta plateforme, ni les objectifs trimestriels de ton équipe marketing. Il fait exactement ce que tu demandes, à une vitesse effrayante. Ce qui signifie que la personne qui formule la demande, c'est toi, et que tu viens de devenir responsable de bien plus que du code. Félicitations pour la promotion. Désolé que personne ne te l'ait dit.

Il existe un contre-argument raisonnable : beaucoup d'ingénieurs diront que, dans chaque poste, on attendait d'eux qu'ils remettent en question les besoins et conçoivent le modèle de données pour le ticket qu'ils prenaient. C'est vrai, et dans les bonnes équipes, c'était toujours le travail. Mais quelque chose a réellement changé. La vitesse de frappe servait de frein naturel aux mauvaises idées. Quand un plan médiocre coûte trois jours d'implémentation, on y réfléchit d'abord. Quand il ne coûte que quatre-vingt-dix secondes, le plan est construit avant que quiconque ait eu le temps d'y penser. La friction qui forçait la réflexion architecturale a disparu, et rien ne l'a remplacée à part toi.

Développeur vs architecte : deux métiers différents

Voici la manière la plus claire que j'ai trouvée pour expliquer la différence. Un développeur prend un ticket et se demande comment. Un architecte regarde le même ticket et se demande s'il doit exister, et sous quelle forme. Le développeur optimise à l'intérieur des contraintes. L'architecte choisit les contraintes et, point crucial, assume les conséquences de ce choix pendant les deux prochaines années. Les deux sont de vraie ingénierie. Ce sont simplement deux métiers différents, qui échouent de manière différente. L'échec d'un développeur, c'est un bug. L'échec d'un architecte, c'est un modèle de données avec des tables redondantes sur lesquelles trois équipes ont déjà construit avant que quiconque s'en aperçoive.

Les outils de code IA se sont discrètement installés sur le siège du développeur. Ce sont les juniors les plus rapides qu'on ait jamais embauchés : infatigables, fluides, et totalement incapables de te dire que ton besoin est le vrai problème. Demande une journalisation des installations par utilisateur et tu obtiendras exactement cela, avec une cascade de solutions de repli pour qu'elle « fonctionne » même quand la plateforme n'en veut pas. Le modèle n'a aucun intérêt pour le budget de latence de ton application, ta politique de confidentialité ou ta rotation d'astreinte. Ce n'est pas un défaut de l'outil. C'est la description de poste du siège qu'il a pris, ce qui signifie que l'autre siège, celui qui dit non, reste vacant tant que tu ne t'y assois pas.

Alors, à quoi ressemble concrètement le fait de s'y asseoir ? Surtout trois choses. Bien connaître tes utilisateurs pour repérer quand un besoin contredit leurs intérêts. Bien connaître le couplage de ton système pour voir le rayon d'impact d'un changement d'une ligne. Et accepter d'avoir la conversation gênante avec la personne qui a écrit le besoin, avant que le code n'existe, et non dans un post-mortem. Rien de tout cela ne passe par des schémas en cases et flèches dans un wiki que personne ne lit. Tout cela repose sur un jugement qu'on ne peut pas déléguer à un outil qui ne résiste jamais.

Les décisions d'architecture que tu prends déjà

Tu n'as pas besoin du titre pour prendre des décisions d'architecture : tu les prends chaque semaine, dans des tickets ordinaires. Où vit la validation (client, API ou base de données). Si un appel est synchrone ou mis en file d'attente. Ce qui est journalisé et ce qui ne l'est délibérément pas. La forme d'une nouvelle table et ce à quoi elle référence via ses clés étrangères. Chacune de ces choses est un pari sur l'avenir, et chacune contraint ou permet les dix tickets suivants. Le diff de journalisation des installations ressemblait à une tâche de supervision. C'était en réalité une décision de confidentialité, de sécurité et de produit, déguisée en une ligne de code.

Voici le avant : ce que l'assistant a produit en implémentant fidèlement « journaliser qui a installé » :

async function logInstall(req, res) {
let identity = null;
try {
identity = { email: await getUserEmail(req) };
} catch {
try {
identity = { userId: await getUserId(req) };
} catch {
identity = { note: "install without identity" };
}
}
await db.installs.insert({ ...identity, at: new Date() });
res.redirect("/welcome");
}

Quinze lignes, trois modes de défaillance, et un schéma qui devra accueillir « e-mail, userId ou rien » pour toujours. Chaque solution de repli couple discrètement le chemin d'installation à une API d'identité : une panne d'un service soumis au consentement peut donc ralentir ou casser ton tunnel d'onboarding. Et la ligne « quelqu'un a installé, on ne sait pas qui » est analytiquement inutile, elle ne dit rien au marketing sur quoi agir. Le besoin a été satisfait à la lettre et trahi dans son esprit.

async function logInstall(req, res) {
await db.installs.insert({ at: new Date() });
res.redirect("/welcome");
// Email is collected on the welcome screen, with consent,
// posted asynchronously — and never gates the install path.
}

L'après tient en quatre lignes. Mais remarque ce qui a réellement changé : pas le code, le besoin. Le but n'a jamais été « capturer un e-mail », mais « mesurer les installations et relancer les nouveaux utilisateurs ». Un horodatage mesure les installations. L'écran de bienvenue, où l'utilisateur voit déjà une interface de consentement, est le bon endroit pour demander l'e-mail, de manière asynchrone, là où un échec ne coûte rien. Le geste de l'architecte n'a pas été d'écrire moins de code. Il a été de renégocier à quoi sert le code.

Une habitude qui vaut la peine d'être prise : avant tout changement non trivial, fais un inventaire de couplage de deux minutes. Demande-toi ce que ce code va appeler, ce qui va l'appeler, et ce qui casse quand chacun de ces éléments est lent, en panne ou déprécié. Dans la version avant, le chemin d'installation dépendait de deux services d'identité qu'il n'avait aucune raison de connaître. Dans la version après, il ne dépend que d'une table. Ce nombre de dépendances, et non le nombre de lignes ni la complexité cyclomatique, est celui qui prédit tes futurs incidents. On observe le même schéma dans la façon dont les assistants de code IA échouent de manières prévisibles et testables : le résultat est localement plausible et globalement couplé.

ADR vs connaissance tacite : quand chacune gagne

Un Architecture Decision Record est volontairement sobre : une page qui contient le contexte, la décision, les alternatives envisagées et les conséquences acceptées. C'est tout. Pas de cérémonie, pas de circuit de validation sauf si tu en veux un. Si les ADR sont passés de « agréable à avoir » à « indispensables » à l'ère de l'IA, c'est à cause de la mémoire. Le modèle n'en a aucune. Dans six mois, quelqu'un pointera un assistant vers le module d'installation, demandera une modification, et le raisonnement minutieux sur le consentement et la politique de la plateforme aura disparu, sauf s'il est écrit là où humains et outils peuvent le trouver. Un ADR dans le dépôt est lu par quiconque (ou quoi que ce soit) touche au code ensuite.

La connaissance tacite gagne réellement dans certaines situations, et prétendre le contraire est la raison pour laquelle les ADR ont une réputation bureaucratique. Une équipe de deux personnes qui construit un prototype dont la durée de vie se mesure en semaines n'a pas besoin de registres de décisions : ceux qui décident sont assis côte à côte, et le code sera de toute façon réécrit. Le contexte oral est plus rapide, plus riche et moins coûteux à cette échelle. Le problème, c'est que les équipes remarquent rarement le moment où elles franchissent le seuil : la première nouvelle recrue, la première équipe qui consomme ton API, le premier incident où « pourquoi a-t-on fait comme ça ? » reste sans réponse.

  • La décision est coûteuse à inverser : changements de schéma sur des données en production, contrats d'API publics, dépendance à un fournisseur.
  • La décision traverse une frontière d'équipe, si bien que les personnes concernées ne sont pas dans la pièce au moment où elle est prise.
  • Tu entends déjà la question future : « pourquoi diable l'a-t-on fait comme ça ? »
  • Un outil d'IA a généré l'implémentation, si bien qu'aucun humain n'a eu à formuler le raisonnement à voix haute.
  • Le compromis n'est pas évident : tu acceptes un coût réel (latence, surface de confidentialité, charge opérationnelle) délibérément.

Ce quatrième point est celui qui est nouveau. Quand un humain écrit du code, le raisonnement laisse des traces : messages de commit, discussions de PR, forme même de la tentative. Quand un assistant l'écrit, le raisonnement n'existe que brièvement dans ta tête, puis nulle part. L'ADR est l'artefact qui rend la revue possible, car il donne aux relecteurs quelque chose contre quoi vérifier le code. Sans lui, la revue se réduit à des remarques de style pendant que l'architecture dérive.

Carnet avec des schémas en cases et flèches tracés à la main et un stylo plume, sous une lumière douce de fenêtre.
Un ADR est une page qui survit longtemps après que le diff a été oublié.

Décisions réversibles vs irréversibles en conception de systèmes

La question la plus utile dans la boîte à outils de l'architecte est celle-ci : combien coûte-t-il de changer d'avis ? Certaines décisions sont des portes à double sens. Un format de log, la signature d'une fonction interne, une durée de vie de cache : on peut revenir dessus n'importe quel après-midi. D'autres sont des portes à sens unique. Un contrat d'API publique auquel des clients externes s'intègrent. Un schéma de base de données qui a accumulé six mois de données de production. Un parcours de consentement sur lequel repose désormais ta position juridique. Une fois la porte à sens unique franchie, le coût de la remise en question n'est pas un refactoring : c'est une migration, un calendrier de dépréciation et des excuses.

Identifie le type de porte avant de construire, car l'IA a rendu la construction bon marché alors que défaire reste aussi coûteux qu'avant. Laissé sans contrainte, un assistant concevra volontiers ton modèle de données à ta place, et le mode d'échec ressemble à des tables redondantes, des colonnes dupliquées et du code de migration empilé sur du code de migration, parce que chaque prompt ajoute une table au lieu de reconsidérer le modèle. Supprimer une table avec des données réelles que trois services lisent est l'une des opérations les plus pénibles de notre métier. La génération bon marché du schéma est précisément la raison pour laquelle le schéma mérite une réflexion coûteuse. Consacre ton budget de réflexion proportionnellement à l'irréversibilité, et non à la durée d'écriture du code : ce rapport s'est inversé.

Ma règle de travail : si une décision touche à des données que tu ne peux pas recréer, ou à une interface dont quelqu'un hors de ton équipe dépendra, elle reçoit un ADR et un second regard avant que l'implémentation ne commence. Tout le reste est livré puis itéré. Cette règle passe d'un projet solo à une équipe plateforme sans modification, et c'est la différence entre aller vite et aller vite dans une direction dont tu ne peux plus sortir.

Remettre en question les besoins comme un architecte

Le cœur inconfortable du métier d'architecte, c'est dire non à des gens qui ont plus d'autorité que toi. « Journaliser qui a installé » ressemblait à un besoin ; c'était en fait une solution imaginée à l'avance pour l'objectif « mesurer les installations et relancer les nouveaux utilisateurs ». Les architectes traduisent les solutions en objectifs, puis proposent un chemin moins coûteux vers ce but. Cette traduction est toute l'astuce, et aucun outil ne la fait, parce que la conception même de l'outil est de se conformer. Certains ingénieurs chargent leur assistant de contexte utilisateur et en tirent un jugement correct : cela aide à la marge, mais le modèle n'ira jamais en réunion dire au marketing que son e-mail de relance ne partira pas au moment de l'installation.

  1. Reformule l'objectif plutôt que la solution : « on veut mesurer les installations et atteindre les nouveaux utilisateurs ».
  2. Propose le chemin moins coûteux et ce qu'il apporte : la journalisation par horodatage mesure parfaitement les installations.
  3. Nomme ce que coûte réellement le chemin cher : friction de consentement, chemin d'installation couplé, lignes inutilisables par le marketing.
  4. Donne-leur un vrai choix : « si l'e-mail compte, on le demande sur l'écran de bienvenue, voici la version en une journée ».
  5. Consigne ce qui a été décidé, pour que la personne suivante ne reprenne pas le sujet à zéro.

Maintenant, l'objection honnête, parce qu'elle mérite d'être entendue : personne n'a été promu. L'histoire la plus probable, c'est que tu deviens le réceptacle de la responsabilité pour des décisions prises par un modèle, au même salaire, avec moins de la partie amusante. Je ne pense pas que ce soit faux, et j'y vois une raison de prendre l'habitude de la documentation au sérieux plutôt que de la sauter. Une trace d'ADR est aussi une trace écrite. Être l'humain qui a décidé ne devient un risque que lorsqu'on ne peut pas montrer son raisonnement. La personne qui a écrit « nous avons choisi l'horodatage plutôt que la capture d'e-mail parce que la plateforme restreint les données d'identité » est couverte. Celle qui a fusionné tout ce que l'assistant a produit ne l'est pas.

Développeur vs architecte : quand chacun gagne

Ce n'est pas un classement, c'est un changement de mode, et la compétence consiste à savoir quel mode réclame le travail qui est devant toi. Quelques cas concrets tirés de mon propre backlog :

  • Correction de bug bien spécifiée, rayon d'impact connu : le mode développeur gagne. Reproduire, corriger, tester, livrer. Réfléchir en mode architecte ici, c'est de la procrastination en costume.
  • Prototype qui valide une demande : mode développeur. Le code sera réécrit s'il marche et supprimé sinon. Des ADR pour un jetable, c'est du gaspillage.
  • Fonctionnalité nouvelle à partir de zéro, besoins flous : mode architecte d'abord, ne serait-ce qu'une heure. Le flou est l'endroit où l'élan généré par l'IA fait le plus de dégâts.
  • Tout ce qui touche à l'argent, à l'identité ou au consentement : mode architecte, sans exception. L'asymétrie de coût entre construire et défaire y est à son pire.
  • Changements de schéma sur des données en production ou changements d'API publique : mode architecte avec un ADR, selon la règle de réversibilité.
  • Équipe de deux personnes, base de code de moins de six mois : mode développeur avec un fichier de notes vivant. Une cérémonie complète n'apporte rien pour l'instant.
  • Domaine réglementé ou plusieurs équipes consommatrices : mode architecte avec des registres, car le « pourquoi » sera demandé par des auditeurs et des inconnus, pas par des amis.

L'échec, dans les deux sens, c'est de rester dans un seul mode. Les développeurs qui ne changent jamais de mode livrent des implémentations élégantes de la mauvaise chose. Les architectes qui ne redescendent jamais produisent des schémas pour des systèmes qui n'existent pas. Les personnes que je serais le moins prêt à perdre dans une équipe sont celles qui font les deux dans le même après-midi : débattre du modèle de données à 10 h, puis corriger l'off-by-one à 14 h sans se plaindre que c'est en dessous d'elles. Si tu construis ton processus de revue autour des sorties de l'IA, il vaut la peine de lire comment les outils de code agentiques structurent les boucles, le contexte et les permissions, car le changement de mode doit se produire à l'intérieur de cette boucle, et non après.

L'IA construira volontairement la mauvaise chose à grande vitesse, pour toujours. Le travail de l'architecte est de décider quelle est la bonne chose, et de noter pourquoi avant que le raisonnement ne s'évapore.

Plan technique avec des lignes de connexion lumineuses entre des formes dessinées, déployé à côté d'un ordinateur portable.
L'architecture consiste à décider quelles lignes ont le droit d'exister avant que quiconque ne les trace.

La recommandation : accepte la promotion

Voici ma position, et ce n'est pas du « ça dépend » : passe par défaut en mode architecte pour tout ce qui touche à ton modèle de données, à un contrat externe ou à ta posture de sécurité, et reste en mode développeur pour tout ce qui est contenu. La répartition ne sera pas 50/50 : pour la plupart des ingénieurs, c'est 20 % d'architecture et 80 % de construction, comme toujours. Ce qui a changé, c'est que la construction est devenue rapide, et que le coût de sauter les 20 % a augmenté exactement du facteur de vitesse. Plus tu délègues la frappe, plus ta valeur se concentre dans la partie que tu ne peux pas déléguer.

Le kit de départ tient en trois habitudes, que tu peux toutes mettre en place cette semaine. D'abord, ajoute un modèle d'ADR dans ton dépôt : contexte, décision, alternatives, conséquences, une demi-page suffit, et rédige-en un la prochaine fois que tu acceptes un vrai compromis. Ensuite, ajoute un inventaire de couplage de deux minutes à chaque epic : qu'est-ce que cela appelle, qui l'appelle, qu'est-ce qui casse quand ces appels échouent. Enfin, mets la question de réversibilité dans ton modèle de ticket : « si c'est faux, combien coûte un changement d'avis ? » Si la réponse est « une migration et des excuses », ralentis. Si c'est « un après-midi », ne ralentis pas.

Le métier de codeur ne disparaît pas, c'est le métier de frappe qui disparaît. Ces deux choses n'ont jamais été la même chose, et les personnes qui paniquent en silence sont celles dont le rôle s'était discrètement réduit à traduire des tickets en syntaxe. Si tu lis des diffs en te demandant « pourquoi ceci est-il couplé à une API d'identité ? », tu faisais déjà le travail de l'architecte. Le seul vrai changement, c'est qu'il est désormais officiel, documenté et à toi. Accepte la promotion.