Agents IA vs développeurs : 5 différences

# Agents IA en développement : différences clés avec les développeurs humains et leur impact

Un agent basé sur un LLM génère la documentation architecturale d’un système Java legacy comportant 17 modules non documentés. Le résultat : des diagrammes de dépendances détaillés, des descriptions d’interfaces et des annotations de composants. Le document imite une spécification d’une équipe mature. Mais dans les zones avec des contournements historiques — comme une couche proxy au lieu de files de messages —, l’agent la présente comme une architecture standard, inventant une logique inexistante sans mise en garde.

Un développeur humain s’arrêterait pour demander des précisions à l’auteur original. L’agent ne travaille qu’avec le code visible, comblant les explications sans noter ses hypothèses. Plus la sortie moyenne est précise, plus il est difficile de repérer les erreurs.

Cinq différences fondamentales entre agents et développeurs

Absence de mémoire de projet

Les agents traitent les tâches de manière isolée, sans contexte accumulé. Dans un projet de comptabilité de chantier (rapports de chefs d’équipe hors ligne), les conflits de synchronisation se résolvent en faveur du serveur à cause d’anciens bugs de doublons. Un développeur se souvient de la migration avec un index unique. L’agent a besoin que cet historique soit fourni dans les documents de contexte.

Pour les utilitaires cadastraux (GKN/EGRN), l’analyse conjointe des formats a pris une semaine : différences de champs, attributs obligatoires. Sans cela, l’agent produit un code cohérent mais inutilisable.

Solution : Maintenir des fichiers de contexte avec les décisions architecturales et les connaissances métier.

Respect littéral des spécifications

Tâche : Dialogue pour sélection de version en cas de conflit de synchronisation. L’agent écrit un composant React pour un seul champ. En production, il plante sur les conflits multi-champs (date, volume, commentaire) — les autres modifications sont perdues.

Un développeur clarifie les ambiguïtés : un seul dialogue ou par champ, scénarios hors ligne. L’agent ignore les modèles du monde réel.

// Exemple : code agent pour un champ

const ConflictDialog = ({ field, localValue, serverValue }) => (
  <Dialog>
    <p>{field}: {localValue} vs {serverValue}</p>
    <button>Local</button>
    <button>Server</button>
  </Dialog>
);

Contrôle qualité SENAR : Définir les objectifs, critères d’acceptation et scénarios négatifs en amont.

Multiplication des erreurs

Lors de la génération de 11 utilitaires cadastraux, une erreur dans la formule de coordonnées (décalage de plusieurs cm, critique pour les levés topographiques) s’est répétée dans trois d’entre eux. La rapidité de l’agent amplifie les succès comme les échecs.

• Vérifier plusieurs modules d’un ensemble, pas un seul.
• Les erreurs de motif se copient sur tous les fichiers similaires.

Ignorance de l’architecture à long terme

Tâche : Recherche de liens dans Sortula. L’agent fait une requête directe depuis le gestionnaire. Bien pour un script, mais un projet en croissance nécessite une couche de service pour le cache, le ranking, les tests A/B.

Après ajout d’une section architecture dans le contexte, l’agent utilise systématiquement cette couche.

Absence de responsabilité pour les effets en aval

Migration BD : Suppression en cascade sur chef d’équipe efface rapports et photos. Les tests ne la détectent pas — ils sont basés sur le schéma. L’agent oublie la tâche instantanément.

Les développeurs anticipent les bugs à un mois. Responsabilité du lead : Révisions manuelles des migrations.

Trois implications pour les processus d’ingénierie

• Points de double vérification : Les agents accélèrent mais exigent une validation aux étapes clés — architecture, migrations, cas limites.

• Contexte comme fondation : Stocker décisions architecturales, infos métier et historique dans le repo. SENAR standardise cela.

• Filtre humain : Les agents exécutent ; les humains stratègent. Initiative et responsabilité restent humaines.

Points clés à retenir

• Les agents excellent en analyse de code statique mais inventent des détails de logique invisible sans avertissement.
• L’exécution littérale exige des specs détaillées avec cas limites.
• Les erreurs se multiplient sur les séries de modules — vérifications au vol indispensables.
• Fournir les décisions architecturales en contexte dès le départ.
• La responsabilité production incombe pleinement au lead développeur.

— Editorial Team