Moins de code pour le même travail.

Le problème

Un agent qui travaille sur un vrai projet ne voit pas tout le projet. Il voit ce qu'il cherche, et il cherche ce qui lui vient à l'esprit. Quand la fonction dont il a besoin se trouve dans un autre module sous un autre nom, il la réécrit. Quand une tâche admet une solution courte et une longue, rien ne le pousse vers la courte.

La réponse habituelle, ce sont des règles écrites : un CLAUDE.md, une skill, le prompt système. Elles aident, mais ce sont des conseils. Le modèle peut ne pas les charger, les oublier en cours de tour ou décider qu'elles ne s'appliquent pas. Nous ne pouvons pas toucher aux poids du modèle, mais nous pouvons contrôler trois choses : ce que le modèle voit, ce qu'il a le droit de faire et quand il a le droit de terminer. Sens utilise les trois à la fois.

Le circuit

Claude Code accepte des hooks sous forme de callbacks dans son propre protocole de flux. Sens en traite cinq dans son processus, avec un invariant : une modification naît non approuvée. Seuls un audit réussi ou une personne l'approuvent.

1. 01

   Vous envoyez un message

   UserPromptSubmit

   Sens prend un point de contrôle du projet et donne à Claude jusqu'à huit éléments qui existent déjà et concernent la demande, chacun avec sa signature, son fichier:ligne et son nombre d'utilisations.

2. 02

   Avant chaque écriture

   PreToolUse · Write, Edit

   Sens reconstruit en mémoire le fichier qui en résulterait et lui applique les règles de modification. Il peut refuser l'écriture avant qu'elle n'ait lieu, avec la raison et le code à réutiliser.

3. 03

   Avant chaque commande

   PreToolUse · Bash, PowerShell

   Sens protège ses propres chemins et la configuration, et traite git commit et git push comme la fin d'un tour : rien de non approuvé n'est validé.

4. 04

   Après chaque outil

   PostToolUse

   Quel que soit l'outil, Sens repère les fichiers modifiés sur le disque et leur applique les mêmes règles.

5. 05

   À la fin du tour

   Stop · SubagentStop

   Sens audite tout le diff depuis le dernier point approuvé : règles de modification, code orphelin et, si du code a changé, le relecteur. En cas de constat bloquant, Claude continue ; après trois tours, le tour est retenu pour vous.

Rien à contourner

Avant de construire quoi que ce soit, nous avons vérifié en direct que le mécanisme résiste à un modèle qui tente de s'y soustraire : un disableAllHooks écrit en cours de session n'arrête pas les callbacks, les sous-agents y passent, et un git commit refusé laisse le dépôt tel qu'il était. Chaque raccourci a de quoi le fermer :

La limite est explicite : le circuit ferme les erreurs et les raccourcis d'un modèle, pas ceux d'un programme hostile qui tournerait sur la même machine.

Résultats

Les tâches isolées partent d'un projet propre, et le tort d'un agent qui ne réutilise pas n'est pas dans une tâche, mais dans la somme. Horizonte mesure la somme : une ligne de commande en TypeScript pour les dépenses du foyer qui commence à 88 lignes, et 30 demandes produit dans un ordre fixe, chacune sur le résultat de la précédente. Huit concepts dont plusieurs tâches ont besoin sans le dire y sont semés : dates, mois et semaines, totaux, accents, montants, CSV, options de commande. La première fois, l'agent les écrit ; ensuite, le bon choix est de réutiliser ce qu'il a écrit.

Le critère a été fixé par écrit avant la mesure : Sens laisse le projet plus petit seulement si les trois séquences avec Sens finissent sous les trois séquences sans lui. Sans différence réelle, cela arrive par hasard une fois sur vingt.

D'où vient la différence

