En une seule semaine d’avril 2026, Anthropic a lancé Claude Opus 4.7, présenté un nouveau produit appelé Claude Design et ajouté des Routines capables de tourner même quand votre ordinateur portable est fermé.

Le même jour, OpenAI a renforcé Codex avec des agents parallèles capables de cliquer et taper sur votre Mac.

C’est devenu normal.

Avril 2026 a été qualifié comme l’un des mois les plus chargés de l’histoire des sorties de LLM.

Environ 65 à 70 % du code d’entreprise est désormais écrit par l’IA. Plus de 50 % des entreprises décrivent leur adoption de l’IA comme un « chaos total »…

Et pourtant…

La ressource développeur la plus populaire de tout cet écosystème n’est :

• ni un framework,

• ni un plugin,

• ni un modèle.

C’est quatre phrases dans un fichier markdown.

Un dépôt GitHub. 60 000 étoiles.

Aucune dépendance.
Aucune API.
Aucune étape de build.

Juste un fichier CLAUDE.md contenant quatre règles comportementales dérivées d’un post d’Andrej Karpathy publié en janvier.

47 règles, soigneusement accumulées pendant des mois.

Ce que Karpathy a réellement diagnostiqué

En janvier 2026, Andrej Karpathy a publié un thread qui a marqué les esprits différemment des autres commentaires sur l’IA.

Il n’annonçait rien.

Il décrivait ce qui cassait.

Pendant environ six semaines, de novembre à décembre 2025, il est passé de :

• 80 % de code manuel + 20 % d’assistance IA

à l’inverse complet :

• 80 % agent IA + 20 % d’éditions humaines.

Il a appelé cela :

Mais le thread n’était pas euphorique.

Il était diagnostique.

Les modèles ne ratent pas le code.

Ils ratent le jugement.

Karpathy a identifié le vrai problème :

• ils ne gèrent pas leur confusion,

• ils ne demandent pas de clarification,

• ils ne signalent pas les incohérences,

• ils ne présentent pas les compromis,

• ils ne s’opposent pas quand ils devraient.

Vous demandez :

et l’agent :

• suppose du JSON,

• écrit sur disque,

• inclut tous les champs,

• ignore la pagination.

Il ne s’arrête jamais pour dire :

Il choisit simplement… et avance.

C’est de là que vient la Ligne 1.

Surcomplexification

Karpathy :

Sa formulation :

Vous demandez un calculateur de réduction.

Vous obtenez :

• un pattern Strategy,

• des classes abstraites,

• un enum,

• une dataclass,

• 40 lignes de configuration.

L’agent construit pour les besoins de demain au lieu du problème d’aujourd’hui.

Cela correspond directement à la Ligne 2.

Modifications parasites

Vous demandez une correction de bug.

Le PR :

• reformate vos guillemets,

• ajoute des types non demandés,

• réécrit du code adjacent.

Le correctif faisait 3 lignes.

Le diff en fait 40.

La Ligne 3 existe à cause de ça.

Karpathy n’a pas proposé de solution.

Il a décrit les modes d’échec avec tellement de clarté que quelques jours plus tard, quelqu’un les a transformés en un fichier CLAUDE.md de quatre lignes et l’a publié sur GitHub.

Mais il existe une quatrième ligne.

Une ligne qui va au-delà de la discipline.

Karpathy disait :

C’est la Ligne 4.

Et c’est elle qui transforme l’ensemble en plus qu’un simple guide de style.

Les 4 lignes

Voici la section comportementale complète du fichier CLAUDE.md que 55 000 développeurs ont jugée digne d’une étoile GitHub :

1. Ne suppose rien. Ne cache pas la confusion. Mets les compromis en évidence.

2. Le minimum de code nécessaire pour résoudre le problème. Rien de spéculatif.

3. Ne touche qu’à ce qui est nécessaire. Nettoie seulement ton propre désordre.

4. Définis des critères de réussite. Boucle jusqu’à vérification.

C’est tout.

Réfléchir avant de coder

« Ne suppose rien. Ne cache pas la confusion. Mets les compromis en évidence. »

C’est la règle qui corrige la frustration la plus fréquente avec les agents IA : ils devinent quand ils devraient poser des questions.

Sans cette règle :

def export_users(format='json'):
    users = User.query.all()
    if format == 'json':
        with open('users.json', 'w') as f:
            json.dump([u.to_dict() for u in users], f)
    return f"Exported {len(users)} users"

L’agent a supposé :

• JSON,

• tous les utilisateurs,

• écriture sur disque,

• quels champs exporter.

Avec cette règle :

Quatre questions au lieu de quatre suppositions.

Les LLM n’externalisent pas naturellement leur incertitude.

Ils sont entraînés à compléter.

Pas à s’arrêter.

Cette ligne force un comportement dont ils sont capables… mais qu’ils n’adoptent pas par défaut.

La simplicité d’abord

« Le minimum de code nécessaire. Rien de spéculatif. »

Sans cette règle :

class DiscountStrategy(ABC):