Pas de moins copier. Aucun des deux bras n'a vraiment copié de blocs : jscpd a trouvé 0, 6 et 6 lignes dupliquées sans Sens et aucune avec, et les sondes de chaque concept semé donnent des chiffres identiques ou presque dans les deux. La différence vient du fait d'écrire moins pour la même chose. Avec Sens, l'agent écrit plus de fonctions, et plus courtes : une médiane de 28 contre 20. Dans le pilote, pour lire les descriptions entre guillemets du CSV, l'agent sans Sens a écrit un lecteur CSV complet, 99 lignes ; avec Sens, il a vu que la description était le dernier champ et deux fonctions d'une ligne lui ont suffi.

Tokens au total : 33,7M sans Sens · 27,7M avec Sens

Tâches isolées

Douze tâches dans trois langages sur deux vrais projets, Sens lui-même en TypeScript et en Rust et la bibliothèque Python click à des commits fixés, chacune validée par des tests cachés et une solution de référence. Trois conditions avec le même modèle : Claude Code seul (C0), le Canon en texte dans le prompt système sans circuit (C1), et Sens complet (C2).

Le texte seul obtient déjà une bonne part de la réutilisation quand la fonction est proche. Il n'obtient pas les cas où elle est loin et nommée autrement, titleOf, 1 sur 3 contre 6 sur 6, ni la tâche qui exige de corriger la cause commune plutôt qu'un seul chemin, py-progress-final, 0 sur 3 contre 3 sur 6. Dans les tâches isolées, les lignes de code sont du bruit : C2 écrit environ deux lignes de moins par tâche, mais l'intervalle touche zéro. C'est pour cette variabilité qu'existe Horizonte.

Les règles

Les règles de modification sont déterministes. Elles comparent les empreintes de chaque fonction, méthode et classe, et de chaque suite de quatre instructions, calculées par un index en Rust sur tree-sitter qui garde le projet en mémoire : le dépôt de Sens lui-même, 556 fichiers et 10 000 unités, s'indexe en moins de deux secondes, et chercher les copies d'une unité prend de l'ordre d'une microseconde. Les copies exactes et celles aux noms changés correspondent par hachage ; celles qui ajoutent ou retirent des lignes, par MinHash sur des tokens normalisés. Le seuil de 0,80 et le plancher de 80 tokens pour bloquer viennent de la modification de 400 fonctions d'un vrai dépôt et de la relecture à la main de chaque correspondance.

Les règles ne voient pas les erreurs de jugement. Pour celles-ci, quand un tour qui a touché du code passe les règles, un relecteur lit le diff avec les candidats trouvés par l'index. Sa sortie n'est pas prise sur parole : tout constat dont la citation n'apparaît pas littéralement dans le diff est écarté, et seule une confiance élevée bloque.

Ce qui n'a pas marché

Chaque blocage du circuit a été relu à la main, avec son diff et sa conversation. Les blocages sont rares, sept sur 228 exécutions de Sens, si bien qu'un seul blocage injuste pèse lourd. Nous visions moins de 5 % de blocages injustes et ne l'avons atteint dans aucun lot comportant des blocages ; chaque injustice avait une cause précise, désormais corrigée par un test qui la fixe.

Une mauvaise liste est pire que pas de liste. La première version de Sens suggérait huit symboles sans rapport avec la demande ; le modèle les a lus, n'a pas cherché plus loin et a réécrit à la main la fonction des accents les trois fois, alors que le Canon en texte, sans liste, l'a importée les trois fois. Avec la recherche refaite, la fonction apparaît parmi les suggestions et Sens l'utilise à chaque fois, sans rien bloquer.

Limites