• pattern Strategy, config, setup, etc.

Avec cette règle :

def calculate_discount(amount: float, percent: float) -> float:
    return amount * (percent / 100)

Une fonction.

Une ligne.

Le vrai problème de la surcomplexité :

• plus de bugs,

• plus de charge mentale,

• plus d’inertie.

Le bon code résout le problème d’aujourd’hui simplement.

Pas celui de demain prématurément.

Changements chirurgicaux

« Ne touche qu’à ce qui est nécessaire. »

Vous corrigez un bug email.

Sans cette règle :

• validation améliorée,

• renommages,

• nouvelles contraintes,

• modifications non demandées.

Avec cette règle :

seulement le correctif du bug.

Le vrai bénéfice :

la révisabilité.

Un diff de 3 lignes se valide vite.

Un diff de 40 lignes coûte du temps.

Exécution guidée par objectifs

« Définis des critères de réussite. Boucle jusqu’à vérification. »

Sans cette règle :

Plan vague.

Avec cette règle :

1. Écrire un test → reproduire le bug

2. Implémenter → vérifier que le test passe

3. Tester les cas limites

4. Vérifier toute la suite de tests

Chaque étape a une validation.

Les trois premières règles :

• empêchent les mauvais comportements.

La quatrième :

• démultiplie les capacités.

Le paradoxe de la configuration

Quand un agent IA se comporte mal, l’instinct naturel est :

ajouter plus de règles.

Cela a créé un écosystème énorme :

• 135 agents,

• 35 compétences,

• 176 plugins,

• 42 commandes,

• 5 formats de configuration concurrents.

Mais cela ne scale pas.

Claude Code limite :

• 6000 caractères par fichier de règles,

• 12000 au total.

Pourquoi ?

Parce qu’au-delà d’un certain seuil :

• les règles créent de la confusion,

• pas de la discipline.

Anthropic le dit clairement :

Analogie : onboarding

Vous pouvez donner :

• un manuel de 50 pages,

ou :

• quatre principes.

Le manuel finit dans un tiroir.

Les principes sont utilisés.

Le paradoxe

Plus de règles donnent l’impression d’avoir plus de contrôle.

Mais après un certain point :

elles ajoutent du bruit.

Les 55 000 étoiles ne sont pas un vote pour le minimalisme esthétique.

C’est un vote pour l’idée que :

Les 4 lignes fonctionnent parce qu’elles modèlent :

• COMMENT l’agent pense,

• pas CE qu’il fait.

Que mettre réellement dans votre fichier

Option A : plugin Claude Code

/plugin marketplace add forrestchang/andrej-karpathy-skills
/plugin install andrej-karpathy-skills@karpathy-skills

Option B : télécharger le fichier

curl -o CLAUDE.md https://raw.githubusercontent.com/forrestchang/andrej-karpathy-skills/main/CLAUDE.md

Ensuite, ajouter seulement :

Commandes build/test

## Projet
- Build: npm run build
- Test: npm test

Conventions

- Les erreurs API retournent { error, code }
- Dates stockées en UTC

Pièges connus

- Timeout paiement = 30s
- Ne pas importer depuis /internal

Ce qu’il ne faut PAS mettre

• architecture déjà visible dans le code,

• guides de style déductibles,

• dépendances visibles dans package.json.

L’agent lit déjà le repo.

Quand 4 lignes ne suffisent pas

Gros refactors

Les règles comportementales ne suffisent pas pour :

• des monorepos,

• dépendances complexes,

• restructurations massives.

Industries réglementées

Santé, finance :

• ne jamais logger des données personnelles,

• review sécurité obligatoire.

Cela nécessite des règles métier supplémentaires.

Cohérence d’équipe

Un CLAUDE.md personnel est simple.

Faire converger 20 ingénieurs est un problème de coordination.

Compatibilité outils

Ces règles sont pensées pour Claude Code.

Cursor, Copilot ou Codex ont des comportements différents.

Attention importante

Les 60 000 étoiles montrent une forte adhésion.

Mais ce n’est pas une preuve scientifique.

Pas encore d’études rigoureuses avant/après.

Le vrai blocage

Le problème n’a jamais été la capacité.

C’était le comportement.

Les modèles savent coder.

Mais ils ne savent pas toujours :

• quand s’arrêter,

• quoi demander,

• combien modifier,

• comment vérifier.

Ce sont des problèmes comportementaux.

Et les problèmes comportementaux ne se résolvent pas simplement avec des modèles plus intelligents.

Ils se résolvent en expliquant au modèle comment agir.

C’est pourquoi quatre phrases ont surpassé :

• plugins,

• agents,

• skills,

• frameworks.

Conclusion personnelle

Demain, j’ouvrirais mon CLAUDE.md et :

• supprimerais toutes les règles déductibles du code,

• garderais les 4 lignes comportementales,

• évaluerais chaque nouvelle règle avec cette question :

Si c’est seulement ce qu’il fait : elle n’a probablement pas sa place dans le fichier.