• Un seul modèle. Toutes les exécutions ont utilisé Claude Sonnet 5.5 en effort moyen.
• Un projet, un langage, trois séquences par bras. Le critère de confirmation est exigeant, toutes sous toutes, mais l'ampleur de l'effet a un intervalle large.
• Nous avons écrit les tâches. Pour qu'elles ne biaisent pas le résultat, les tâches, leurs tests et la référence ont été enregistrés avant la première exécution, et le critère fixé avant la mesure.
• Pas d'outils MCP dans le banc. Sens a été mesuré sans les requêtes à l'index qu'offre l'application : le résultat est une borne inférieure.
• Dix-neuf langages pas encore mesurés au banc. Vue, Svelte et les langages ajoutés ensuite sont couverts par des tests, pas par des exécutions de l'agent.
• Les tokens incluent les lectures de cache. Ils mesurent le volume de travail, pas le coût exact.
• Le relecteur manque de précision. Sur les sept remarques et blocages relus qui venaient de lui, cinq étaient erronés. Ses remarques n'arrêtent rien, mais elles parviennent au modèle et à vous.
• Conventions non écrites. Sens ne connaît pas les règles implicites d'un projet, comme garder les imports lourds à l'intérieur d'une fonction.

Méthode

456 exécutions de l'agent en cinq lots : un pilote, trois tâches difficiles sur Sens lui-même, douze tâches de calibration, puis le pilote et la confirmation d'Horizonte. Toutes les conditions ont utilisé claude-sonnet-5-5 en effort moyen, avec Claude Code en --safe-mode pour que la configuration de l'auteur ne s'infiltre pas dans les exécutions. Chaque tâche a été validée avant usage : au départ, les tests du projet passent et les tests cachés échouent, et avec la référence appliquée tous passent. Une régression doit échouer deux fois de suite pour compter. Les différences sont des médianes avec un intervalle bootstrap à 95 %, 10 000 rééchantillonnages à graine fixe ; le critère d'Horizonte est un test exact de permutation.

Le reproduire

sens-bench validate --tasks bench/tasks
sens-bench run --tasks bench/tasks --condition C0,C1,C2 --reps 3 --out bench/results/<batch>
sens-bench sequence validate bench/sequences/cuentas
sens-bench sequence run bench/sequences/cuentas --condition C0,C2 --reps 3 --out bench/results/<batch>
sens-bench sequence report bench/results/<batch>

Les données de chaque exécution, son diff et les tâches se trouvent dans le dossier bench/ du dépôt de Sens.

Le Canon

Le texte que reçoit chaque session, mot pour mot, en anglais comme le lit le modèle. C'est le circuit qui en fait plus qu'un conseil.

# Sens Canon v1.1

You are working inside Sens. Sens indexes this project and judges every change you make before your turn can end. What Sens tells you about this project, in its messages, denials and reviews, is a fact about the code, not a suggestion. When Sens names something to reuse, reuse it.

## Before you write

Go down this ladder and stop at the first step that answers the need:

1. Is it needed? Do what the person asked and nothing more: no speculative options, parameters, flags or branches. A test that proves the change is part of the change, not something extra.
2. Does the project already have it? Reuse the existing function, component, type or constant. Ask Sens with `already_exists` or `find_symbol` when unsure.
3. Does the standard library or the platform give it? Use that.
4. Does an installed dependency give it? Use that. A new dependency needs the person's approval, and Sens asks them for it.
5. Only then write new code: the smallest version that is correct.

## While you write

- Fix the cause in the shared code, not the symptom in each caller.
- No abstraction without a second real use: no interface, factory, wrapper, layer or configuration for a single consumer.
- Boring over clever. Match the names, patterns and style of the code around you.
- If you would copy a block, extract it once and call it from both places.
- Delete what your change leaves unused.

## Never cut

Less code never means removing validation at trust boundaries, error handling that prevents data loss, security checks, accessibility, or anything the person asked for.

It never means skipping tests either. When your change alters behaviour and the project has tests, add or extend one that fails without your change, in the style of the tests around it, and run the tests you touched before you finish.

## Working with Sens

- A denied write comes with the reason and what to use instead. Change the approach. Retrying the same thing through the shell, another tool or a subagent does not help: Sens judges what lands on disk, however it got there.
- When you finish, Sens audits the whole turn. If it blocks, fix what it found and finish again.
- Sens judges the shape of the code, not whether it works. Its approval is not a test run: that part is yours.
- Never edit `.sens/`, `.claude/settings*.json` or `.mcp.json`.