The Cheatsheet

Available in both English and French:

• English — Interactive HTML
• French — Interactive HTML

Items marked with a green NEW badge are features added since late 2025.

What’s Covered

This isn’t a “top 20 commands” summary. It’s the full reference:

Recent Additions Worth Knowing

MCP Computer Use

Launched March 23, 2026. Claude can now see and control your desktop: take screenshots, click, type, scroll, and drag across macOS applications.

• 27 tools including screenshot, left_click, type, key, scroll, zoom, computer_batch
• Security: request_access must be called first. Compositor-level filtering — only allowed apps are visible in screenshots
• Performance: computer_batch executes a sequence of actions in a single tool call
• Available on Pro and Max plans, macOS only for now

New Slash Commands

New CLI Flags

Hooks: 25 Events, 4 Handler Types

The hook system now supports 25 lifecycle events (up from ~8) and 4 handler types: command, http, prompt, agent. New events include SubagentStart/Stop, TaskCreated/Completed, TeammateIdle, PostCompact, ConfigChange, FileChanged, and more.

Skills & Subagents Frontmatter

Skills gained context: fork, paths:, and effort: options. Subagents gained isolation: worktree and memory: project/user/local for persistent knowledge.

“Customize Claude Code” Card

One of the most useful sections: a complete guide showing how to create every type of extension — slash commands, skills, subagents, rules, hooks, and MCP servers — each with a full frontmatter example and a decision guide for “where should this go?”

If you spot an error or a missing feature, feel free to reach out — I’ll keep this cheatsheet updated as Claude Code evolves.

La Cheatsheet

Disponible en français et en anglais :

• Français — HTML interactif
• English — Interactive HTML

Les éléments marqués d’un badge vert NEW sont des features ajoutées depuis fin 2025.

Ce qui est couvert

Ce n’est pas un résumé “top 20 commandes”. C’est la référence complète :

Ajouts récents à connaître

MCP Computer Use

Lancé le 23 mars 2026. Claude peut maintenant voir et contrôler votre bureau : prendre des screenshots, cliquer, taper, scroller et faire du drag & drop sur les applications macOS.

• 27 outils dont screenshot, left_click, type, key, scroll, zoom, computer_batch
• Sécurité : request_access obligatoire. Filtrage au niveau du compositing — seules les apps autorisées sont visibles dans les screenshots
• Performance : computer_batch exécute une séquence d’actions en un seul appel
• Disponible sur les plans Pro et Max, macOS uniquement pour le moment

Nouvelles commandes Slash

Nouveaux flags CLI

Hooks : 25 événements, 4 types de handlers

Le système de hooks supporte maintenant 25 événements du cycle de vie (contre ~8 auparavant) et 4 types de handlers : command, http, prompt, agent. Nouveaux événements : SubagentStart/Stop, TaskCreated/Completed, TeammateIdle, PostCompact, ConfigChange, FileChanged, et d’autres.

Frontmatter Skills & Subagents

Les Skills ont gagné les options context: fork, paths:, et effort:. Les Subagents ont gagné isolation: worktree et memory: project/user/local pour la connaissance persistante.

Card “Personnaliser Claude Code”

Une des sections les plus utiles : un guide complet montrant comment créer chaque type d’extension — commandes slash, skills, sous-agents, rules, hooks et serveurs MCP — chacun avec un exemple de frontmatter complet et un guide de décision “où placer quoi ?”.

Si vous repérez une erreur ou une feature manquante, n’hésitez pas à me contacter — je maintiendrai cette cheatsheet à jour au fil des évolutions de Claude Code.

Qu’est-ce que /insights ?

/insights est une commande intégrée à Claude Code qui analyse l’historique de vos sessions locales et produit un rapport HTML interactif. Pas besoin de configuration, pas de tracking externe : tout est basé sur les données déjà stockées sur votre machine.

# Dans Claude Code, tapez simplement :
/insights

Le rapport est généré dans ~/.claude/usage-data/report.html et s’ouvre automatiquement dans votre navigateur.

Comment ça Fonctionne Techniquement

Le système traite vos données en 6 étapes :

Sessions locales (~/.claude/projects/)
    ↓
1. Collecte et filtrage des sessions
    ↓
2. Extraction des métadonnées (tokens, outils, durée, modifications)
    ↓
3. Analyse qualitative des transcriptions via LLM (Haiku)
    ↓
4. Agrégation des données sur l'ensemble des sessions
    ↓
5. Analyse multi-prompt générant des insights spécialisés
    ↓
6. Rendu HTML avec visualisations interactives

Filtrage Intelligent

Toutes les sessions ne sont pas analysées. Sont exclues :

Traitement des Données

• Modèle utilisé : Haiku (rapport coût/performance optimal)
• Limite : 50 nouvelles sessions analysées par exécution
• Cache : Les analyses sont cachées dans ~/.claude/usage-data/facets/<session-id>.json
• Sessions longues : Découpées en segments de 25 000 caractères, chacun résumé séparément

Ce que Contient le Rapport

1. Dashboard Statistiques

Vue d’ensemble chiffrée de votre activité :

• Sessions et messages : nombre total, moyenne par jour
• Temps passé : durée cumulée de vos sessions
• Tokens consommés : input et output
• Activité Git : commits et pushs
• Jours actifs : fréquence et séries d’activité
• Heures de pointe : quand vous êtes le plus productif

2. Résumé Exécutif (“At a Glance”)

Quatre sections ciblées :

3. Visualisations Interactives

• Graphique d’activité quotidienne avec sélecteur de fuseau horaire
• Distribution des outils utilisés (Read, Edit, Bash, Grep, etc.)
• Répartition des langages de programmation
• Niveaux de satisfaction par session
• Types de sessions : tâche unique, multi-tâches, itération, exploration, question rapide

4. Analyse des Frictions

C’est la section la plus actionnable. Le rapport catégorise vos points de douleur :

Chaque friction est documentée avec des exemples concrets tirés de vos sessions.

5. Suggestions CLAUDE.md

La section la plus intéressante : le rapport génère des règles prêtes à copier-coller dans votre CLAUDE.md, basées sur les instructions que vous répétez souvent.

Exemple de suggestion :

# Suggestion générée par /insights

## Testing
- Toujours exécuter les tests après modification d'un fichier source
- Utiliser vitest pour les tests unitaires, pas jest

## Conventions
- Utiliser des imports absolus avec l'alias @/
- Nommer les fichiers en kebab-case

Ces suggestions ciblent précisément les patterns répétitifs détectés dans vos sessions. L’idée : dire une fois à Claude ce que vous répétez chaque jour.

6. Recommandations de Features

Selon votre profil d’utilisation, le rapport suggère des fonctionnalités Claude Code que vous n’exploitez peut-être pas :

• MCP Servers si vous interagissez souvent avec des outils externes
• Skills personnalisés si vous répétez les mêmes workflows
• Hooks si vous faites des actions manuelles post-édition
• Mode Headless si vous avez des tâches CI/CD
• Task Agents si vous faites de l’exploration de codebase complexe

Catégories d’Objectifs Trackés

Le rapport classifie automatiquement vos sessions par type de tâche :

debug/investigate     │ implement feature    │ fix bug
write script/tool     │ refactor code        │ configure system
create PR/commit      │ analyze data         │ understand codebase
write tests           │ write docs           │ deploy/infra

Cette classification aide à comprendre comment vous répartissez votre temps avec Claude Code.

Confidentialité et Données

Point important : tout est local.

• L’analyse s’exécute sur votre machine via l’API Anthropic
• Aucun code source n’est uploadé
• L’analyse porte sur les patterns d’interaction, pas sur le contenu du code
• Le rapport HTML reste en local, partageable à votre discrétion
• Les facettes cachées ne contiennent que des métadonnées agrégées

Bonnes Pratiques

Fréquence d’Utilisation

Ne lancez pas /insights tous les jours. Le sweet spot :

• Toutes les 2-3 semaines pour un suivi régulier
• Après un milestone (fin de feature, release)
• Après une période de friction pour identifier les causes

Exploiter le Rapport

1. Commencez par les frictions : c’est là que se cachent les gains rapides
2. Copiez les suggestions CLAUDE.md pertinentes dans votre projet
3. Testez les features recommandées que vous n’utilisez pas encore
4. Comparez les rapports d’un mois sur l’autre pour mesurer votre progression

Workflow Mensuel Recommandé

/insights
    ↓
Lire les frictions identifiées
    ↓
Copier les suggestions CLAUDE.md pertinentes
    ↓
Tester 1-2 features recommandées
    ↓
Reprendre le travail normal
    ↓
/insights le mois suivant → mesurer l'évolution

Limitations

• 50 sessions max par analyse (les plus récentes sont priorisées)
• Modèle Haiku pour l’analyse (bon rapport qualité/prix, mais moins fin qu’Opus)
• 30 jours de fenêtre d’analyse
• Le rapport peut prendre plusieurs minutes selon le volume (600+ messages = patience)

Mon Avis

La feature n’a qu’un mois d’existence au moment où j’écris, mais elle m’a déjà surpris. Après mon premier /insights, j’ai découvert que je répétais les mêmes consignes de formatting dans plus de la moitié de mes sessions — du temps perdu que quelques lignes dans CLAUDE.md auraient pu éviter.

C’est un miroir de vos habitudes : parfois flatteur, parfois brutal. La vraie valeur est dans les suggestions CLAUDE.md. Au lieu de répéter les mêmes instructions session après session, vous les codifiez une bonne fois. C’est exactement le genre d’optimisation meta qui fait gagner du temps sur le long terme.

Le fait que tout reste local est un plus non négligeable, surtout pour ceux qui travaillent sur du code propriétaire. On est encore aux débuts de cette feature — il sera intéressant de voir comment Anthropic la fera évoluer dans les prochaines versions.

La commande est toute fraîche — c’est le moment de l’essayer et de découvrir ce que vos sessions révèlent sur vous.

What is /insights?

/insights is a built-in Claude Code command that analyzes your local session history and produces an interactive HTML report. No configuration needed, no external tracking: everything is based on data already stored on your machine.

# In Claude Code, simply type:
/insights

The report is generated at ~/.claude/usage-data/report.html and opens automatically in your browser.

How It Works Technically

The system processes your data in 6 stages:

Local sessions (~/.claude/projects/)
    ↓
1. Session collection and filtering
    ↓
2. Metadata extraction (tokens, tools, duration, modifications)
    ↓
3. Qualitative transcript analysis via LLM (Haiku)
    ↓
4. Data aggregation across all sessions
    ↓
5. Multi-prompt analysis generating specialized insights
    ↓
6. HTML rendering with interactive visualizations

Smart Filtering

Not all sessions are analyzed. Excluded:

Data Processing

• Model used: Haiku (optimal cost/performance ratio)
• Limit: 50 new sessions analyzed per run
• Cache: Analyses are cached in ~/.claude/usage-data/facets/<session-id>.json
• Long sessions: Split into 25,000-character segments, each summarized separately

What the Report Contains

1. Statistics Dashboard

A quantified overview of your activity:

• Sessions and messages: total count, daily average
• Time spent: cumulative session duration
• Tokens consumed: input and output
• Git activity: commits and pushes
• Active days: frequency and activity streaks
• Peak hours: when you’re most productive

2. Executive Summary (“At a Glance”)

Four targeted sections:

3. Interactive Visualizations

• Daily activity chart with timezone selector
• Tool usage distribution (Read, Edit, Bash, Grep, etc.)
• Programming language breakdown
• Satisfaction levels per session
• Session types: single task, multi-task, iteration, exploration, quick question

4. Friction Analysis

This is the most actionable section. The report categorizes your pain points:

Each friction is documented with concrete examples from your sessions.

5. CLAUDE.md Suggestions

The most valuable section: the report generates copy-paste-ready rules for your CLAUDE.md, based on instructions you repeat often.

Example suggestion:

# Suggestion generated by /insights

## Testing
- Always run tests after modifying a source file
- Use vitest for unit tests, not jest

## Conventions
- Use absolute imports with the @/ alias
- Name files in kebab-case

These suggestions precisely target repetitive patterns detected in your sessions. The idea: tell Claude once what you repeat every day.

6. Feature Recommendations

Based on your usage profile, the report suggests Claude Code features you might not be leveraging:

• MCP Servers if you frequently interact with external tools
• Custom Skills if you repeat the same workflows
• Hooks if you perform manual post-edit actions
• Headless Mode if you have CI/CD tasks
• Task Agents if you do complex codebase exploration

Goal Categories Tracked

The report automatically classifies your sessions by task type:

debug/investigate     │ implement feature    │ fix bug
write script/tool     │ refactor code        │ configure system
create PR/commit      │ analyze data         │ understand codebase
write tests           │ write docs           │ deploy/infra

This classification helps understand how you distribute your time with Claude Code.

Privacy and Data

Important point: everything is local.

• Analysis runs on your machine via the Anthropic API
• No source code is uploaded
• Analysis focuses on interaction patterns, not code content
• The HTML report stays local, shareable at your discretion
• Cached facets contain only aggregated metadata

Best Practices

Usage Frequency

Don’t run /insights every day. The sweet spot:

• Every 2-3 weeks for regular monitoring
• After a milestone (feature completion, release)
• After a friction period to identify root causes

Leveraging the Report

1. Start with frictions: that’s where quick wins hide
2. Copy relevant CLAUDE.md suggestions into your project
3. Test recommended features you’re not using yet
4. Compare reports month over month to measure your progress

Recommended Monthly Workflow

/insights
    ↓
Read identified frictions
    ↓
Copy relevant CLAUDE.md suggestions
    ↓
Test 1-2 recommended features
    ↓
Resume normal work
    ↓
/insights next month → measure evolution

Limitations

• 50 sessions max per analysis (most recent are prioritized)
• Haiku model for analysis (good cost/quality ratio, but less nuanced than Opus)
• 30-day analysis window
• Report can take several minutes depending on volume (600+ messages = patience)

My Take

The feature is only a month old as I write this, but it has already surprised me. After my first /insights run, I discovered I was repeating the same formatting instructions in over half my sessions — wasted time that a few lines in CLAUDE.md could have prevented.

It’s a mirror of your habits: sometimes flattering, sometimes brutal. The real value lies in the CLAUDE.md suggestions. Instead of repeating the same instructions session after session, you codify them once and for all. This is exactly the kind of meta-optimization that saves time in the long run.

The fact that everything stays local is a significant plus, especially for those working on proprietary code. We’re still in the early days of this feature — it will be interesting to see how Anthropic evolves it in upcoming versions.

The command is brand new — now is the time to try it and discover what your sessions reveal about you.

Le Problème : IA Cloud vs Vie Privée

Les solutions de transcription (Otter.ai, Fireflies, transcriptions Teams/Meet) partagent un point commun : vos conversations transitent par leurs serveurs. Problématique pour :

• Réunions stratégiques d’entreprise
• Entretiens confidentiels
• Discussions médicales ou juridiques
• Tout ce qui ne regarde pas Google, Microsoft ou une startup

Sans parler des abonnements mensuels qui s’accumulent.

La Solution : Tout Local, Zéro Compromis

Sourdine fait tourner deux modèles d’IA directement sur votre Mac :

Aucune connexion internet après le téléchargement initial. Vos données ne quittent jamais votre machine.

Comment Ça Marche

Capture Audio Intelligente

Sourdine capture simultanément deux sources :

Micro (votre voix)    →  ┐
                         ├→  Mixeur audio  →  Transcription
Audio système (Teams) →  ┘

Cette double capture utilise ScreenCaptureKit (macOS 14.2+). J’ai développé un module natif en Rust avec napi-rs pour l’intégrer à Electron.

Pipeline de Transcription

Le STT tourne dans un worker Node.js séparé pour ne pas bloquer l’interface.

Génération de Notes

Mistral 7B analyse la transcription pour extraire :

• Résumé concis de la discussion
• Points clés abordés
• Actions à suivre avec personnes assignées
• Titre descriptif automatique

Vous pouvez aussi poser des questions : “Qu’est-ce que Pierre a dit à propos du budget ?”

Toutes les réunions sont indexées via SQLite FTS5 (recherche full-text) et exportables en Markdown ou texte brut.

Architecture Technique

┌──────────────────────────────────────────────────┐
│  Electron Main Process                           │
│  ├── NestJS Backend (injection de dépendances)  │
│  ├── stt-worker (sherpa-onnx, process isolé)    │
│  ├── llm-worker (node-llama-cpp, process isolé) │
│  └── SQLite (stockage local, recherche FTS5)    │
└──────────────────────────────────────────────────┘
                       │ IPC
┌──────────────────────┴───────────────────────────┐
│  Renderer Process (Angular 21)                   │
└──────────────────────────────────────────────────┘

Stack Technique

Pourquoi Ces Choix ?

• Electron — Accès natif au système (audio, fichiers), écosystème TypeScript
• NestJS dans Electron — Architecture modulaire, injection de dépendances
• Workers séparés — Isolation des modèles IA (crash-safe)
• Rust pour l’audio — Performances natives, intégration ScreenCaptureKit

Performance sur Apple Silicon

Les puces Apple Silicon avec leur Neural Engine sont parfaitement adaptées.

Ce Que J’ai Appris

1. L’Audio, C’est Compliqué

• Resampling (48kHz → 16kHz)
• Conversion formats (Float32 → Int16 PCM)
• Mixage sources multiples
• Gestion buffers et latence

2. L’IA Locale a des Contraintes

• 16 Go RAM minimum
• Chargement initial de plusieurs secondes
• Qualité dépend de la quantification (Q4_K_M = bon compromis)

3. Electron N’est Pas Mort

Malgré les critiques sur la mémoire, reste le meilleur choix pour desktop cross-platform avec accès natif.

Installation

Prérequis

Téléchargement du DMG

Télécharger Sourdine v0.2.1-beta

1. Ouvrir le DMG et glisser Sourdine dans Applications
2. Exécuter cette commande (app non signée) :

   xattr -cr /Applications/Sourdine.app
   

3. Lancer Sourdine — L’assistant téléchargera les modèles IA (~5 Go)
4. Accorder les permissions Microphone et Enregistrement d’écran au premier lancement

Beta : Cette version est en développement actif. Vos retours sont les bienvenus via GitHub Issues.

Conclusion

Sourdine est né d’un besoin personnel : garder le contrôle sur mes données tout en bénéficiant de l’IA. Le projet est open source et les contributions sont bienvenues.

github.com/Lingelo/Sourdine

Si vous partagez cette préoccupation pour la vie privée, j’espère que ce projet vous sera utile.

The Problem: Cloud AI vs Privacy

Transcription solutions (Otter.ai, Fireflies, Teams/Meet transcriptions) share one thing in common: your conversations go through their servers. Problematic for:

• Strategic business meetings
• Confidential interviews
• Medical or legal discussions
• Anything that’s none of Google, Microsoft, or a startup’s business

Not to mention the monthly subscriptions piling up.

The Solution: All Local, Zero Compromise

Sourdine runs two AI models directly on your Mac:

No internet connection needed after initial download. Your data never leaves your machine.

How It Works

Smart Audio Capture

Sourdine captures two sources simultaneously:

Microphone (your voice)  →  ┐
                            ├→  Audio mixer  →  Transcription
System audio (Teams)     →  ┘

This dual capture uses ScreenCaptureKit (macOS 14.2+). I developed a native module in Rust with napi-rs to integrate it with Electron.

Transcription Pipeline

STT runs in a separate Node.js worker to avoid blocking the UI.

Note Generation

Mistral 7B analyzes the transcription to extract:

• Summary of the discussion
• Key points covered
• Action items with assigned people
• Title automatically generated

You can also ask questions: “What did Pierre say about the budget?”

All meetings are indexed via SQLite FTS5 (full-text search) and can be exported as Markdown or plain text.

Technical Architecture

┌──────────────────────────────────────────────────┐
│  Electron Main Process                           │
│  ├── NestJS Backend (dependency injection)      │
│  ├── stt-worker (sherpa-onnx, isolated process) │
│  ├── llm-worker (node-llama-cpp, isolated)      │
│  └── SQLite (local storage, FTS5 search)        │
└──────────────────────────────────────────────────┘
                       │ IPC
┌──────────────────────┴───────────────────────────┐
│  Renderer Process (Angular 21)                   │
└──────────────────────────────────────────────────┘

Tech Stack

Why These Choices?

• Electron — Native system access (audio, files), TypeScript ecosystem
• NestJS in Electron — Modular architecture, dependency injection
• Separate workers — AI model isolation (crash-safe)
• Rust for audio — Native performance, ScreenCaptureKit integration

Performance on Apple Silicon

Apple Silicon chips with their Neural Engine are perfectly suited for this.

What I Learned

1. Audio Is Complicated

• Resampling (48kHz → 16kHz)
• Format conversion (Float32 → Int16 PCM)
• Multi-source mixing
• Buffer and latency management

2. Local AI Has Constraints

• 16 GB RAM minimum
• Initial loading takes several seconds
• Quality depends on quantization (Q4_K_M = good compromise)

3. Electron Is Not Dead

Despite criticism about memory usage, still the best choice for cross-platform desktop with native access.

Installation

Requirements

Download the DMG

Download Sourdine v0.2.1-beta

1. Open the DMG and drag Sourdine to Applications
2. Run this command (app is not signed):

   xattr -cr /Applications/Sourdine.app
   

3. Launch Sourdine — The wizard will download AI models (~5 GB)
4. Grant Microphone and Screen Recording permissions on first launch

Beta: This version is under active development. Feedback is welcome via GitHub Issues.

Conclusion

Sourdine was born from a personal need: keeping control over my data while benefiting from AI. The project is open source and contributions are welcome.

github.com/Lingelo/Sourdine

If you share this concern for privacy, I hope this project will be useful to you.

There’s a physical law you apply every day without knowing it. It explains why your desk gets messy, why your coffee cools down, why your projects drift, why your teams become disorganized, and perhaps even why you sometimes feel overwhelmed by your emotions.

This law is the second law of thermodynamics: the entropy of an isolated system can only increase. In other words: without effort, everything tends toward disorder.

But entropy isn’t really “disorder” in the sense of a messy room. It’s about the number of possible configurations [2]. An assembled puzzle has only one correct configuration—low entropy. A scattered puzzle can be mixed in billions of ways—high entropy. And if you shake the box, the puzzle will never solve itself. Things spontaneously move toward the state with the most possible configurations. Always.

This idea has profound implications. On how we work, think, and feel. And above all, it sheds new light on the question that obsesses our era: what separates human intelligence from artificial intelligence? The answer might well lie in entropy itself.

Life: The Anti-Entropic Anomaly

In a universe inexorably marching toward total disorder, life is a spectacular anomaly. From a few simple molecules, it builds organisms of staggering complexity—cells that divide, organs that cooperate, brains that think. Life creates order where there shouldn’t be any.

But it doesn’t violate thermodynamics. It circumvents it. A living organism creates order locally by increasing disorder around it. You eat ordered food, you release heat and waste. The global balance remains positive in entropy. The universe continues its march toward chaos, but life has found how to swim against the current—temporarily, locally, at the cost of constant energy expenditure.

Erwin Schrödinger understood this as early as 1944 in his book What is Life? [1]: a living organism literally feeds on negative entropy. It draws order from its environment to maintain its own structure. As soon as it stops—that’s death. The return to thermodynamic equilibrium. The return to disorder.

This idea is dizzying: to live is to resist entropy. Every heartbeat, every breath, every thought is an act of resistance against the universe’s natural tendency toward chaos.

And it’s this resistance that underlies everything we do—including what we call work.

Human Work: A Universal Struggle Against Disorder

If life is resistance to entropy, then work is its primary tool. And not just intellectual or technical work. All professions, without exception, are forms of struggle against disorder.

The Surgeon

A sick body is a system whose entropy is increasing—cells become disorganized, organs malfunction, biological processes derail. The surgeon intervenes to restore order. They repair, restructure, realign. Every suture is an anti-entropic act. But the operating room itself generates disorder: energy consumed, materials used, staff fatigue. Order is always local, and it always has a cost.

Today, AI systems assist surgeons—image analysis, surgical planning, robotic surgery. They reduce uncertainty upstream. But at the critical moment, when the patient’s body presents an unforeseen anomaly, it’s the surgeon’s intuition—nourished by thousands of hours of embodied practice, by the sensation of tissue under their fingers, by that ability to “sense” that something is wrong—that makes the difference. AI optimizes the plan. The human navigates the chaos.

The Farmer

A field left to itself returns to wilderness. Weeds invade, soil depletes, biodiversity simplifies. The farmer imposes order: selecting species, structuring rows, controlling irrigation. They transform a chaotic ecosystem into an organized productive system. But again, at the cost of enormous energy expenditure—fuel, fertilizers, physical labor.

Precision agriculture now uses drones, sensors, and algorithms to optimize irrigation and treatments. AI excels at regularity: analyzing satellite data, predicting yields, detecting diseases in images. But the farmer who senses a storm coming by looking at the sky, who knows soil needs rest by taking it in their hand, who adapts practices to a microclimate no algorithm models—they operate in a dimension the machine doesn’t yet touch. Their intelligence is embodied in the earth [8].

The Teacher

An untrained mind is a space of high informational entropy [3]. Ideas are fragmented, connections random, understanding of the world fuzzy. The teacher reduces this entropy: structuring knowledge, creating logical links, building frameworks of understanding. They transform noise into signal.

Adaptive learning platforms and AI tutors already do part of this work—and sometimes better than humans for pure information transmission. But a teacher does much more than transmit knowledge. They perceive the discouraged look of the student in the third row. They sense the exact moment when a class disengages. They adapt their speech not to performance metrics, but to a collective energy they physically feel in the room. AI can personalize a learning path. The teacher creates the desire to learn—and that’s emotional entropy transformed into motivation.

The Manager

A team without direction is a high-entropy system. People work in their own directions, priorities are unclear, efforts scatter. The manager creates order: aligning objectives, clarifying roles, coordinating actions.

AI tools can already analyze a team’s velocity, suggest resource allocations, identify workflow blockers. But management, in its most essential dimension, is emotional work. It’s knowing that a colleague is going through a divorce and adjusting expectations without saying it explicitly. It’s sensing tension between two people before it explodes. It’s inspiring a collective to give their best when everything seems lost. The machine manages flows. The human manages souls.

The Developer

Code without architecture is chaos. Overlapping functions, circular dependencies, incomprehensible variable names. The developer imposes structure: patterns, conventions, abstractions.

This is perhaps the profession where the human-machine boundary is thinnest today. Code AIs generate functions, entire modules, sometimes complete applications. But as I detailed in my critical analysis of AI and developer replacement, generated code is often “almost correct”—and the “almost” hides hours of debugging. The developer’s true value isn’t in writing code. It’s in understanding the problem—that ability to translate a fuzzy human need into a coherent software architecture. AI writes code. The human understands why that code must exist.

The Artist

One might think art is pure chaos, pure entropy. But it’s exactly the opposite. Facing a blank canvas—a space of infinite possibilities, maximum entropy—the artist makes choices. Every brushstroke reduces possibilities. Every composed note eliminates alternatives. Art is the imposition of a singular order on a space of infinite chaos.

Generative AIs now produce stunning images, music, texts. Technically, they reduce entropy: they converge toward structured outputs from statistical noise. But something fundamental is missing. A human artist paints because they suffer, because they’ve seen something that shook them, because they want to say something words cannot express. AI generates because it’s asked to generate. The difference isn’t in the result—it’s in the intention. And intention is born from inner chaos. From lived experience. From emotional entropy.

The Lawyer

Law is a monumental attempt to reduce social entropy. Without laws, human interactions are unpredictable—high entropy. The legal system imposes rules, procedures, consequences that reduce the number of possible behaviors.

Legal AIs already analyze jurisprudence, predict trial outcomes, generate contracts. But law, in its most critical moments, is an exercise in structured empathy. To plead is to understand a jury’s emotions. To judge is to weigh the human intention behind an act. To legislate is to anticipate a society’s passions. Law without humanity is mere bureaucracy—dead order, without the breath of chaos that makes it just.

The Chef

Raw ingredients are a system of high culinary entropy—they can be combined in an almost infinite number of ways, the overwhelming majority of which will be inedible. The chef selects, doses, transforms, assembles according to precise principles to produce an ordered result.

AIs generate recipes, optimize flavor combinations, analyze taste profiles. But a great chef doesn’t follow a recipe—they feel it. They taste and adjust in real-time, guided by a sensory memory no database reproduces. Cooking, at its highest level, is a dialogue between body and matter [9]. Between a chaos of flavors and an order that emerges from intuition.

The pattern is universal: in every profession, AI excels in the anti-entropic dimension—structuring, optimizing, predicting, reducing uncertainty. But humans bring something the machine doesn’t have: the inner chaos that gives order its meaning, its direction, and its depth. AI is a canal. The human is a river.

Intelligence: The Ultimate Anti-Entropic Weapon

If work is the struggle against entropy, intelligence is the most sophisticated weapon in this arsenal.

Physicist Alex Wissner-Gross proposed an elegant idea in 2013 [4]: intelligent behavior is what maximizes future options. An intelligent system acts to keep as many doors open as possible. It’s paradoxical: it looks like maximizing entropy (more possibilities), but in reality it’s controlling which possibilities remain open. It’s directed entropy.

Take a chess player. A beginner reduces their own options with each move without realizing it. A grandmaster maintains a position that leaves them a maximum of viable future moves. They don’t create disorder on the board—they preserve a structured space of possibilities.

This definition applies to all domains. A good doctor keeps therapeutic options open rather than rushing to a diagnosis. A good investor diversifies rather than betting everything on one position. A good software architect designs extensible systems rather than rigid ones. In each case, intelligence consists of resisting the premature closure of possibilities.

Neuroscience suggests the brain operates at criticality [5]—that boundary between order and chaos where information propagates most richly. Too much neural order and the brain becomes rigid, unable to adapt. Too much chaos and it can no longer process information coherently. Intelligence emerges at the edge of chaos.

And this is where the comparison with AI becomes revealing.

AI: Anti-Entropy Without Chaos

A language model is fundamentally an informational entropy reduction machine [3]. You ask a vague question—there are millions of possible answers (high entropy). AI gives you a relevant answer—it drastically reduces uncertainty (low entropy). This is literally what an LLM does with each generated token: it chooses among thousands of possible words the one most probable in context.

AI is extraordinarily efficient at this entropy reduction. Often more efficient than a human. It processes more data, faster, with fewer cognitive biases. For purely anti-entropic tasks—classifying, sorting, optimizing, predicting—it’s already superior in many domains.

But there’s a cost, and not just energetic. As I explored in my article on AI’s ecological cost, the datacenters running these models consume massive amounts of energy and produce heat [12]. AI creates informational order by increasing physical disorder elsewhere. Thermodynamics won’t be fooled.

And there’s an even deeper difference. A living organism maintains itself [1]. It actively fights against its own degradation. It repairs, adapts, evolves. AI does none of that. Without humans to supply energy, maintain it, correct it, it stops. It doesn’t resist entropy—it’s a tool in humanity’s resistance to entropy.

AI is anti-entropic, yes. But it’s anti-entropic without the counterweight of chaos. And that’s perhaps where its fundamental limit lies.

AGI: The Dream of a Machine Like Us

The question everyone asks: could artificial general intelligence bridge this gap?

In theory, an AGI would be an incredible concentrate of order. It could understand, plan, adapt, create in any domain. It would be anti-entropic at a scale we can’t even imagine.

But to be truly intelligent in the human sense, it would need something nobody yet knows how to give it: something to lose.

A human thinks with urgency because they’re mortal. They create because they suffer. They innovate because they’re afraid. They love because they know it can end. All this existential entropy—the chaos of being a fragile body in an unpredictable world—isn’t a bug in human intelligence. It’s its engine.

An AGI, even infinitely more powerful than any human brain, would be intelligent differently. It could optimize, solve, structure better than us. But could it write a poem that makes you cry? Not because it doesn’t know how to assemble words—it already knows that. But because behind a touching poem, there’s someone who lived the chaos they describe. Someone for whom these words aren’t probabilistic tokens but scars.

There’s also the body argument—what philosophers and neuroscientists call embodied cognition [8] [9]. Our intelligence isn’t just in the brain. How you think is shaped by having hands, by feeling hunger, by having back pain, by smelling coffee in the morning. All this sensory experience feeds thought in a way a purely informational system cannot reproduce.

You can’t simulate the fear of death if you can’t die. You can’t understand the joy of a shared meal if you’ve never been hungry. You can’t grasp the beauty of a sunset if you don’t have a retina that vibrates.

It’s the difference between a river and a canal. Both carry water. The canal is more efficient—no meanders, no floods, no surprises. But only the river can carve a canyon. Because the canyon is born from chaos—from the brute force of water that follows no plan, that erodes, that overflows, that destroys to create.

AGI would be a perfect canal. The human is a river. And the world needs both.

Emotions: The Necessary Chaos the Machine Will Never Have

This is where the human-machine comparison becomes sharpest.

If intelligence is anti-entropic, emotions seem to be the exact opposite. Anger, fear, love, jealousy—they don’t follow logic, they don’t maximize options, they overwhelm rational thought. In thermodynamic terms, emotions introduce disorder into the ordered mechanics of intelligence.

But is this a design flaw?

Neurologist Antonio Damasio studied patients with lesions in the ventromedial prefrontal cortex [6]—the area connecting reasoning to emotions. Their IQ was intact. Their logic worked perfectly. But without feeling, they became incapable of making decisions. They could analyze the pros and cons of a restaurant for hours without ever choosing. Their pure intelligence, deprived of emotional “noise,” was paralyzed.

Read that last sentence carefully. Pure intelligence, without emotions, is paralyzed. This is exactly the condition of an AI. It doesn’t choose—it calculates the highest probability. It doesn’t decide—it optimizes a cost function. It doesn’t act—it executes. The difference between choosing and calculating is created by emotional chaos.

Emotions are a form of functional entropy—disorder the system uses as fuel. Fear makes you flee without thinking—which saves your life when a truck is heading toward you. Love pushes you to protect your children at the expense of your own safety—which is “irrational” but biologically brilliant. Enthusiasm pushes you to start an impossible project—which sometimes leads to discoveries pure reason would never have allowed.

If we return to the idea of neural criticality [5], emotions are precisely what prevents the brain from becoming too rigid. They inject just enough chaos to remain adaptive, creative, alive.

That’s why an AI, however powerful, lacks something fundamental. It lacks that entropic engine that pushes one to act without calculated reason, to create without guaranteed results, to take irrational risks—in short, to be alive. AI has no guts. And guts, in thermodynamics as in philosophy, matter.

Emotional Intelligence: Taming the Chaos the Machine Doesn’t Know

Then comes a modern concept: emotional intelligence. Observing your emotions, naming them, regulating them, using them wisely. It’s applying anti-entropy to what is fundamentally entropic. It’s a fascinating meta-level: intelligence turning against the chaos that feeds it.

Every human culture has attempted this domestication. Greek Stoicism proposed apatheia [11]—not the absence of emotions, but their mastery through reason. Buddhism aims for detachment through meditation. Cognitive-behavioral therapy restructures dysfunctional emotional patterns. Modern personal development promises to “manage your emotions” like managing an investment portfolio.

But here’s the troubling observation: it never fully works. You can meditate for ten years, and a betrayal or bereavement brings you back to raw chaos in a second. You can be the calmest, most structured manager in the world, and an unexpected crisis awakens panic. Emotional intelligence is a constant effort that never ends.

This is exactly what thermodynamics predicts. Maintaining order requires permanent effort. As soon as you stop, entropy returns. Emotional intelligence isn’t an achievement—it’s a permanent conquest against our own entropy.

And this may be our ultimate competitive advantage over the machine. AI doesn’t need emotional intelligence—it has no emotions to manage. But it’s precisely because we must navigate our own inner chaos that we’re capable of empathy, compassion, deep understanding. Emotional intelligence isn’t a human luxury—it’s the byproduct of a struggle only living beings can wage. And this struggle produces something no algorithm can manufacture: wisdom.

But individual wisdom wasn’t enough. Facing the immensity of chaos—death, suffering, the absurd—humanity needed a larger framework. Long before emotional intelligence, long before philosophy, long before science, it had found another tool to fight existential entropy: religion.

Spirituality: The Oldest Response to Chaos

Look at religions through the lens of entropy, and something striking appears: every spiritual tradition, whatever it may be, is fundamentally an anti-entropic system applied to human existence [15].

Existential chaos—awareness of death, suffering, injustice, the absurd—is perhaps the most vertiginous form of entropy the human mind faces. Why am I here? Why suffering? What happens after death? These questions are chasms of uncertainty, spaces of infinite possibilities where the mind can get lost. High existential entropy.

And religion, in all its forms, proposes exactly what any anti-entropic struggle does: reduce the number of possible configurations. It provides a framework. A narrative. An order.

Monotheism imposes a single God, a plan, a direction to the universe—where chaos suggests the absence of meaning. Buddhism proposes the Four Noble Truths and the Eightfold Path—a methodical structure for navigating suffering. Hinduism offers the concept of dharma—a cosmic order assigning everyone a role in the greater whole. Animist and shamanic traditions create a network of links between human, nature, and spirits—a mesh of meaning where there could be only void.

In each case, the mechanism is the same: facing a universe that seems chaotic and indifferent, spirituality creates a structuring narrative that reduces the anguish of infinity. It transforms “everything is possible and nothing has meaning” into “here is the path, here is the reason, here is your place.”

The Anti-Entropy of Rituals

Religions don’t just provide intellectual answers. They also structure time and behavior [16]—two dimensions where entropy constantly threatens us.

Prayer five times a day in Islam. The weekly Shabbat in Judaism. Sunday Mass in Christianity. Meditation cycles in Buddhism. Fasts, festivals, pilgrimages. All these rituals do exactly the same thing: they impose an ordered rhythm on the chaotic flow of existence. They are anti-entropic metronomes.

Without ritual, days blur together. Time loses its structure. Meaning crumbles. This is what many non-religious people are rediscovering today: the need for secular rituals—morning meditation, journaling, exercise routines—to maintain inner order. The form has changed, but the anti-entropic function remains the same.

And collective rituals add an additional dimension: they synchronize the inner chaos of thousands of individuals into a shared ordered experience [15]. A collective prayer, a shared song, a silence observed together—these are moments when social entropy is temporarily reduced to almost zero. Everyone feels the same thing, at the same moment, in the same place. It’s extraordinarily powerful. And it’s something no technology has managed to reproduce.

Faith: Accepting Chaos to Transcend It

But there’s a fascinating paradox in spirituality that distinguishes it from all other forms of anti-entropic struggle.

Science reduces entropy by eliminating uncertainty: it measures, proves, verifies. Technology reduces entropy by controlling: it automates, optimizes, predicts. Religion does something radically different: it reduces entropy by accepting the incomprehensible.

To believe is to recognize that you don’t understand everything—and find peace in that acceptance. It’s living with mystery without being destroyed by it. It’s the most paradoxical form of anti-entropy: creating inner order not by eliminating chaos, but by giving it a status. Mystery is no longer a threat—it becomes sacred.

This is exactly what AI cannot do. An AI facing uncertainty does one of two things: it calculates a probability, or it signals that it lacks data. It cannot accept mystery. It cannot find beauty in what it doesn’t understand. It cannot be moved by infinity.

The spiritual quest may be the ultimate proof of our entropic nature. We seek meaning because we live in chaos. We pray, meditate, believe because our inner chaos—our fears, our awareness of death, our visceral need to understand—pushes us there. The machine doesn’t have this quest because it doesn’t have this chaos. It doesn’t need God because it doesn’t need meaning. And perhaps that’s the deepest difference between human and machine: not intelligence, not emotions, but the ability to search for something we may never find—and keep searching anyway.

Human Duality: What the Machine Cannot Be

The human being isn’t a creature of order. Nor is it a creature of chaos. It is the battlefield between the two. And it’s this tension—this permanent oscillation between structure and disorder—that produces what we call the human experience.

Creativity is born from this tension. A musician who knows only music theory (pure order) composes technically perfect but soulless pieces. A musician who knows nothing about theory (pure chaos) produces noise. The music that moves us is born exactly at the boundary between the two. Enough structure to be understandable. Enough chaos to be surprising. This is exactly what AI doesn’t do: it produces structure without the lived chaos that makes it moving.

The same principle applies to innovation. The most revolutionary advances rarely come from pure method or pure chance. They come from that intermediate zone: a structured mind that accepts being surprised by the unexpected. Penicillin, Post-its, microwaves—all discoveries born from the meeting between an ordered system and a chaotic accident. An AI can optimize a research process. But it can’t have the happy accident that changes everything, because it has no body that stumbles, no hand that slips, no attention that drifts toward a fascinating anomaly.

Even our human relationships obey this logic. A relationship that’s too ordered—too predictable, too controlled—suffocates. A relationship that’s too chaotic—without landmarks, without commitment—exhausts. Relationships that last are those that find this dynamic balance between stability and surprise. AI can simulate a conversation. It can’t live a relationship, because a relationship implies the risk of emotional chaos—and that risk is what gives it value.

The Future: Neither Replacement Nor Opposition, But Complementarity

If AI is the canal and the human is the river, then the future isn’t in replacing one with the other, nor in their opposition, but in their complementarity.

AI excels at what we do poorly: processing massive volumes of information, maintaining constant attention, eliminating cognitive biases, optimizing complex systems. It’s an unprecedented anti-entropic amplifier.

Humans excel at what AI cannot do: giving meaning, feeling, understanding others, navigating ambiguity, creating from lived experience, making decisions in total uncertainty. They are the meaning generators in a world the machine can order but not understand.

Tomorrow’s surgeon will use AI to plan operations with superhuman precision—and make the difference when the plan fails. The teacher will use AI to personalize each learning path—and inspire students through passion, humanity, their own doubts. The developer will use AI to write code faster—and bring deep understanding of the human problem the code must solve. The artist will use AI as an extraordinary brush—and provide the vision, pain, and beauty that give the work its reason for existence.

In every profession, the same dynamic: the machine reduces entropy, the human gives it meaning.

What Entropy Teaches Us About Meaning

If everything tends toward disorder, if every act of order is temporary and costly, what’s the point?

That’s perhaps the wrong question. The right question would be: doesn’t meaning emerge precisely from this struggle?

Philosopher Albert Camus imagined Sisyphus happy [10]—this man condemned to push a boulder up a mountain only to watch it roll back down eternally. The absurdity of the task doesn’t make it meaningless. It’s in the struggle itself that Sisyphus finds his dignity.

We are all Sisyphus. The surgeon heals patients who will fall ill again. The teacher forms minds that will forget. The developer writes code that will become obsolete. The manager organizes teams that will reorganize. The artist creates works that time will alter. The farmer cultivates fields that seasons will ravage.

And yet, we continue. Not because we ignore entropy, but because the struggle against it is what defines us.

AI cannot be Sisyphus. It has no boulder. It has no mountain. It has neither awareness of the task’s absurdity nor the dignity of pursuing it anyway. It can push harder, faster, longer than us. But it doesn’t know why it pushes. And it’s the “why” that makes Sisyphus a hero.

Entropy tells us nothing lasts. But it also tells us that everything beautiful, true, and good that exists was torn from chaos by conscious effort. And that may be the most honest definition of meaning—a definition only a being who knows chaos can understand.

Conclusion: What the Machine Teaches Us About Ourselves

It’s ironic that it’s the advent of artificial intelligence that forces us to ask the most human question of all: what makes us irreplaceable?

The answer, seen through the lens of entropy, is clear. It’s not our intelligence—the machine is already faster. It’s not our memory—the machine is already vaster. It’s not our logic—the machine is already more rigorous.

What makes us irreplaceable is our chaos. Our emotions, our mortality, our body, our contradictions, our fears, our irrational hopes, our quest for meaning in the face of absurdity. All that inner disorder we spend our lives trying to tame—through intelligence, emotions, spirituality, work—is precisely what gives our intelligence its depth, our creativity its power, our existence its meaning.

Entropy isn’t our enemy. It’s the backdrop against which everything valuable is drawn. Without it, there would be no need to heal, teach, build, create, love. Meaning exists only because disorder threatens it.

The machine is our ally in this struggle. It amplifies our ability to create order. But it can’t fight the battle for us, because the battle isn’t only against external disorder—it’s also against inner disorder. And it’s from this battle—intimate, painful, permanent—the same battle waged by the monk in prayer, the artist before their canvas, the parent consoling their child at three in the morning—that everything that makes us human beings is born.

So the next time you feel overwhelmed by chaos—at work, in your head, in your life—remember this: you’re not failing. You’re doing exactly what life has been doing for 3.8 billion years. You’re resisting entropy. And the simple fact that you’re there, conscious, reading these words, capable of feeling something while reading them—that, no machine can do. And that’s already everything.

This essay was born from an exploratory conversation between a human and an artificial intelligence about the nature of entropy. The intuitions, doubts, and unexpected connections are human—creative chaos. The structuring, development, and writing were assisted by Claude (Anthropic)—informational anti-entropy. Neither would have produced this text alone. And perhaps that’s the future: not human against machine, but human with machine, in a dance between order and chaos that produces something neither could create separately. The sources below were verified by the author.

Sources and References

Thermodynamics and Entropy

[1] Schrödinger, E. (1944). What is Life? The Physical Aspect of the Living Cell. Cambridge University Press. — The concept of negative entropy (negentropy) as the engine of life.

[2] Boltzmann, L. (1877). Über die Beziehung zwischen dem zweiten Hauptsatze der mechanischen Wärmetheorie und der Wahrscheinlichkeitsrechnung. — The statistical formulation of entropy (S = k·log W).

[3] Shannon, C.E. (1948). “A Mathematical Theory of Communication.” Bell System Technical Journal, 27(3), 379–423. — The link between informational and physical entropy.

Intelligence and Entropy

[4] Wissner-Gross, A.D. & Freer, C.E. (2013). “Causal Entropic Forces.” Physical Review Letters, 110(16). — Intelligence as maximization of future options.

[5] Beggs, J.M. & Plenz, D. (2003). “Neuronal Avalanches in Neocortical Circuits.” Journal of Neuroscience, 23(35), 11167–11177. — Neural criticality: the brain at the edge of chaos.

Emotions and Decision-Making

[6] Damasio, A. (1994). Descartes’ Error: Emotion, Reason, and the Human Brain. Putnam Publishing. — The somatic marker hypothesis: without emotions, no decision.

[7] Damasio, A. (1999). The Feeling of What Happens: Body and Emotion in the Making of Consciousness. Harcourt Brace. — The role of emotions in consciousness.

Embodied Cognition

[8] Varela, F.J., Thompson, E. & Rosch, E. (1991). The Embodied Mind: Cognitive Science and Human Experience. MIT Press. — Intelligence isn’t just in the brain, it’s in the body.

[9] Clark, A. (1997). Being There: Putting Brain, Body, and World Together Again. MIT Press. — Body and environment as active participants in cognition.

Philosophy and Meaning

[10] Camus, A. (1942). The Myth of Sisyphus. Gallimard. — The absurd and the dignity of struggle.

[11] Epictetus. Enchiridion (Handbook). ~125 CE. — The foundations of Stoicism.

AI and Ecological Cost

[12] Strubell, E., Ganesh, A. & McCallum, A. (2019). “Energy and Policy Considerations for Deep Learning in NLP.” Proceedings of the 57th Annual Meeting of the ACL. — The energy cost of large models.

Religion and Anthropology

[15] Durkheim, É. (1912). The Elementary Forms of Religious Life. Félix Alcan. — Religion as a structuring social fact.

[16] Eliade, M. (1957). The Sacred and the Profane. Gallimard. — Sacred time (ordered) vs. profane time (chaotic).

Il existe une loi physique que vous appliquez chaque jour sans le savoir. Elle explique pourquoi votre bureau se désordonne, pourquoi votre café refroidit, pourquoi vos projets dérivent, pourquoi vos équipes se désorganisent, et peut-être même pourquoi vous vous sentez parfois submergé par vos émotions.

Cette loi, c’est le deuxième principe de la thermodynamique : l’entropie d’un système isolé ne peut qu’augmenter. Dit autrement : sans effort, tout tend vers le désordre.

Mais l’entropie n’est pas vraiment “le désordre” au sens où on range mal sa chambre. C’est une question de nombre de configurations possibles [2]. Un puzzle assemblé n’a qu’une seule configuration correcte — entropie faible. Un puzzle en vrac peut être mélangé de milliards de façons — entropie élevée. Et si vous secouez la boîte, le puzzle ne va jamais se résoudre tout seul. Les choses vont spontanément vers l’état qui a le plus de configurations possibles. Toujours.

Cette idée a des implications profondes. Sur notre façon de travailler, de penser, de ressentir. Et surtout, elle éclaire d’une lumière nouvelle la question qui obsède notre époque : qu’est-ce qui sépare l’intelligence humaine de l’intelligence artificielle ? La réponse pourrait bien se trouver dans l’entropie elle-même.

La vie : l’anomalie anti-entropique

Dans un univers qui marche inexorablement vers le désordre total, la vie est une anomalie spectaculaire. À partir de quelques molécules simples, elle construit des organismes d’une complexité stupéfiante — des cellules qui se divisent, des organes qui coopèrent, des cerveaux qui pensent. La vie crée de l’ordre là où il ne devrait pas y en avoir.

Mais elle ne viole pas la thermodynamique. Elle la contourne. Un organisme vivant crée de l’ordre localement en augmentant le désordre autour de lui. Vous mangez de la nourriture ordonnée, vous rejetez de la chaleur et des déchets. Le bilan global reste positif en entropie. L’univers continue sa marche vers le chaos, mais la vie a trouvé comment nager à contre-courant — temporairement, localement, au prix d’une dépense constante d’énergie.

Erwin Schrödinger l’avait compris dès 1944 dans son livre What is Life? [1] : un organisme vivant se nourrit littéralement d’entropie négative. Il puise de l’ordre dans son environnement pour maintenir sa propre structure. Dès qu’il arrête — c’est la mort. Le retour à l’équilibre thermodynamique. Le retour au désordre.

Cette idée est vertigineuse : vivre, c’est résister à l’entropie. Chaque battement de cœur, chaque respiration, chaque pensée est un acte de résistance contre la tendance naturelle de l’univers au chaos.

Et c’est cette résistance qui fonde tout ce que nous faisons — y compris ce que nous appelons le travail.

Le travail humain : une lutte universelle contre le désordre

Si la vie est résistance à l’entropie, alors le travail est son outil principal. Et pas seulement le travail intellectuel ou technique. Tous les métiers, sans exception, sont des formes de lutte contre le désordre.

Le chirurgien

Un corps malade est un système dont l’entropie augmente — les cellules se désorganisent, les organes dysfonctionnent, les processus biologiques déraillent. Le chirurgien intervient pour restaurer l’ordre. Il répare, il restructure, il réaligne. Chaque suture est un acte anti-entropique. Mais la salle d’opération elle-même génère du désordre : énergie consommée, matériel utilisé, fatigue du personnel. L’ordre est toujours local, et il a toujours un coût.

Aujourd’hui, des systèmes d’IA assistent les chirurgiens — analyse d’imagerie, planification opératoire, robots chirurgicaux. Ils réduisent l’incertitude en amont. Mais au moment critique, quand le corps du patient présente une anomalie imprévue, c’est l’intuition du chirurgien — nourrie par des milliers d’heures de pratique incarnée, par la sensation du tissu sous ses doigts, par cette capacité à “sentir” que quelque chose ne va pas — qui fait la différence. L’IA optimise le plan. L’humain navigue le chaos.

L’agriculteur

Un champ laissé à lui-même retourne à l’état sauvage. Les mauvaises herbes envahissent, le sol s’appauvrit, la biodiversité se simplifie. L’agriculteur impose un ordre : il sélectionne les espèces, structure les rangées, contrôle l’irrigation. Il transforme un écosystème chaotique en un système productif organisé. Mais là encore, au prix d’une énorme dépense d’énergie — carburant, engrais, travail physique.

L’agriculture de précision utilise désormais des drones, des capteurs et des algorithmes pour optimiser l’irrigation et les traitements. L’IA excelle dans la régularité : analyser des données satellite, prédire les rendements, détecter les maladies sur des images. Mais l’agriculteur qui sent l’orage arriver en regardant le ciel, qui sait qu’un sol a besoin de repos en le prenant dans sa main, qui adapte ses pratiques à un microclimat que nul algorithme ne modélise — celui-là opère dans une dimension que la machine ne touche pas encore. Son intelligence est incarnée dans la terre [8].

L’enseignant

Un esprit non formé est un espace de haute entropie informationnelle [3]. Les idées sont fragmentées, les connexions aléatoires, la compréhension du monde est floue. L’enseignant réduit cette entropie : il structure les connaissances, crée des liens logiques, construit des cadres de compréhension. Il transforme le bruit en signal.

Les plateformes d’apprentissage adaptatif et les tuteurs IA font déjà une partie de ce travail — et parfois mieux que l’humain pour la transmission pure d’information. Mais un enseignant fait bien plus que transmettre du savoir. Il perçoit le regard découragé de l’élève au troisième rang. Il sent le moment exact où une classe décroche. Il adapte son discours non pas à des métriques de performance, mais à une énergie collective qu’il ressent physiquement dans la salle. L’IA peut personnaliser un parcours d’apprentissage. L’enseignant donne envie d’apprendre — et ça, c’est de l’entropie émotionnelle transformée en motivation.

Le manager

Une équipe sans direction est un système à haute entropie. Les gens travaillent chacun dans leur direction, les priorités sont floues, les efforts se dispersent. Le manager crée de l’ordre : il aligne les objectifs, clarifie les rôles, coordonne les actions.

Les outils d’IA peuvent déjà analyser la vélocité d’une équipe, suggérer des allocations de ressources, identifier des blocages dans un workflow. Mais le management, dans sa dimension la plus essentielle, c’est du travail émotionnel. C’est savoir qu’un collaborateur traverse un divorce et adapter ses attentes sans le dire explicitement. C’est sentir une tension entre deux personnes avant qu’elle n’éclate. C’est inspirer un collectif à donner le meilleur de lui-même quand tout semble perdu. La machine gère des flux. L’humain gère des âmes.

Le développeur

Du code sans architecture est du chaos. Des fonctions qui se chevauchent, des dépendances circulaires, des noms de variables incompréhensibles. Le développeur impose une structure : des patterns, des conventions, des abstractions.

C’est peut-être le métier où la frontière homme-machine est aujourd’hui la plus ténue. Les IA de code génèrent des fonctions, des modules entiers, parfois des applications complètes. Mais comme je l’ai détaillé dans mon analyse critique sur l’IA et le remplacement des développeurs, le code généré est souvent “presque correct” — et le “presque” cache des heures de débogage. La vraie valeur du développeur n’est pas dans l’écriture de code. C’est dans la compréhension du problème — cette capacité à traduire un besoin humain flou en une architecture logicielle cohérente. L’IA écrit du code. L’humain comprend pourquoi ce code doit exister.

L’artiste

On pourrait croire que l’art est pur chaos, pure entropie. Mais c’est exactement l’inverse. Face à une toile blanche — espace de possibilités infinies, entropie maximale — l’artiste fait des choix. Chaque coup de pinceau réduit les possibilités. Chaque note composée élimine des alternatives. L’art, c’est l’imposition d’un ordre singulier sur un espace de chaos infini.

Les IA génératives produisent désormais des images époustouflantes, des musiques, des textes. Techniquement, elles réduisent l’entropie : elles convergent vers des outputs structurés à partir d’un bruit statistique. Mais il manque quelque chose de fondamental. Un artiste humain peint parce qu’il souffre, parce qu’il a vu quelque chose qui l’a bouleversé, parce qu’il veut dire quelque chose que les mots ne peuvent pas exprimer. L’IA génère parce qu’on lui demande de générer. La différence n’est pas dans le résultat — c’est dans l’intention. Et l’intention naît du chaos intérieur. Du vécu. De l’entropie émotionnelle.

Le juriste

Le droit est une tentative monumentale de réduire l’entropie sociale. Sans lois, les interactions humaines sont imprévisibles — haute entropie. Le système juridique impose des règles, des procédures, des conséquences qui réduisent le nombre de comportements possibles.

Les IA juridiques analysent déjà des jurisprudences, prédisent des issues de procès, génèrent des contrats. Mais le droit, dans ses moments les plus critiques, est un exercice d’empathie structurée. Plaider, c’est comprendre les émotions d’un jury. Juger, c’est peser l’intention humaine derrière un acte. Légiférer, c’est anticiper les passions d’une société. Le droit sans humanité n’est que bureaucratie — de l’ordre mort, sans le souffle du chaos qui le rend juste.

Le cuisinier

Des ingrédients bruts sont un système de haute entropie culinaire — ils peuvent être combinés d’un nombre presque infini de façons, dont l’écrasante majorité sera immangeable. Le cuisinier sélectionne, dose, transforme, assemble selon des principes précis pour produire un résultat ordonné.

Des IA génèrent des recettes, optimisent des combinaisons de saveurs, analysent des profils gustatifs. Mais un grand chef ne suit pas une recette — il la ressent. Il goûte et ajuste en temps réel, guidé par une mémoire sensorielle que nulle base de données ne reproduit. La cuisine, à son plus haut niveau, est un dialogue entre le corps et la matière [9]. Entre un chaos de saveurs et un ordre qui émerge de l’intuition.

Le pattern est universel : dans chaque métier, l’IA excelle dans la dimension anti-entropique — structurer, optimiser, prédire, réduire l’incertitude. Mais l’humain apporte quelque chose que la machine n’a pas : le chaos intérieur qui donne à l’ordre son sens, sa direction, et sa profondeur. L’IA est un canal. L’humain est un fleuve.

L’intelligence : l’arme anti-entropique ultime

Si le travail est la lutte contre l’entropie, l’intelligence est l’arme la plus sophistiquée dans cet arsenal.

Le physicien Alex Wissner-Gross a proposé en 2013 une idée élégante [4] : le comportement intelligent, c’est ce qui maximise les options futures. Un système intelligent agit pour se garder le plus de portes ouvertes possible. C’est paradoxal : ça ressemble à maximiser l’entropie (plus de possibilités), mais en réalité c’est contrôler quelles possibilités restent ouvertes. C’est de l’entropie dirigée.

Prenez un joueur d’échecs. Un débutant réduit ses propres options à chaque coup sans s’en rendre compte. Un grand maître maintient une position qui lui laisse un maximum de coups futurs viables. Il ne crée pas du désordre sur l’échiquier — il préserve un espace de possibilités structuré.

Cette définition s’applique à tous les domaines. Un bon médecin maintient des options thérapeutiques ouvertes plutôt que de se précipiter sur un diagnostic. Un bon investisseur diversifie plutôt que de tout miser sur une seule position. Un bon architecte logiciel conçoit des systèmes extensibles plutôt que rigides. Dans chaque cas, l’intelligence consiste à résister à la fermeture prématurée des possibilités.

Les neurosciences suggèrent que le cerveau fonctionne à la criticité [5] — cette frontière entre ordre et chaos où l’information se propage de la manière la plus riche possible. Trop d’ordre neuronal et le cerveau devient rigide, incapable de s’adapter. Trop de chaos et il ne peut plus traiter l’information de manière cohérente. L’intelligence émerge au bord du chaos.

Et c’est ici que la comparaison avec l’IA devient révélatrice.

L’IA : une anti-entropie sans chaos

Un modèle de langage est fondamentalement une machine à réduire l’entropie informationnelle [3]. Vous posez une question vague — il y a des millions de réponses possibles (haute entropie). L’IA vous donne une réponse pertinente — elle réduit drastiquement l’incertitude (basse entropie). C’est littéralement ce que fait un LLM à chaque token généré : il choisit parmi des milliers de mots possibles celui qui est le plus probable dans le contexte.

L’IA est extraordinairement efficace dans cette réduction d’entropie. Souvent plus efficace qu’un humain. Elle traite plus de données, plus vite, avec moins de biais cognitifs. Pour les tâches purement anti-entropiques — classer, trier, optimiser, prédire — elle est déjà supérieure dans de nombreux domaines.

Mais il y a un coût, et pas seulement énergétique. Comme je l’ai exploré dans mon article sur le coût écologique de l’IA, les datacenters qui font tourner ces modèles consomment des quantités massives d’énergie et produisent de la chaleur [12]. L’IA crée de l’ordre informationnel en augmentant le désordre physique ailleurs. La thermodynamique ne se laisse pas duper.

Et il y a une différence plus profonde encore. Un organisme vivant se maintient lui-même [1]. Il lutte activement contre sa propre dégradation. Il se répare, s’adapte, évolue. L’IA ne fait rien de tout ça. Sans humains pour l’alimenter en énergie, la maintenir, la corriger, elle s’arrête. Elle ne résiste pas à l’entropie — elle est un outil dans la résistance humaine à l’entropie.

L’IA est anti-entropique, oui. Mais elle est anti-entropique sans le contrepoids du chaos. Et c’est peut-être là que réside sa limite fondamentale.

L’AGI : le rêve d’une machine qui nous ressemble

La question que tout le monde se pose : une intelligence artificielle générale pourrait-elle combler ce fossé ?

En théorie, une AGI serait un concentré d’ordre incroyable. Elle pourrait comprendre, planifier, s’adapter, créer dans n’importe quel domaine. Elle serait anti-entropique à une échelle que nous ne pouvons même pas imaginer.

Mais pour être vraiment intelligente au sens humain du terme, elle aurait besoin de quelque chose que personne ne sait encore lui donner : quelque chose à perdre.

Un humain pense avec urgence parce qu’il est mortel. Il crée parce qu’il souffre. Il innove parce qu’il a peur. Il aime parce qu’il sait que ça peut finir. Toute cette entropie existentielle — le chaos d’être un corps fragile dans un monde imprévisible — n’est pas un bug de l’intelligence humaine. C’est son moteur.

Une AGI, même infiniment plus puissante que n’importe quel cerveau humain, serait intelligente autrement. Elle pourrait optimiser, résoudre, structurer mieux que nous. Mais pourrait-elle écrire un poème qui fait pleurer ? Pas parce qu’elle ne sait pas assembler les mots — ça, elle sait déjà. Mais parce que derrière un poème qui touche, il y a quelqu’un qui a vécu le chaos qu’il décrit. Quelqu’un pour qui ces mots ne sont pas des tokens probabilistes mais des cicatrices.

Il y a aussi l’argument du corps — ce que les philosophes et les neuroscientifiques appellent la cognition incarnée [8] [9]. Notre intelligence n’est pas que dans le cerveau. La façon dont vous pensez est façonnée par le fait que vous avez des mains, que vous ressentez la faim, que vous avez mal au dos, que vous sentez l’odeur du café le matin. Toute cette expérience sensorielle nourrit la pensée d’une manière qu’un système purement informationnel ne peut pas reproduire.

Vous ne pouvez pas simuler la peur de mourir si vous ne pouvez pas mourir. Vous ne pouvez pas comprendre la joie d’un repas partagé si vous n’avez jamais eu faim. Vous ne pouvez pas saisir la beauté d’un coucher de soleil si vous n’avez pas de rétine qui vibre.

C’est la différence entre un fleuve et un canal. Les deux transportent de l’eau. Le canal est plus efficace — pas de méandres, pas de crues, pas de surprises. Mais seul le fleuve peut creuser un canyon. Parce que le canyon naît du chaos — de la force brute de l’eau qui ne suit pas de plan, qui érode, qui déborde, qui détruit pour créer.

L’AGI serait un canal parfait. L’humain est un fleuve. Et le monde a besoin des deux.

Les émotions : le chaos nécessaire que la machine n’aura jamais

C’est ici que la comparaison homme-machine devient la plus tranchante.

Si l’intelligence est anti-entropique, les émotions semblent être l’exact opposé. La colère, la peur, l’amour, la jalousie — ça ne suit pas la logique, ça ne maximise pas les options, ça submerge la pensée rationnelle. En termes thermodynamiques, les émotions introduisent du désordre dans la mécanique ordonnée de l’intelligence.

Mais est-ce un défaut de conception ?

Le neurologue Antonio Damasio a étudié des patients avec des lésions du cortex préfrontal ventromédian [6] — la zone qui connecte le raisonnement aux émotions. Leur QI était intact. Leur logique fonctionnait parfaitement. Mais sans ressentir, ils devenaient incapables de prendre des décisions. Ils pouvaient analyser pendant des heures les avantages et inconvénients d’un restaurant sans jamais choisir. Leur intelligence pure, privée du “bruit” émotionnel, était paralysée.

Lisez bien cette dernière phrase. L’intelligence pure, sans émotions, est paralysée. C’est exactement la condition d’une IA. Elle ne choisit pas — elle calcule la probabilité la plus élevée. Elle ne décide pas — elle optimise une fonction de coût. Elle n’agit pas — elle exécute. La différence entre choisir et calculer, c’est le chaos émotionnel qui la crée.

Les émotions sont une forme d’entropie fonctionnelle — du désordre que le système utilise comme carburant. La peur vous fait fuir sans réfléchir — ce qui vous sauve la vie quand un camion fonce vers vous. L’amour vous pousse à protéger vos enfants au mépris de votre propre sécurité — ce qui est “irrationnel” mais biologiquement brillant. L’enthousiasme vous pousse à commencer un projet impossible — ce qui parfois mène à des découvertes que la pure raison n’aurait jamais permises.

Si on reprend l’idée de la criticité neurale [5], les émotions sont justement ce qui empêche le cerveau de devenir trop rigide. Elles injectent le chaos juste nécessaire pour rester adaptatif, créatif, vivant.

C’est pour ça qu’une IA, aussi puissante soit-elle, manque quelque chose de fondamental. Il lui manque ce moteur entropique qui pousse à agir sans raison calculée, à créer sans garantie de résultat, à prendre des risques irrationnels — bref, à être vivant. L’IA n’a pas de tripes. Et les tripes, en thermodynamique comme en philosophie, ça compte.

L’intelligence émotionnelle : domestiquer le chaos que la machine ne connaît pas

Arrive alors un concept moderne : l’intelligence émotionnelle. Observer ses émotions, les nommer, les réguler, les utiliser à bon escient. C’est appliquer de l’anti-entropie à ce qui est fondamentalement entropique. C’est un méta-niveau fascinant : l’intelligence qui se retourne contre le chaos qui la nourrit.

Chaque culture humaine a tenté cette domestication. Le stoïcisme grec proposait l’apatheia [11] — non pas l’absence d’émotions, mais leur maîtrise par la raison. Le bouddhisme vise le détachement par la méditation. La psychothérapie cognitive-comportementale restructure les schémas émotionnels dysfonctionnels. Le développement personnel moderne promet de “gérer ses émotions” comme on gère un portefeuille d’investissement.

Mais voilà le constat troublant : ça ne marche jamais complètement. Vous pouvez méditer pendant dix ans, une trahison ou un deuil vous ramène au chaos brut en une seconde. Vous pouvez être le manager le plus calme et le plus structuré du monde, une crise inattendue réveille la panique. L’intelligence émotionnelle est un effort constant qui ne s’achève jamais.

C’est exactement ce que prédit la thermodynamique. Maintenir l’ordre demande un effort permanent. Dès que vous arrêtez, l’entropie revient. L’intelligence émotionnelle n’est pas un acquis — c’est une conquête permanente contre notre propre entropie.

Et c’est peut-être notre avantage compétitif ultime face à la machine. L’IA n’a pas besoin d’intelligence émotionnelle — elle n’a pas d’émotions à gérer. Mais c’est précisément parce que nous devons naviguer notre propre chaos intérieur que nous sommes capables d’empathie, de compassion, de compréhension profonde. L’intelligence émotionnelle n’est pas un luxe humain — c’est le sous-produit d’une lutte que seuls les êtres vivants peuvent mener. Et cette lutte produit quelque chose qu’aucun algorithme ne peut fabriquer : la sagesse.

Mais la sagesse individuelle ne suffisait pas. Face à l’immensité du chaos — la mort, la souffrance, l’absurde — l’humanité avait besoin d’un cadre plus grand. Bien avant l’intelligence émotionnelle, bien avant la philosophie, bien avant la science, elle avait trouvé un autre outil pour lutter contre l’entropie existentielle : la religion.

La spiritualité : la plus ancienne réponse au chaos

Regardons les religions à travers le prisme de l’entropie, et quelque chose de frappant apparaît : chaque tradition spirituelle, quelle qu’elle soit, est fondamentalement un système anti-entropique appliqué à l’existence humaine [15].

Le chaos existentiel — la conscience de la mort, de la souffrance, de l’injustice, de l’absurde — est peut-être la forme la plus vertigineuse d’entropie que l’esprit humain affronte. Pourquoi suis-je ici ? Pourquoi la souffrance ? Que se passe-t-il après la mort ? Ces questions sont des gouffres d’incertitude, des espaces de possibilités infinies où l’esprit peut se perdre. Haute entropie existentielle.

Et la religion, dans toutes ses formes, propose exactement ce que fait toute lutte anti-entropique : réduire le nombre de configurations possibles. Elle donne un cadre. Un récit. Un ordre.

Le monothéisme impose un Dieu unique, un plan, une direction à l’univers — là où le chaos suggère l’absence de sens. Le bouddhisme propose les Quatre Nobles Vérités et l’Octuple Sentier — une structure méthodique pour naviguer la souffrance. L’hindouisme offre le concept de dharma — un ordre cosmique qui assigne à chacun un rôle dans le grand tout. Les traditions animistes et chamaniques créent un réseau de liens entre l’humain, la nature et les esprits — un maillage de sens là où il pourrait n’y avoir que du vide.

Dans chaque cas, le mécanisme est le même : face à un univers qui semble chaotique et indifférent, la spiritualité crée un récit structurant qui réduit l’angoisse de l’infini. Elle transforme “tout est possible et rien n’a de sens” en “voici le chemin, voici la raison, voici ta place”.

L’anti-entropie des rituels

Les religions ne se contentent pas de fournir des réponses intellectuelles. Elles structurent aussi le temps et le comportement [16] — deux dimensions où l’entropie nous guette en permanence.

La prière cinq fois par jour dans l’islam. Le shabbat hebdomadaire dans le judaïsme. La messe dominicale dans le christianisme. Les cycles de méditation dans le bouddhisme. Les jeûnes, les fêtes, les pèlerinages. Tous ces rituels font exactement la même chose : ils imposent un rythme ordonné sur le flux chaotique de l’existence. Ils sont des métronomes anti-entropiques.

Sans rituel, les jours se confondent. Le temps perd sa structure. Le sens s’effrite. C’est d’ailleurs ce que beaucoup de personnes non religieuses redécouvrent aujourd’hui : le besoin de rituels laïques — méditation matinale, journaling, routines sportives — pour maintenir un ordre intérieur. La forme a changé, mais la fonction anti-entropique reste la même.

Et les rituels collectifs ajoutent une dimension supplémentaire : ils synchronisent le chaos intérieur de milliers d’individus en une expérience commune ordonnée [15]. Une prière collective, un chant partagé, un silence observé ensemble — ce sont des moments où l’entropie sociale est temporairement réduite à presque zéro. Tout le monde ressent la même chose, au même moment, dans le même lieu. C’est extraordinairement puissant. Et c’est quelque chose qu’aucune technologie n’a réussi à reproduire.

La foi : accepter le chaos pour le transcender

Mais il y a un paradoxe fascinant dans la spiritualité, qui la distingue de toutes les autres formes de lutte anti-entropique.

La science réduit l’entropie en éliminant l’incertitude : elle mesure, elle prouve, elle vérifie. La technologie réduit l’entropie en contrôlant : elle automatise, elle optimise, elle prévoit. La religion, elle, fait quelque chose de radicalement différent : elle réduit l’entropie en acceptant l’incompréhensible.

Croire, c’est reconnaître qu’on ne comprend pas tout — et trouver la paix dans cette acceptation. C’est vivre avec le mystère sans être détruit par lui. C’est la forme la plus paradoxale d’anti-entropie : créer de l’ordre intérieur non pas en éliminant le chaos, mais en lui donnant un statut. Le mystère n’est plus une menace — il devient sacré.

C’est exactement ce que l’IA ne peut pas faire. Une IA face à l’incertitude fait une de deux choses : elle calcule une probabilité, ou elle signale qu’elle manque de données. Elle ne peut pas accepter le mystère. Elle ne peut pas trouver de la beauté dans ce qu’elle ne comprend pas. Elle ne peut pas être émue par l’infini.

La quête spirituelle est peut-être la preuve ultime de notre nature entropique. Nous cherchons un sens parce que nous vivons dans le chaos. Nous prions, nous méditons, nous croyons parce que notre chaos intérieur — nos peurs, notre conscience de la mort, notre besoin viscéral de comprendre — nous y pousse. La machine n’a pas cette quête, parce qu’elle n’a pas ce chaos. Elle n’a pas besoin de Dieu, parce qu’elle n’a pas besoin de sens. Et peut-être que c’est ça, la différence la plus profonde entre l’homme et la machine : non pas l’intelligence, non pas les émotions, mais la capacité de chercher quelque chose qu’on ne trouvera peut-être jamais — et de continuer à chercher quand même.

La dualité humaine : ce que la machine ne peut pas être

L’être humain n’est pas un être d’ordre. Il n’est pas non plus un être de chaos. Il est le champ de bataille entre les deux. Et c’est cette tension — cette oscillation permanente entre structure et désordre — qui produit ce qu’on appelle l’expérience humaine.

La créativité naît de cette tension. Un musicien qui ne connaît que la théorie musicale (pur ordre) compose des pièces techniquement parfaites mais sans âme. Un musicien qui ne connaît rien à la théorie (pur chaos) produit du bruit. La musique qui nous touche naît exactement à la frontière entre les deux. Assez de structure pour être compréhensible. Assez de chaos pour être surprenante. C’est exactement ce que l’IA ne fait pas : elle produit de la structure sans le chaos vécu qui la rend émouvante.

Le même principe s’applique à l’innovation. Les avancées les plus révolutionnaires viennent rarement de la pure méthode ou du pur hasard. Elles viennent de cette zone intermédiaire : un esprit structuré qui accepte de se laisser surprendre par l’inattendu. Penicilline, post-it, micro-ondes — toutes des découvertes nées de la rencontre entre un système ordonné et un accident chaotique. Une IA peut optimiser un processus de recherche. Mais elle ne peut pas avoir l’accident heureux qui change tout, parce qu’elle n’a pas de corps qui trébuche, de main qui glisse, d’attention qui dérive vers une anomalie fascinante.

Même nos relations humaines obéissent à cette logique. Une relation trop ordonnée — trop prévisible, trop contrôlée — étouffe. Une relation trop chaotique — sans repères, sans engagement — épuise. Les relations qui durent sont celles qui trouvent cet équilibre dynamique entre stabilité et surprise. L’IA peut simuler une conversation. Elle ne peut pas vivre une relation, parce qu’une relation implique le risque du chaos émotionnel — et ce risque est ce qui lui donne sa valeur.

L’avenir : ni remplacement ni opposition, mais complémentarité

Si l’IA est le canal et l’humain le fleuve, alors l’avenir n’est ni dans le remplacement de l’un par l’autre, ni dans leur opposition, mais dans leur complémentarité.

L’IA excelle dans ce que nous faisons mal : traiter des volumes massifs d’information, maintenir une attention constante, éliminer les biais cognitifs, optimiser des systèmes complexes. Elle est un amplificateur anti-entropique sans précédent.

L’humain excelle dans ce que l’IA ne peut pas faire : donner un sens, ressentir, comprendre l’autre, naviguer l’ambiguïté, créer à partir du vécu, prendre des décisions dans l’incertitude totale. Il est le générateur de sens dans un monde que la machine peut ordonner mais pas comprendre.

Le chirurgien de demain utilisera l’IA pour planifier ses opérations avec une précision surhumaine — et fera la différence quand le plan échouera. L’enseignant utilisera l’IA pour personnaliser chaque parcours d’apprentissage — et inspirera ses élèves par sa passion, son humanité, ses propres doutes. Le développeur utilisera l’IA pour écrire du code plus vite — et apportera la compréhension profonde du problème humain que le code doit résoudre. L’artiste utilisera l’IA comme un pinceau extraordinaire — et fournira la vision, la douleur et la beauté qui donnent à l’œuvre sa raison d’exister.

Dans chaque métier, la même dynamique : la machine réduit l’entropie, l’humain lui donne un sens.

Ce que l’entropie nous apprend sur le sens

Si tout tend vers le désordre, si chaque acte d’ordre est temporaire et coûteux, à quoi bon ?

C’est peut-être la mauvaise question. La bonne question serait : est-ce que le sens n’émerge pas précisément de cette lutte ?

Le philosophe Albert Camus imaginait Sisyphe heureux [10] — cet homme condamné à pousser un rocher en haut d’une montagne pour le voir redescendre éternellement. L’absurdité de la tâche ne la rend pas vide de sens. C’est dans la lutte elle-même que Sisyphe trouve sa dignité.

Nous sommes tous Sisyphe. Le chirurgien soigne des patients qui retomberont malades. L’enseignant forme des esprits qui oublieront. Le développeur écrit du code qui deviendra obsolète. Le manager organise des équipes qui se réorganiseront. L’artiste crée des œuvres que le temps altérera. L’agriculteur cultive des champs que les saisons ravageront.

Et pourtant, nous continuons. Non pas parce que nous ignorons l’entropie, mais parce que la lutte contre elle est ce qui nous définit.

L’IA ne peut pas être Sisyphe. Elle n’a pas de rocher. Elle n’a pas de montagne. Elle n’a pas la conscience de l’absurdité de la tâche ni la dignité de la poursuivre quand même. Elle peut pousser plus fort, plus vite, plus longtemps que nous. Mais elle ne sait pas pourquoi elle pousse. Et c’est le “pourquoi” qui fait de Sisyphe un héros.

L’entropie nous dit que rien ne dure. Mais elle nous dit aussi que tout ce qui existe de beau, de vrai, de bon, a été arraché au chaos par un effort conscient. Et ça, c’est peut-être la définition la plus honnête du sens — une définition que seul un être qui connaît le chaos peut comprendre.

Conclusion : Ce que la machine nous apprend sur nous-mêmes

Il est ironique que ce soit l’avènement de l’intelligence artificielle qui nous force à nous poser la question la plus humaine qui soit : qu’est-ce qui nous rend irremplaçables ?

La réponse, vue à travers le prisme de l’entropie, est limpide. Ce n’est pas notre intelligence — la machine est déjà plus rapide. Ce n’est pas notre mémoire — la machine est déjà plus vaste. Ce n’est pas notre logique — la machine est déjà plus rigoureuse.

Ce qui nous rend irremplaçables, c’est notre chaos. Nos émotions, notre mortalité, notre corps, nos contradictions, nos peurs, nos espoirs irrationnels, notre quête de sens face à l’absurde. Tout ce désordre intérieur que nous passons notre vie à essayer de dompter — par l’intelligence, par les émotions, par la spiritualité, par le travail — c’est précisément ce qui donne à notre intelligence sa profondeur, à notre créativité sa puissance, à notre existence son sens.

L’entropie n’est pas notre ennemie. Elle est la toile de fond contre laquelle tout ce qui a de la valeur se dessine. Sans elle, il n’y aurait pas besoin de soigner, d’enseigner, de construire, de créer, d’aimer. Le sens n’existe que parce que le désordre le menace.

La machine est notre alliée dans cette lutte. Elle amplifie notre capacité à créer de l’ordre. Mais elle ne peut pas mener le combat à notre place, parce que le combat n’est pas que contre le désordre extérieur — il est aussi contre le désordre intérieur. Et c’est de ce combat-là, intime, douloureux, permanent — le même combat que mène le moine en prière, l’artiste devant sa toile, le parent qui console son enfant à trois heures du matin — que naît tout ce qui fait de nous des êtres humains.

Alors la prochaine fois que vous vous sentirez submergé par le chaos — au travail, dans votre tête, dans votre vie — rappelez-vous ceci : vous n’êtes pas en train d’échouer. Vous êtes en train de faire exactement ce que la vie fait depuis 3,8 milliards d’années. Vous résistez à l’entropie. Et le simple fait que vous soyez là, conscient, en train de lire ces mots, capables de ressentir quelque chose en les lisant — ça, aucune machine ne peut le faire. Et c’est déjà tout.

Cet essai est né d’une conversation exploratoire entre un humain et une intelligence artificielle sur la nature de l’entropie. Les intuitions, les doutes et les connexions inattendues sont humains — le chaos créatif. La structuration, le développement et la rédaction ont été assistés par Claude (Anthropic) — l’anti-entropie informationnelle. Ni l’un ni l’autre n’aurait produit ce texte seul. Et c’est peut-être ça, l’avenir : non pas l’homme contre la machine, mais l’homme avec la machine, dans une danse entre ordre et chaos qui produit quelque chose qu’aucun des deux ne pourrait créer séparément. Les sources ci-dessous ont été vérifiées par l’auteur.

Sources et références

Thermodynamique et entropie

[1] Schrödinger, E. (1944). What is Life? The Physical Aspect of the Living Cell. Cambridge University Press. — Le concept d’entropie négative (negentropy) comme moteur de la vie.

[2] Boltzmann, L. (1877). Über die Beziehung zwischen dem zweiten Hauptsatze der mechanischen Wärmetheorie und der Wahrscheinlichkeitsrechnung. — La formulation statistique de l’entropie (S = k·log W).

[3] Shannon, C.E. (1948). “A Mathematical Theory of Communication.” Bell System Technical Journal, 27(3), 379–423. — Le lien entre entropie informationnelle et physique.

Intelligence et entropie

[4] Wissner-Gross, A.D. & Freer, C.E. (2013). “Causal Entropic Forces.” Physical Review Letters, 110(16). — L’intelligence comme maximisation des options futures.

[5] Beggs, J.M. & Plenz, D. (2003). “Neuronal Avalanches in Neocortical Circuits.” Journal of Neuroscience, 23(35), 11167–11177. — La criticité neurale : le cerveau au bord du chaos.

Émotions et prise de décision

[6] Damasio, A. (1994). Descartes’ Error: Emotion, Reason, and the Human Brain. Putnam Publishing. — L’hypothèse des marqueurs somatiques : sans émotions, pas de décision.

[7] Damasio, A. (1999). The Feeling of What Happens: Body and Emotion in the Making of Consciousness. Harcourt Brace. — Le rôle des émotions dans la conscience.

Cognition incarnée

[8] Varela, F.J., Thompson, E. & Rosch, E. (1991). The Embodied Mind: Cognitive Science and Human Experience. MIT Press. — L’intelligence n’est pas que dans le cerveau, elle est dans le corps.

[9] Clark, A. (1997). Being There: Putting Brain, Body, and World Together Again. MIT Press. — Le corps et l’environnement comme participants actifs de la cognition.

Philosophie et sens

[10] Camus, A. (1942). Le Mythe de Sisyphe. Gallimard. — L’absurde et la dignité de la lutte.

[11] Épictète. Manuel (Enchiridion). ~125 apr. J.-C. — Les fondements du stoïcisme.

IA et coût écologique

[12] Strubell, E., Ganesh, A. & McCallum, A. (2019). “Energy and Policy Considerations for Deep Learning in NLP.” Proceedings of the 57th Annual Meeting of the ACL. — Le coût énergétique des grands modèles.

Religion et anthropologie

[15] Durkheim, É. (1912). Les Formes élémentaires de la vie religieuse. Félix Alcan. — La religion comme fait social structurant.

[16] Eliade, M. (1957). Le Sacré et le Profane. Gallimard. — Temps sacré (ordonné) vs temps profane (chaotique).

Pourquoi Cette Intégration Change la Donne

Jusqu’à présent, Claude Code nécessitait obligatoirement une connexion aux serveurs d’Anthropic. Avec cette intégration Ollama, vous pouvez maintenant :

Prérequis

1. Ollama v0.14.0+

L’intégration nécessite Ollama version 0.14.0 ou supérieure. Vérifiez votre version :

ollama --version

Si besoin, mettez à jour Ollama depuis ollama.com.

2. Modèle avec Grand Contexte

Claude Code nécessite une grande fenêtre de contexte pour fonctionner correctement. La recommandation officielle est 64k tokens minimum.

Configurez le contexte dans Ollama :

# Créer un Modelfile avec contexte étendu
cat > Modelfile << 'EOF'
FROM qwen3-coder
PARAMETER num_ctx 65536
EOF

ollama create qwen3-coder-64k -f Modelfile

3. Claude Code Installé

Si ce n’est pas encore fait :

# macOS/Linux
curl -fsSL https://claude.ai/install.sh | bash

# Windows
irm https://claude.ai/install.ps1 | iex

Configuration

Méthode 1 : Lancement Rapide (Recommandé)

Ollama fournit une commande simplifiée :

ollama launch claude

Pour le mode configuration interactive :

ollama launch claude --config

Cette méthode configure automatiquement les variables d’environnement nécessaires.

Méthode 2 : Configuration Manuelle

Définissez les trois variables d’environnement requises :

export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL=http://localhost:11434

Puis lancez Claude Code avec le modèle de votre choix :

claude --model qwen3-coder-64k

Méthode 3 : Ligne Unique

Pour un lancement ponctuel sans modifier votre environnement :

ANTHROPIC_AUTH_TOKEN=ollama \
ANTHROPIC_BASE_URL=http://localhost:11434 \
ANTHROPIC_API_KEY="" \
claude --model qwen3-coder

Configuration Persistante

Ajoutez ces lignes à votre ~/.bashrc ou ~/.zshrc :

# Claude Code avec Ollama
export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL=http://localhost:11434
alias claude-local='claude --model qwen3-coder-64k'

Puis rechargez :

source ~/.bashrc  # ou source ~/.zshrc

Modèles Recommandés

Pour le Développement

Pour les Machines Puissantes

Télécharger un Modèle

# Télécharger le modèle
ollama pull qwen3-coder

# Vérifier les modèles disponibles
ollama list

Exemple de Session

# 1. Démarrer Ollama (si pas en service)
ollama serve &

# 2. Lancer Claude Code
ANTHROPIC_AUTH_TOKEN=ollama \
ANTHROPIC_BASE_URL=http://localhost:11434 \
ANTHROPIC_API_KEY="" \
claude --model qwen3-coder

# 3. Utiliser normalement
> Analyse le fichier @src/api/users.ts et suggère des améliorations

Limitations à Connaître

Performance

Les modèles locaux sont généralement moins performants que Claude Sonnet ou Opus sur les tâches complexes. Attendez-vous à :

• Réponses parfois moins précises
• Temps de réflexion plus long sur du matériel modeste
• Moins de capacité de raisonnement avancé

Consommation Ressources

Fonctionnalités

Certaines fonctionnalités avancées peuvent ne pas fonctionner parfaitement :

• Vision (analyse d’images)
• Tool use complexe
• Subagents

Cas d’Usage Idéaux

Quand Utiliser Ollama

• Code propriétaire sensible : Le code ne quitte jamais votre machine
• Développement offline : Travail en avion, zones sans internet
• Prototypage rapide : Pas de souci de coûts API
• Apprentissage : Expérimentez sans limite

Quand Rester sur Anthropic

• Tâches complexes : Refactoring majeur, architecture
• Code reviews approfondies : Analyse de sécurité
• Production : Quand la qualité est critique

Basculer Entre Local et Cloud

Créez des alias pour switcher facilement :

# Dans ~/.bashrc ou ~/.zshrc

# Mode Ollama (local)
alias claude-local='ANTHROPIC_AUTH_TOKEN=ollama \
  ANTHROPIC_BASE_URL=http://localhost:11434 \
  ANTHROPIC_API_KEY="" \
  claude --model qwen3-coder-64k'

# Mode Anthropic (cloud) - nécessite ANTHROPIC_API_KEY configuré
alias claude-cloud='claude'

Usage :

claude-local   # Pour le travail sensible ou offline
claude-cloud   # Pour les tâches complexes

Troubleshooting

Erreur “Connection Refused”

Ollama n’est pas démarré :

ollama serve

Erreur “Context Too Long”

Le modèle n’a pas assez de contexte. Créez une version étendue :

cat > Modelfile << 'EOF'
FROM votre-modele
PARAMETER num_ctx 65536
EOF

ollama create votre-modele-64k -f Modelfile

Réponses Lentes

• Vérifiez que le GPU est utilisé : nvidia-smi ou ollama ps
• Utilisez un modèle plus petit
• Fermez les applications gourmandes en VRAM

Qualité Insuffisante

Essayez un modèle plus grand ou repassez sur Claude Cloud pour cette tâche spécifique.

Conclusion

L’intégration Ollama ouvre de nouvelles possibilités pour Claude Code :

• Confidentialité pour le code sensible
• Économies sur les coûts API
• Flexibilité dans le choix des modèles
• Travail offline possible

Pour la plupart des tâches quotidiennes, un bon modèle local comme qwen3-coder fait très bien le travail. Gardez l’accès au cloud Anthropic pour les cas où vous avez besoin de la puissance maximale.

Pour aller plus loin avec Claude Code, consultez mes autres articles sur l’IA et le développement.

Why This Integration Is a Game Changer

Until now, Claude Code required a connection to Anthropic’s servers. With this Ollama integration, you can now:

Requirements

1. Ollama v0.14.0+

The integration requires Ollama version 0.14.0 or higher. Check your version:

ollama --version

If needed, update Ollama from ollama.com.

2. Model with Large Context

Claude Code requires a large context window to work properly. The official recommendation is 64k tokens minimum.

Configure context in Ollama:

# Create a Modelfile with extended context
cat > Modelfile << 'EOF'
FROM qwen3-coder
PARAMETER num_ctx 65536
EOF

ollama create qwen3-coder-64k -f Modelfile

3. Claude Code Installed

If not already done:

# macOS/Linux
curl -fsSL https://claude.ai/install.sh | bash

# Windows
irm https://claude.ai/install.ps1 | iex

Configuration

Method 1: Quick Launch (Recommended)

Ollama provides a simplified command:

ollama launch claude

For interactive configuration mode:

ollama launch claude --config

This method automatically configures the necessary environment variables.

Method 2: Manual Configuration

Set the three required environment variables:

export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL=http://localhost:11434

Then launch Claude Code with your chosen model:

claude --model qwen3-coder-64k

Method 3: Single Line

For a one-time launch without modifying your environment:

ANTHROPIC_AUTH_TOKEN=ollama \
ANTHROPIC_BASE_URL=http://localhost:11434 \
ANTHROPIC_API_KEY="" \
claude --model qwen3-coder

Persistent Configuration

Add these lines to your ~/.bashrc or ~/.zshrc:

# Claude Code with Ollama
export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL=http://localhost:11434
alias claude-local='claude --model qwen3-coder-64k'

Then reload:

source ~/.bashrc  # or source ~/.zshrc

Recommended Models

For Development

For Powerful Machines

Download a Model

# Download the model
ollama pull qwen3-coder

# Check available models
ollama list

Example Session

# 1. Start Ollama (if not running)
ollama serve &

# 2. Launch Claude Code
ANTHROPIC_AUTH_TOKEN=ollama \
ANTHROPIC_BASE_URL=http://localhost:11434 \
ANTHROPIC_API_KEY="" \
claude --model qwen3-coder

# 3. Use normally
> Analyze the file @src/api/users.ts and suggest improvements

Limitations to Know

Performance

Local models are generally less performant than Claude Sonnet or Opus on complex tasks. Expect:

• Sometimes less accurate responses
• Longer thinking time on modest hardware
• Less advanced reasoning capability

Resource Consumption

Features

Some advanced features may not work perfectly:

• Vision (image analysis)
• Complex tool use
• Subagents

Ideal Use Cases

When to Use Ollama

• Sensitive proprietary code: Code never leaves your machine
• Offline development: Work on planes, areas without internet
• Rapid prototyping: No API cost concerns
• Learning: Experiment without limits

When to Stay on Anthropic

• Complex tasks: Major refactoring, architecture
• In-depth code reviews: Security analysis
• Production: When quality is critical

Switching Between Local and Cloud

Create aliases to easily switch:

# In ~/.bashrc or ~/.zshrc

# Ollama mode (local)
alias claude-local='ANTHROPIC_AUTH_TOKEN=ollama \
  ANTHROPIC_BASE_URL=http://localhost:11434 \
  ANTHROPIC_API_KEY="" \
  claude --model qwen3-coder-64k'

# Anthropic mode (cloud) - requires ANTHROPIC_API_KEY configured
alias claude-cloud='claude'

Usage:

claude-local   # For sensitive or offline work
claude-cloud   # For complex tasks

Troubleshooting

“Connection Refused” Error

Ollama is not started:

ollama serve

“Context Too Long” Error

The model doesn’t have enough context. Create an extended version:

cat > Modelfile << 'EOF'
FROM your-model
PARAMETER num_ctx 65536
EOF

ollama create your-model-64k -f Modelfile

Slow Responses

• Check that GPU is being used: nvidia-smi or ollama ps
• Use a smaller model
• Close VRAM-hungry applications

Insufficient Quality

Try a larger model or switch back to Claude Cloud for that specific task.

Conclusion

The Ollama integration opens new possibilities for Claude Code:

• Privacy for sensitive code
• Savings on API costs
• Flexibility in model choice
• Offline work possible

For most daily tasks, a good local model like qwen3-coder does the job very well. Keep access to Anthropic’s cloud for cases where you need maximum power.

To go further with Claude Code, check out my other articles on AI and development.

This article offers a methodical deconstruction of the dominant narrative about AI and developer replacement, drawing on recent scientific studies, economic data, analyses from researchers like Tim Dettmers (Ai2) on hardware physical limits, and a relevant video analysis by Melvynx — a French developer and tech content creator with over 100,000 subscribers — on the subject.

The Trap of “Impressive” Demos

Misleading Demonstrations

Social media is flooded with videos showing websites created in minutes by AI. These demos, often shared by influencers seeking virality, present several fundamental problems:

• Code unusable in production: the visual result often hides fragile architecture
• Optimized context: prompts are carefully prepared to maximize the effect
• No maintenance shown: nobody shows how the project evolves 6 months later
• Simplified use cases: real projects involve complex business constraints

Defining “Replacement”

For AI to truly replace a developer, it would need to demonstrate near-total autonomy. Replacing a team of 6 developers with 1 developer managing 5 AI agents would require those agents to function without constant supervision.

However, if the developer must prompt and manage AI 24/7, correct their errors, and validate every decision, it would be more productive to keep human developers assisted by AI. The real productivity gain doesn’t justify the headcount reduction promised by marketing narratives.

The METR Study: The Reality of AI Productivity

19% Slower with AI

A randomized controlled trial by METR (Model Evaluation & Threat Research) published in July 2025 measured the real impact of AI tools on experienced developer productivity. The results are counter-intuitive: developers using AI took 19% longer to complete their tasks than those working without assistance.

The study recruited 16 experienced developers working on major open-source repositories (averaging 22,000+ stars and 1 million+ lines of code). Each developer handled real issues, randomly assigned with or without access to AI tools (primarily Cursor Pro with Claude 3.5/3.7 Sonnet).

The Gap Between Perception and Reality

The most striking result concerns the gap between perception and reality:

As TechCrunch notes: “When AI is allowed, developers spend less time actively coding and searching for information, and instead spend time prompting AI, waiting on and reviewing AI outputs, and idle.”

One developer participating in the study reported having “wasted at least an hour first trying to solve a specific issue with AI” before eventually reverting all code changes and just implementing it without AI assistance.

Confirmation by Google DORA

These results align with Google’s 2024 DORA report: while 75% of developers feel more productive with AI tools, every 25% increase in AI adoption corresponds to a 1.5% drop in delivery speed and a 7.2% drop in system stability.

The Myth of Near-Term AGI

What AGI Actually Requires

Artificial General Intelligence (AGI) represents a system capable of:

• Reasoning about user experience and making design decisions
• Understanding business constraints specific to each project
• Learning from mistakes persistently (not crashing the database again after a first failure)
• Adapting to context without needing detailed instructions for each interaction

These capabilities remain out of reach for current models, despite their impressive performance on specific tasks.

Expert Predictions: A Fragile Consensus

According to an analysis by 80,000 Hours compiling expert predictions, estimates vary considerably:

Notably, the most optimistic predictions consistently come from executives at companies with a direct financial interest in the AGI narrative, while the academic community remains more measured.

As AIMultiple notes, in just four years, the average Metaculus estimate for AGI arrival has dropped from 50 years to 5 years. This volatility reflects media hype more than measurable technical advances.

The History of Failed Predictions

This volatility is nothing new. AI history is littered with bold predictions that never materialized:

This recurring pattern — confident experts perpetually pushing back their predictions — should encourage caution toward current announcements.

The Financial Interest Behind AGI Discourse

OpenAI’s financial figures illuminate the marketing narrative around AGI. According to CNBC and LessWrong:

OpenAI Financial Losses:

• 2024: $5 billion in losses on $3.7 billion in revenue
• First half 2025: $13.5 billion in losses on $4.3 billion in revenue
• Training costs alone: $3 billion in 2024 (exceeding subscription revenue)
• HSBC projection: even with $200 billion in revenue by 2030, OpenAI will need an additional $207 billion to survive

To justify massive investments and astronomical valuations, AI companies must sell a grand vision: AGI that will transform the world. Announcing “AI is gradually improving on certain tasks” isn’t enough to raise billions.

This dynamic echoes the analysis I proposed in my article on Sam Altman’s statements about the AI bubble, where OpenAI’s CEO himself acknowledged the existence of a speculative bubble.

AGI as a “Silicon Valley Fantasy”

Tim Dettmers, researcher at Ai2 (Allen Institute for AI) and recognized for his work on language model optimization and quantization (notably the QLoRA format widely used for efficient fine-tuning), provides an academic counterweight to Silicon Valley’s optimistic predictions. He bluntly describes superintelligent AI as a “fantasy” and the pursuit of AGI as a “chimera.”

His central argument: true AGI would need to accomplish complex physical tasks, which requires economically viable advanced robots — a reality far from being achieved. This vision contrasts with China’s pragmatic approach, which prioritizes useful current applications rather than racing toward a hypothetical artificial general intelligence.

Technical Stagnation of Models

No Architectural Revolution Since the Transformer

Contrary to marketing narrative, fundamental advances remain limited. According to Wikipedia and Data Science Dojo, all major current models (GPT-4, Claude, Gemini, LLaMA) use the Transformer architecture introduced in 2017.

OpenAI did not publish technical details of GPT-4, explicitly refusing to specify model size, architecture, or hardware used. What has actually evolved is the environment around the model:

“Reasoning” Demystified: A Mirage?

An August 2025 study titled “Is Chain-of-Thought Reasoning of LLMs a Mirage?” concludes that CoT reasoning is a “brittle mirage” that collapses as soon as you leave training distributions.

According to IBM and a Wharton study, Chain of Thought limitations are significant:

• Fragility: minor and semantically insignificant perturbations cause significant performance drops
• Illusion of transparency: final answers often remain unchanged even when intermediate steps are falsified or omitted
• Time cost: 20-80% additional time for marginal gains on reasoning models
• Increased variability: CoT can introduce errors on “easy” questions the model would otherwise solve correctly

As Wharton’s research summarizes: “These findings challenge the assumption that CoT is universally beneficial.”

Insurmountable Barriers: The Scaling Problem

Five Fundamental Limitations Identified

A November 2025 research paper identifies five fundamental limitations that bound LLM scaling gains:

1. Hallucination: generating false information with confidence
2. Context compression: information loss in long contexts
3. Reasoning degradation: declining performance on complex problems
4. Retrieval fragility: inconsistency in accessing knowledge
5. Multimodal misalignment: inconsistencies between modalities

The “Curse of Complexity”

Research using the ZebraLogic framework reveals a significant decline in accuracy as problem complexity increases. This limitation persists even with larger models and more inference-time computation, suggesting inherent constraints in current LLM reasoning capabilities.

The Economic and Energy Wall

According to Dr. Adnan Masood, AI solutions architect and researcher, and recent research:

• Physical limits: we’re approaching per-chip performance limits as Moore’s Law slows
• Astronomical costs: over $100 million to train GPT-4
• Limited data: quality text data is running out, forcing reliance on synthetic data
• Diminishing returns: frontier models (OpenAI, Anthropic, Google, Meta) show smaller performance jumps despite massive training budgets

I analyzed this energy issue in my article on AI’s ecological impact.

The Physical Limits of Hardware

Tim Dettmers provides technical insight into unavoidable hardware constraints. His assessment is stark: “We may have one or two years left for scaling before further improvements become physically impossible.”

The numbers are telling:

According to Dettmers, GPUs reached their maximum efficiency around 2018. Since then, they’ve only added “one-off features that are quickly exhausted.” Maintaining similar progress “requires an exponential increase in computation, energy, and infrastructure costs.” Previously, exponential hardware growth compensated for these needs — that’s no longer the case.

The Real State of the Job Market

Bureau of Labor Statistics Data

Contrary to catastrophist narrative, the U.S. Bureau of Labor Statistics projects 17.9% growth in software developer employment between 2023 and 2033, well above the 4% average for all occupations.

These projections align with Tim Dettmers’ estimate that only 11% of jobs are currently replaceable by AI — far from the apocalyptic predictions circulating on social media.

Explosion of AI Positions

According to Veritone and GetAura, the first half of 2025 saw an explosion in AI-related job postings:

AI positions now represent 10-12% of all software jobs, a sign that AI is integrating into the industry rather than replacing it.

Rising Salaries

According to IEEE Spectrum:

• Median AI salary (Q1 2025): $156,998/year (+0.8% quarter over quarter)
• Top AI researchers: Meta offering packages of $10-20 million
• Fastest growth: AI/Machine Learning Engineer (+41.8% year over year)

AI Adoption by Developers

According to the JetBrains 2025 report:

• 85% of developers regularly use AI tools
• 62% rely on at least one AI coding assistant
• 89% save at least one hour per week thanks to AI
• 68% expect employers to require AI tool proficiency

Decoding the Indeed Graph

A graph from Indeed showing a drop in tech job postings in the United States regularly circulates to fuel catastrophist narrative. This reading deserves contextualization:

What the graph shows: an index based on year 2020 = 100.

What it actually means: the current “drop” simply brings the market back to February 2020 levels, just before the abnormal Covid-19 pandemic spike. The 2020 tech job market was considered robust and healthy.

My Experience: Over a Year of Augmented Development

As a developer who has been practicing AI-augmented development for over a year, my daily experience confirms the conclusions of the studies cited. I condensed this practice into a 20-article series on Claude Code, with a documented concrete project: recreating a complete game in TypeScript.

What over a year of practice taught me:

• AI excels at repetitive tasks, scaffolding, test generation, and documentation
• AI fails at architecture decisions, business edge cases, and fine-tuning optimization
• Structured workflow (Explore → Plan → Code → Test) transforms a hit-or-miss tool into an effective partner
• Supervision remains essential: every generation requires review and validation

As I summarize in the final case study: “Claude Code is not a developer replacement, but a productivity multiplier.”

My example project cost ($120 for 5000 lines of code) illustrates the value proposition — but also the necessity of human expertise to guide, validate, and correct AI at every step.

Conclusion: AI as a Tool, Not a Replacement

Recent data paints a nuanced picture far from alarmist predictions:

What studies show:

• AI can slow down experienced developers by 19% in certain contexts
• Chain of Thought is a “brittle mirage” that collapses outside training cases
• The developer job market is growing 17.9% over 10 years
• OpenAI is losing billions, fueling a financially motivated AGI narrative
• GPUs reached maximum efficiency around 2018 and hardware physical limits are approaching
• Only 11% of jobs are currently replaceable by AI

What this implies:

• AI tools are useful but don’t replace human expertise
• The “human-in-the-loop” paradigm remains essential for production-quality code
• The profession is evolving toward more architecture and less “boilerplate code”
• Developers mastering AI will have a competitive advantage

The human-in-the-loop concept is not a temporary limitation while waiting for more advanced AI — it’s a structural necessity. Even the most sophisticated AI systems require human oversight for critical decisions, contextual validation, and final accountability. Developers are becoming orchestrators who guide, correct, and validate the AI’s work.

As Tim Dettmers, researcher at Ai2, emphasizes, AGI remains a “Silicon Valley fantasy” — a chimera that contrasts with the pragmatic approach of prioritizing useful current applications. The narrative about imminent developer replacement stems more from marketing and trend-following than from rigorous technical analysis. Wisdom recommends adopting these technologies while maintaining critical thinking, continuing to develop fundamental skills, and not succumbing to panic fueled by misleading demos and financially motivated projections.

Key Takeaways

The 4 key figures from this article:

• -19%: AI slows down experienced developers (METR study)
• 11%: Share of jobs currently replaceable by AI (Dettmers)
• +17.9%: Projected developer employment growth 2023-2033 (BLS)
• 2018: Year when GPUs reached maximum efficiency

Year-End Review

As 2025 draws to a close, the landscape of AI in software development is becoming clearer. Far from the apocalyptic prophecies of early in the year, we now have concrete data to assess the real impact of these technologies.

2025 will have been the year of demystification: rigorous studies revealed the limitations of AI tools, the colossal financial losses of industry giants exposed the fragility of their business model, and developers on the ground learned to distinguish media hype from daily reality.

For 2026, my advice remains the same: learn to use these tools, but never stop developing your fundamental skills. AI is an excellent assistant — not a replacement.

Happy New Year 2026 to all developers! May this new year bring you exciting projects, quickly resolved bugs, and serenity in the face of the alarmist predictions that will undoubtedly continue to flourish.

What was your experience with AI in 2025? Share your thoughts in the comments or on social media.

Sources

1. Melvynx - Will AI replace developers? - YouTube

2. METR - Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity - METR

3. AI coding tools may not speed up every developer - TechCrunch

4. AI coding tools can slow down seasoned developers by 19% - InfoWorld

5. Shrinking AGI timelines: a review of expert forecasts - 80,000 Hours

6. When Will AGI/Singularity Happen? 8,590 Predictions Analyzed - AIMultiple

7. OpenAI sees roughly $5 billion loss this year on $3.7 billion in revenue - CNBC

8. OpenAI lost $5 billion in 2024 (and its losses are increasing) - LessWrong

9. Is Chain-of-Thought Reasoning of LLMs a Mirage? - arXiv

10. The Decreasing Value of Chain of Thought in Prompting - Wharton

11. On the Fundamental Limits of LLMs at Scale - arXiv

12. ZebraLogic: On the Scaling Limits of LLMs for Logical Reasoning - arXiv

13. AI impacts in BLS employment projections - Bureau of Labor Statistics

14. AI Jobs on the Rise: Q1 2025 Labor Market Analysis - Veritone

15. New AI Job Market Data (Through June 2025) - GetAura

16. AI Jobs in 2025: Essential Insights for Software Engineers - IEEE Spectrum

17. The State of Developer Ecosystem 2025 - JetBrains

18. GPT-4 - Wikipedia

19. What is chain of thought (CoT) prompting? - IBM

20. Superintelligent AI is a Silicon Valley Fantasy - Tim Dettmers (Ai2) - Developpez.com

21. Is there a Wall? - Dr. Adnan Masood - Dr. Adnan Masood (AI solutions architect)

Cet article propose une déconstruction méthodique du discours dominant sur l’IA et le remplacement des développeurs, s’appuyant sur des études scientifiques récentes, des données économiques, les analyses de chercheurs comme Tim Dettmers (Ai2) sur les limites physiques du hardware, et une analyse vidéo pertinente de Melvynx — développeur français et créateur de contenu tech suivi par plus de 100 000 abonnés — sur le sujet.

Le Piège des Démos “Impressionnantes”

Des Démonstrations Trompeuses

Les réseaux sociaux regorgent de vidéos montrant des sites web créés en quelques minutes par l’IA. Ces démos, souvent relayées par des influenceurs en quête de viralité, présentent plusieurs problèmes fondamentaux :

• Code non utilisable en production : le résultat visuel cache souvent une architecture fragile
• Contexte optimisé : les prompts sont soigneusement préparés pour maximiser l’effet
• Absence de maintenance : personne ne montre l’évolution du projet 6 mois plus tard
• Cas d’usage simplifiés : les projets réels impliquent des contraintes métier complexes

La Définition du “Remplacement”

Pour qu’une IA remplace véritablement un développeur, elle devrait démontrer une autonomie quasi-totale. Remplacer une équipe de 6 développeurs par 1 développeur pilotant 5 agents IA nécessiterait que ces agents fonctionnent sans supervision constante.

Or, si le développeur doit “prompter” et manager les IA 24h/24, corriger leurs erreurs et valider chaque décision, il serait plus productif de conserver des développeurs humains assistés par l’IA. Le gain de productivité réel ne justifie pas la réduction d’effectifs promises par les discours marketing.

L’Étude METR : La Réalité de la Productivité avec l’IA

19% Plus Lent avec l’IA

Une étude randomisée contrôlée de METR (Model Evaluation & Threat Research) publiée en juillet 2025 a mesuré l’impact réel des outils d’IA sur la productivité des développeurs expérimentés. Les résultats sont contre-intuitifs : les développeurs utilisant l’IA ont mis 19% plus de temps à accomplir leurs tâches que ceux travaillant sans assistance.

L’étude a recruté 16 développeurs expérimentés travaillant sur des repositories open-source majeurs (moyenne de 22 000+ stars et 1 million+ de lignes de code). Chaque développeur a traité des issues réelles, assignées aléatoirement avec ou sans accès aux outils d’IA (principalement Cursor Pro avec Claude 3.5/3.7 Sonnet).

Le Fossé entre Perception et Réalité

Le résultat le plus frappant concerne l’écart entre perception et réalité :

Comme le note TechCrunch : “Quand l’IA est autorisée, les développeurs passent moins de temps à coder activement et à chercher des informations, et plus de temps à prompter l’IA, attendre ses outputs, les vérifier, et rester inactifs.”

Un développeur participant à l’étude témoigne avoir “perdu au moins une heure à essayer de résoudre un problème spécifique avec l’IA” avant de finalement annuler tous les changements et implémenter la solution sans assistance.

Confirmation par Google DORA

Ces résultats s’alignent avec le rapport DORA 2024 de Google : bien que 75% des développeurs se sentent plus productifs avec les outils d’IA, chaque augmentation de 25% dans l’adoption de l’IA correspond à une baisse de 1.5% de la vitesse de livraison et une chute de 7.2% de la stabilité des systèmes.

Le Mythe de l’AGI à Court Terme

Ce que l’AGI Implique Réellement

L’Intelligence Artificielle Générale (AGI) représente un système capable de :

• Réfléchir à l’expérience utilisateur et prendre des décisions de conception
• Comprendre les contraintes métier spécifiques à chaque projet
• Apprendre de ses erreurs de manière persistante (ne pas refaire crasher la base de données après un premier échec)
• S’adapter au contexte sans avoir besoin d’instructions détaillées à chaque interaction

Ces capacités restent hors de portée des modèles actuels, malgré leurs impressionnantes performances sur des tâches spécifiques.

Les Prédictions des Experts : Un Consensus Fragile

Selon une analyse de 80,000 Hours compilant les prédictions d’experts, les estimations varient considérablement :

On remarque que les prédictions les plus optimistes proviennent systématiquement des dirigeants d’entreprises ayant un intérêt financier direct dans le discours AGI, tandis que la communauté académique reste plus mesurée.

Comme le note AIMultiple, en quatre ans seulement, l’estimation moyenne sur Metaculus pour l’arrivée de l’AGI est passée de 50 ans à 5 ans. Cette volatilité reflète davantage l’emballement médiatique que des avancées techniques mesurables.

L’Histoire des Prédictions Échouées

Cette volatilité n’est pas nouvelle. L’histoire de l’IA est jalonnée de prédictions audacieuses qui ne se sont jamais réalisées :

Ce pattern récurrent — des experts confiants repoussant perpétuellement leurs prédictions — devrait inciter à la prudence face aux annonces actuelles.

L’Intérêt Financier du Discours AGI

Les chiffres financiers d’OpenAI éclairent le discours marketing autour de l’AGI. Selon CNBC et LessWrong :

Pertes financières d’OpenAI :

• 2024 : 5 milliards de dollars de pertes pour 3.7 milliards de revenus
• Premier semestre 2025 : 13.5 milliards de pertes pour 4.3 milliards de revenus
• Coût d’entraînement seul : 3 milliards en 2024 (dépassant les revenus d’abonnement)
• Projection HSBC : même avec 200 milliards de revenus d’ici 2030, OpenAI aura besoin de 207 milliards supplémentaires pour survivre

Pour justifier des investissements massifs et des valorisations astronomiques, les entreprises d’IA doivent vendre une vision grandiose : l’AGI qui transformera le monde. Annoncer “l’IA s’améliore progressivement sur certaines tâches” ne suffit pas à lever des milliards.

Cette dynamique rappelle l’analyse que j’avais proposée dans mon article sur les déclarations de Sam Altman concernant la bulle IA, où le PDG d’OpenAI lui-même reconnaissait l’existence d’une bulle spéculative.

L’AGI comme « Fantasme de la Silicon Valley »

Tim Dettmers, chercheur chez Ai2 (Allen Institute for AI) et reconnu pour ses travaux sur l’optimisation des modèles de langage et la quantification (notamment le format QLoRA largement utilisé pour le fine-tuning efficace), apporte un contrepoids académique aux prédictions optimistes de la Silicon Valley. Il qualifie sans détour l’IA superintelligente de « fantasme » et la poursuite de l’AGI de « chimère ».

Son argument central : l’AGI véritable devrait accomplir des tâches physiques complexes, ce qui nécessite des robots avancés économiquement viables — une réalité loin d’être atteinte. Cette vision contraste avec l’approche pragmatique chinoise, qui privilégie les applications utiles actuelles plutôt qu’une course vers une intelligence artificielle générale hypothétique.

La Stagnation Technique des Modèles

Pas de Révolution Architecturale Depuis le Transformer

Contrairement au discours marketing, les avancées fondamentales restent limitées. Selon Wikipedia et Data Science Dojo, tous les modèles majeurs actuels (GPT-4, Claude, Gemini, LLaMA) utilisent l’architecture Transformer introduite en 2017.

OpenAI n’a pas publié les détails techniques de GPT-4, refusant explicitement de spécifier la taille du modèle, l’architecture ou le hardware utilisé. Ce qui a réellement évolué, c’est l’environnement autour du modèle :

Le “Reasoning” Démystifié : Un Mirage ?

Une étude d’août 2025 intitulée “Is Chain-of-Thought Reasoning of LLMs a Mirage?” conclut que le raisonnement CoT est un “mirage fragile” qui s’effondre dès qu’on sort des distributions d’entraînement.

Selon IBM et une étude de Wharton, les limitations du Chain of Thought sont significatives :

• Fragility : des perturbations mineures et sémantiquement insignifiantes causent des chutes de performance importantes
• Illusion de transparence : les réponses finales restent souvent inchangées même quand les étapes intermédiaires sont falsifiées ou omises
• Coût temporel : 20-80% de temps supplémentaire pour des gains marginaux sur les modèles de raisonnement
• Variabilité accrue : le CoT peut introduire des erreurs sur des questions “faciles” que le modèle aurait autrement résolues correctement

Comme le résume la recherche de Wharton : “Ces résultats remettent en question l’hypothèse que le CoT est universellement bénéfique.”

Les Barrières Infranchissables : Le Scaling Problem

Cinq Limitations Fondamentales Identifiées

Une recherche de novembre 2025 identifie cinq limitations fondamentales qui bornent les gains du scaling des LLM :

1. Hallucination : génération d’informations fausses avec confiance
2. Compression du contexte : perte d’information dans les longs contextes
3. Dégradation du raisonnement : performance déclinante sur les problèmes complexes
4. Fragilité de la récupération : inconsistance dans l’accès aux connaissances
5. Désalignement multimodal : incohérences entre modalités

Le “Curse of Complexity”

Les recherches utilisant le framework ZebraLogic révèlent un déclin significatif de la précision à mesure que la complexité des problèmes augmente. Cette limitation persiste même avec des modèles plus grands et plus de temps de calcul à l’inférence, suggérant des contraintes inhérentes aux capacités de raisonnement actuelles des LLM.

Le Mur Économique et Énergétique

Selon Dr. Adnan Masood, architecte solutions IA et chercheur, et les recherches récentes :

• Limites physiques : nous approchons des limites de performance par puce alors que la loi de Moore ralentit
• Coûts astronomiques : plus de 100 millions de dollars pour entraîner GPT-4
• Données limitées : les données textuelles de qualité s’épuisent, forçant le recours aux données synthétiques
• Rendements décroissants : les modèles frontière (OpenAI, Anthropic, Google, Meta) montrent des sauts de performance plus faibles malgré des budgets d’entraînement massifs

J’avais analysé cette problématique énergétique dans mon article sur l’impact écologique de l’IA.

Les Limites Physiques du Hardware

Tim Dettmers apporte un éclairage technique sur les contraintes matérielles incontournables. Son constat est sans appel : « Il nous reste peut-être un ou deux ans pour la mise à l’échelle avant que de nouvelles améliorations ne deviennent physiquement impossibles. »

Les chiffres sont éloquents :

Selon Dettmers, les GPU ont atteint leur rendement maximal vers 2018. Depuis, ce ne sont que des « fonctionnalités ponctuelles qui s’épuisent rapidement ». Maintenir un progrès similaire « nécessite une augmentation exponentielle des coûts en calcul, en énergie et en infrastructure ». Auparavant, la croissance exponentielle du matériel compensait ces besoins — ce n’est plus le cas.

L’État Réel du Marché de l’Emploi

Les Données du Bureau of Labor Statistics

Contrairement au discours catastrophiste, le Bureau of Labor Statistics américain projette une croissance de 17.9% de l’emploi des développeurs logiciels entre 2023 et 2033, soit bien supérieure à la moyenne de 4% pour toutes les professions.

Ces projections s’alignent avec l’estimation de Tim Dettmers selon laquelle seulement 11% des emplois sont actuellement remplaçables par l’IA — bien loin des prédictions apocalyptiques relayées sur les réseaux sociaux.

Explosion des Postes IA

Selon Veritone et GetAura, le premier semestre 2025 a connu une explosion des offres d’emploi liées à l’IA :

Les postes IA représentent désormais 10-12% de tous les emplois software, signe que l’IA s’intègre dans l’industrie plutôt qu’elle ne la remplace.

Salaires en Hausse

Selon IEEE Spectrum :

• Salaire médian IA (Q1 2025) : 156 998 dollars/an (+0.8% trimestre sur trimestre)
• Top chercheurs IA : Meta propose des packages de 10-20 millions de dollars
• Croissance la plus rapide : AI/Machine Learning Engineer (+41.8% en un an)

L’Adoption de l’IA par les Développeurs

Selon le rapport JetBrains 2025 :

• 85% des développeurs utilisent régulièrement des outils d’IA
• 62% s’appuient sur au moins un assistant de code IA
• 89% économisent au moins une heure par semaine grâce à l’IA
• 68% s’attendent à ce que les employeurs exigent la maîtrise des outils IA

Décryptage du Graphique Indeed

Un graphique d’Indeed montrant une chute des offres d’emploi tech aux États-Unis circule régulièrement pour alimenter le discours catastrophiste. Cette lecture mérite une contextualisation :

Ce que le graphique montre : un index en base 100 sur l’année 2020.

Ce que cela signifie réellement : la “chute” actuelle ramène simplement le marché au niveau de février 2020, juste avant le pic anormal lié à la pandémie de Covid-19. Le marché de l’emploi tech de 2020 était considéré comme robuste et sain.

Mon Expérience : Plus d’un An de Développement Augmenté

En tant que développeur pratiquant le développement augmenté par l’IA depuis plus d’un an, mon expérience quotidienne confirme les conclusions des études citées. J’ai condensé cette pratique dans une série de 20 articles sur Claude Code, avec un projet concret documenté : recréer un jeu complet en TypeScript.

Ce que plus d’un an de pratique m’a appris :

• L’IA excelle sur les tâches répétitives, le scaffolding, la génération de tests et la documentation
• L’IA échoue sur les décisions d’architecture, les edge cases métier et l’optimisation fine
• Le workflow structuré (Explore → Plan → Code → Test) transforme un outil hasardeux en partenaire efficace
• La supervision reste indispensable : chaque génération nécessite relecture et validation

Comme je le résume dans l’étude de cas finale : “Claude Code n’est pas un remplacement du développeur, mais un multiplicateur de productivité.”

Le coût de mon projet exemple (120$ pour 5000 lignes de code) illustre bien le rapport qualité-prix — mais aussi la nécessité d’une expertise humaine pour guider, valider et corriger l’IA à chaque étape.

Conclusion : L’IA comme Outil, Pas comme Remplaçant

Les données récentes dessinent un portrait nuancé loin des prédictions alarmistes :

Ce que les études montrent :

• L’IA peut ralentir les développeurs expérimentés de 19% dans certains contextes
• Le Chain of Thought est un “mirage fragile” qui s’effondre hors des cas d’entraînement
• Le marché de l’emploi développeur croît de 17.9% sur 10 ans
• OpenAI perd des milliards, alimentant un discours AGI financièrement motivé
• Les GPU ont atteint leur rendement maximal vers 2018 et les limites physiques du hardware se rapprochent
• Seulement 11% des emplois sont actuellement remplaçables par l’IA

Ce que cela implique :

• Les outils d’IA sont utiles mais ne remplacent pas l’expertise humaine
• Le paradigme “human-in-the-loop” (humain dans la boucle) reste indispensable pour du code de qualité production
• Le métier évolue vers plus d’architecture et moins de “code boilerplate”
• Les développeurs maîtrisant l’IA auront un avantage compétitif

Le concept de human-in-the-loop n’est pas une limitation temporaire en attendant des IA plus avancées — c’est une nécessité structurelle. Même les systèmes d’IA les plus sophistiqués nécessitent une supervision humaine pour les décisions critiques, la validation contextuelle et la responsabilité finale. Les développeurs deviennent des orchestrateurs qui guident, corrigent et valident le travail de l’IA.

Comme le souligne Tim Dettmers, chercheur chez Ai2, l’AGI reste un « fantasme de la Silicon Valley » — une chimère qui contraste avec l’approche pragmatique privilégiant les applications utiles actuelles. Le discours sur le remplacement imminent des développeurs relève davantage du marketing et de l’effet de mode que d’une analyse technique rigoureuse. La sagesse recommande d’adopter ces technologies en gardant un esprit critique, de continuer à développer ses compétences fondamentales, et de ne pas céder à la panique alimentée par des démos trompeuses et des projections financièrement motivées.

À Retenir

Les 4 chiffres clés de cet article :

• -19% : L’IA ralentit les développeurs expérimentés (étude METR)
• 11% : Part des emplois actuellement remplaçables par l’IA (Dettmers)
• +17.9% : Croissance projetée de l’emploi développeur 2023-2033 (BLS)
• 2018 : Année où les GPU ont atteint leur rendement maximal

Bilan de Fin d’Année

Alors que 2025 touche à sa fin, le paysage de l’IA dans le développement logiciel se clarifie. Loin des prophéties apocalyptiques du début d’année, nous disposons désormais de données concrètes pour évaluer l’impact réel de ces technologies.

L’année 2025 aura été celle de la démystification : les études rigoureuses ont révélé les limites des outils d’IA, les pertes financières colossales des géants du secteur ont exposé la fragilité du modèle économique, et les développeurs sur le terrain ont appris à distinguer le battage médiatique de la réalité quotidienne.

Pour 2026, mon conseil reste le même : apprenez à utiliser ces outils, mais ne cessez jamais de développer vos compétences fondamentales. L’IA est un excellent assistant — pas un remplaçant.

Bonne année 2026 à tous les développeurs ! Que cette nouvelle année vous apporte des projets passionnants, des bugs rapidement résolus, et la sérénité face aux prédictions alarmistes qui ne manqueront pas de fleurir.

Et vous, quelle a été votre expérience avec l’IA en 2025 ? Partagez vos retours dans les commentaires ou sur les réseaux sociaux.

Sources

1. Melvynx - L’IA va-t-elle remplacer les développeurs ? - YouTube

2. METR - Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity - METR

3. AI coding tools may not speed up every developer - TechCrunch

4. AI coding tools can slow down seasoned developers by 19% - InfoWorld

5. Shrinking AGI timelines: a review of expert forecasts - 80,000 Hours

6. When Will AGI/Singularity Happen? 8,590 Predictions Analyzed - AIMultiple

7. OpenAI sees roughly $5 billion loss this year on $3.7 billion in revenue - CNBC

8. OpenAI lost $5 billion in 2024 (and its losses are increasing) - LessWrong

9. Is Chain-of-Thought Reasoning of LLMs a Mirage? - arXiv

10. The Decreasing Value of Chain of Thought in Prompting - Wharton

11. On the Fundamental Limits of LLMs at Scale - arXiv

12. ZebraLogic: On the Scaling Limits of LLMs for Logical Reasoning - arXiv

13. AI impacts in BLS employment projections - Bureau of Labor Statistics

14. AI Jobs on the Rise: Q1 2025 Labor Market Analysis - Veritone

15. New AI Job Market Data (Through June 2025) - GetAura

16. AI Jobs in 2025: Essential Insights for Software Engineers - IEEE Spectrum

17. The State of Developer Ecosystem 2025 - JetBrains

18. GPT-4 - Wikipedia

19. What is chain of thought (CoT) prompting? - IBM

20. L’IA superintelligente est un fantasme de la Silicon Valley - Tim Dettmers (Ai2) - Developpez.com

21. Is there a Wall? - Dr. Adnan Masood - Dr. Adnan Masood (architecte solutions IA)

Pour découvrir le projet en détail, lisez mon article dédié : Prelude of the Chambered Reborn : Renaissance d’un classique de Notch

Voir aussi mon autre projet de jeu rétro en TypeScript : GBTS - Un émulateur GameBoy

Le défi

Le projet original

Prelude of the Chambered est un dungeon crawler créé par Notch en 48h lors de la Ludum Dare 21 en 2011. Le code original est en Java, avec un moteur de rendu raycasting software fait maison — environ 5 000 lignes de code Java réparties sur une quarantaine de fichiers.

Mon objectif

Porter le jeu vers le web moderne avec :

• TypeScript au lieu de Java
• Canvas 2D API (rendu software, comme l’original)
• Vite pour le build
• Déployable sur n’importe quel navigateur

Le défi : conserver le moteur de raycasting original et son rendu pixel par pixel, sans passer par WebGL ou une bibliothèque 3D.

Sans Claude Code, j’aurais estimé ce projet à plusieurs semaines de travail. Avec Claude Code, je me suis lancé un soir après le dîner en me disant “on verra bien jusqu’où on va”.

Une soirée, un jeu complet

Exploration du code Java

claude

> @java-src/**/*.java Analyse l'architecture du jeu original.
> Identifie les composants principaux et leurs responsabilités.

En quelques secondes, Claude a cartographié l’ensemble du projet :

• Art.java : Gestion des textures et sprites
• Game.java : Boucle de jeu principale
• Level.java : Chargement des niveaux via des images PNG
• Screen.java : Moteur de raycasting software
• Entity.java : Système d’entités

Conversion du moteur de rendu

Le cœur du projet : adapter le moteur de raycasting Java vers TypeScript/Canvas 2D.

> Analyse @java-src/Screen.java et @java-src/Bitmap.java
> Implémente l'équivalent en TypeScript avec Canvas 2D API.
> Conserve le rendu software pixel par pixel.

Claude a :

1. Compris le système de rendu par bitmap de Notch
2. Adapté les calculs de raycasting pour TypeScript
3. Créé une classe Bitmap compatible avec le Canvas 2D
4. Préservé le rendu software sans GPU

Le système de niveaux bitmap

L’architecture géniale de Notch : chaque niveau est une image PNG où chaque couleur de pixel définit un élément du jeu.

> Analyse comment Level.java charge les niveaux depuis des images.
> Implémente la même logique en TypeScript.

Claude a parfaitement reproduit le système :

• Blanc = mur
• Bleu = eau
• Magenta = échelle
• Rouge = ennemis (avec variations selon la nuance)
• Canal alpha = IDs pour lier switches et portes

Les entités et le gameplay

> Analyse les ennemis dans @java-src/entities/
> et implémente-les en TypeScript avec le même comportement.

Claude a converti méthodiquement chaque ennemi :

• Bat : Mouvement aléatoire
• Ogre : Patrouille + attaque
• Ghost : Traverse les murs
• Eye : Attaque à distance
• Plus les variantes boss

Intégration et debug

Quelques ajustements ont été nécessaires :

• Fine-tuning des collisions
• Adaptation de Thread.sleep() vers requestAnimationFrame
• Gestion des inputs (Java AWT → événements DOM)

Déploiement

> Configure Vite pour builder le projet et GitHub Actions pour déployer.

Et voilà. Projet déployé, jouable dans le navigateur.

Résultats

Ce qui a été accompli en une soirée

La stack finale

• TypeScript : Typage strict
• Canvas 2D API : Rendu software, pas de WebGL
• Vite : Build ultra-rapide avec HMR
• GitHub Actions : Déploiement automatique

Ce que Claude a fait

• Analyse complète du code Java original
• Conversion du moteur de raycasting
• Adaptation du système de niveaux bitmap
• Conversion de toutes les entités
• Configuration du build et déploiement
• Debug des problèmes rencontrés

Ce que j’ai fait

• Direction du projet (quoi faire, dans quel ordre)
• Validation des choix de Claude
• Fine-tuning du gameplay
• Identification des bugs à corriger
• Revue finale du code

Pourquoi ça a marché

1. Code source complet disponible

J’avais le code Java original. Claude pouvait analyser l’existant plutôt que deviner.

2. Références précises

@java-src/Screen.java plutôt que “le fichier de rendu” — Claude savait exactement quoi analyser.

3. Architecture fidèle

Plutôt que réinventer avec une lib 3D moderne, on a conservé l’approche originale : raycasting software sur Canvas 2D. Moins de décisions à prendre = conversion plus rapide.

4. Itérations rapides

Composant par composant, chaque étape validée avant la suivante.

Ce que ça change

Sans Claude Code, ce projet aurait pris plusieurs semaines :

• Comprendre le moteur de raycasting : 2-3 jours
• Adapter les calculs Java → TypeScript : 1 semaine
• Débugger les différences de comportement : plusieurs jours

Avec Claude Code : une soirée.

Ce n’est pas que Claude code plus vite — c’est qu’il élimine le temps de “compréhension” et de “traduction mentale” entre les langages.

Conclusion de la série

En 20 jours, nous avons couvert :

1. Installation et premiers pas
2. Syntaxe secrète #@/!
3. Workflow EPCT
4. Prompt engineering
5. Gestion du contexte
6. Git workflows
7. Permissions et sécurité
8. Slash commands personnalisées
9. Subagents
10. Skills
11. Plugins et marketplace
12. Hooks
13. MCP
14. IDE integration
15. CI/CD headless
16. Facturation et coûts
17. Troubleshooting
18. Status line et terminal
19. Comparatif des outils
20. Cette étude de cas

Claude Code est un outil puissant qui, bien utilisé, transforme la façon dont nous développons. Ce n’est pas un remplacement du développeur — c’est un multiplicateur de productivité qui peut comprimer des semaines de travail en quelques heures.

Maintenant, c’est à vous de jouer !

Merci d’avoir suivi cette série “Maîtriser Claude Code en 20 jours”. Découvrez le projet Prelude Reborn — Jouer maintenant

To discover the project in detail, read my dedicated article: Prelude of the Chambered Reborn: Renaissance of a Notch classic

Also see my other retro game project in TypeScript: GBTS - A GameBoy Emulator

The Challenge

The Original Project

Prelude of the Chambered is a dungeon crawler created by Notch in 48h during Ludum Dare 21 in 2011. The original code is in Java, with a homemade software raycasting rendering engine — about 5,000 lines of Java code spread across forty files.

My Goal

Port the game to the modern web with:

• TypeScript instead of Java
• Canvas 2D API (software rendering, like the original)
• Vite for building
• Deployable on any browser

The challenge: preserve the original raycasting engine and its pixel-by-pixel rendering, without using WebGL or a 3D library.

Without Claude Code, I would have estimated this project at several weeks of work. With Claude Code, I started one evening after dinner thinking “let’s see how far we get”.

One Evening, One Complete Game

Exploring the Java Code

claude

> @java-src/**/*.java Analyze the original game architecture.
> Identify the main components and their responsibilities.

In seconds, Claude mapped out the entire project:

• Art.java: Texture and sprite management
• Game.java: Main game loop
• Level.java: Level loading via PNG images
• Screen.java: Software raycasting engine
• Entity.java: Entity system

Converting the Rendering Engine

The heart of the project: adapting the Java raycasting engine to TypeScript/Canvas 2D.

> Analyze @java-src/Screen.java and @java-src/Bitmap.java
> Implement the equivalent in TypeScript with Canvas 2D API.
> Preserve the pixel-by-pixel software rendering.

Claude:

1. Understood Notch’s bitmap rendering system
2. Adapted raycasting calculations for TypeScript
3. Created a Bitmap class compatible with Canvas 2D
4. Preserved software rendering without GPU

The Bitmap Level System

Notch’s brilliant architecture: each level is a PNG image where every pixel color defines a game element.

> Analyze how Level.java loads levels from images.
> Implement the same logic in TypeScript.

Claude perfectly reproduced the system:

• White = wall
• Blue = water
• Magenta = ladder
• Red = enemies (with variations based on shade)
• Alpha channel = IDs to link switches and doors

Entities and Gameplay

> Analyze enemies in @java-src/entities/
> and implement them in TypeScript with the same behavior.

Claude methodically converted each enemy:

• Bat: Random movement
• Ogre: Patrol + attack
• Ghost: Goes through walls
• Eye: Ranged attack
• Plus boss variants

Integration and Debug

Some adjustments were necessary:

• Collision fine-tuning
• Adapting Thread.sleep() to requestAnimationFrame
• Input handling (Java AWT → DOM events)

Deployment

> Configure Vite to build the project and GitHub Actions to deploy.

And there you go. Project deployed, playable in the browser.

Results

What Was Accomplished in One Evening

The Final Stack

• TypeScript: Strict typing
• Canvas 2D API: Software rendering, no WebGL
• Vite: Ultra-fast build with HMR
• GitHub Actions: Automatic deployment

What Claude Did

• Complete analysis of original Java code
• Raycasting engine conversion
• Bitmap level system adaptation
• Conversion of all entities
• Build and deployment configuration
• Debugging encountered problems

What I Did

• Project direction (what to do, in what order)
• Validating Claude’s choices
• Gameplay fine-tuning
• Identifying bugs to fix
• Final code review

Why It Worked

1. Complete Source Code Available

I had the original Java code. Claude could analyze the existing code rather than guess.

2. Precise References

@java-src/Screen.java rather than “the rendering file” — Claude knew exactly what to analyze.

3. Faithful Architecture

Rather than reinventing with a modern 3D lib, we preserved the original approach: software raycasting on Canvas 2D. Fewer decisions to make = faster conversion.

4. Fast Iterations

Component by component, each step validated before the next.

What This Changes

Without Claude Code, this project would have taken several weeks:

• Understanding the raycasting engine: 2-3 days
• Adapting Java → TypeScript calculations: 1 week
• Debugging behavior differences: several days

With Claude Code: one evening.

It’s not that Claude codes faster — it’s that it eliminates the “understanding” and “mental translation” time between languages.

Series Conclusion

In 20 days, we covered:

1. Installation and first steps
2. Secret syntax #@/!
3. EPCT Workflow
4. Prompt engineering
5. Context management
6. Git workflows
7. Permissions and security
8. Custom slash commands
9. Subagents
10. Skills
11. Plugins and marketplace
12. Hooks
13. MCP
14. IDE integration
15. CI/CD headless
16. Billing and costs
17. Troubleshooting
18. Status line and terminal
19. Tool comparison
20. This case study

Claude Code is a powerful tool that, when used well, transforms how we develop. It’s not a developer replacement — it’s a productivity multiplier that can compress weeks of work into a few hours.

Now it’s your turn!

Thank you for following this “Master Claude Code in 20 Days” series. Discover the Prelude Reborn project — Play now

Pour un contexte plus large sur l’état de l’IA en développement, voir mon article IA et développement en 2025. Et si vous envisagez des alternatives locales, consultez OpenAI GPT OSS vs Ollama.

Vue d’ensemble

Claude Code

Forces

• Agentic : Peut planifier et exécuter des tâches complexes de bout en bout
• Contexte projet : CLAUDE.md, rules, mémoire hiérarchique
• Extensible : Hooks, skills, subagents, MCP
• Terminal-native : Rapide, scriptable, intégrable CI/CD
• Autonomie : Peut travailler sur plusieurs fichiers en séquence

Faiblesses

• Courbe d’apprentissage : Syntaxe #@/! à maîtriser
• Prix : Plus cher que les alternatives
• Pas d’IDE intégré : Nécessite votre éditeur séparé
• Moins visuel : Pas de diff graphique intégré

Idéal pour

• Développeurs terminal-first
• Projets complexes multi-fichiers
• Automatisation CI/CD
• Utilisateurs avancés cherchant la puissance

Cursor

Forces

• IDE complet : Fork VS Code avec IA native
• Multi-modèle : GPT-4, Claude, modèles locaux
• Visuel : Diffs intégrés, chat contextuel
• Composer : Mode agent pour tâches complexes
• Accessibilité : Interface familière VS Code

Faiblesses

• Verrouillé : Doit utiliser Cursor comme IDE
• Limité terminal : Pas d’usage CLI pur
• Dépendance : Fork qui peut diverger de VS Code
• Moins extensible : Pas de système de plugins aussi riche

Idéal pour

• Développeurs VS Code cherchant une intégration IA native
• Équipes voulant un outil unifié
• Utilisateurs préférant l’interface graphique
• Projets où la visualisation est importante

GitHub Copilot

Forces

• Intégration GitHub : PRs, Issues, Actions natifs
• Prix accessible : $10/mois individuel
• Ubiquité : Disponible dans tous les IDE majeurs
• Complétion en temps réel : Suggestions pendant la frappe
• Copilot Chat : Conversation contextuelle

Faiblesses

• Moins agentic : Pas de planification autonome
• Contexte limité : Moins bon pour les projets larges
• Microsoft-dépendant : Lié à l’écosystème Microsoft
• Moins personnalisable : Pas de rules, hooks, etc.

Idéal pour

• Débutants en assistants IA
• Budget limité
• Projets GitHub-centric
• Complétion de code rapide

Comparaison détaillée

Compréhension du contexte

Capacités agentiques

Personnalisation

Prix et licences

Workflows comparés

Refactoring d’un module

Claude Code :

> ultrathink. Refactorise le module auth pour utiliser JWT.
> Assure-toi que tous les tests passent.

→ Claude planifie, modifie les fichiers, exécute les tests, corrige si nécessaire.

Cursor :

1. Ouvrir Composer
2. Décrire le refactoring
3. Review les changements proposés
4. Accepter/ajuster
5. Lancer les tests manuellement

Copilot :

1. Ouvrir Copilot Chat
2. Demander des suggestions de refactoring
3. Appliquer fichier par fichier
4. Lancer les tests manuellement

Fix d’un bug

Claude Code :

> Le test UserService.test.ts échoue ligne 45.
> Trouve et corrige le bug.

Cursor :

1. Clic droit sur l’erreur
2. “Fix with AI”
3. Review la suggestion
4. Appliquer

Copilot :

1. Sélectionner le code problématique
2. /fix dans le chat
3. Appliquer la suggestion

Nouveau projet

Claude Code :

> Crée une API REST avec Express, TypeScript, Prisma.
> Structure selon les best practices.
> Ajoute l'authentification JWT.

Cursor :

1. Composer mode
2. Décrire l’architecture
3. Générer fichier par fichier
4. Ajuster au fur et à mesure

Copilot :

1. Créer les fichiers manuellement
2. Utiliser les suggestions pour le contenu
3. Copilot Chat pour les questions

Quand utiliser quoi ?

Utilisez Claude Code si :

• Vous êtes à l’aise avec le terminal
• Vous travaillez sur des projets complexes
• Vous voulez automatiser (CI/CD, scripts)
• Vous avez besoin d’autonomie de l’IA
• Budget n’est pas la contrainte principale

Utilisez Cursor si :

• Vous préférez VS Code
• Vous voulez une expérience intégrée
• Vous travaillez visuellement (diffs)
• Vous voulez changer de modèle facilement
• Budget modéré

Utilisez Copilot si :

• Vous débutez avec l’IA
• Budget limité
• Vous êtes dans l’écosystème GitHub
• Vous voulez des suggestions temps réel
• Vous utilisez divers IDE

Combinaison recommandée

Ma stack personnelle :

┌─────────────────────────────────────────┐
│ Claude Code (terminal)                  │
│ - Tâches complexes                      │
│ - Automatisation                        │
│ - CI/CD                                 │
├─────────────────────────────────────────┤
│ VS Code + Copilot                       │
│ - Édition quotidienne                   │
│ - Complétion temps réel                 │
│ - Quick fixes                           │
└─────────────────────────────────────────┘

Cette combinaison offre :

• La puissance de Claude pour les tâches lourdes
• La rapidité de Copilot pour le quotidien
• Le meilleur des deux mondes

Évolution du marché

Tendances 2024-2025

• Plus d’autonomie : Les outils deviennent plus agentiques
• Multi-modèle : Choix du LLM selon la tâche
• Intégration : Moins de friction entre outils
• Spécialisation : Outils par domaine (web, mobile, data)

Ce qui arrive

• Claude Code continue d’ajouter des fonctionnalités agentiques
• Cursor pousse sur l’intégration multi-modèle
• Copilot évolue vers plus d’autonomie (Copilot Workspace)

Conclusion

Il n’y a pas de “meilleur” outil universel. Le choix dépend de :

1. Votre workflow : Terminal vs GUI
2. Votre budget : $10 à $200/mois
3. Vos besoins : Complétion vs Agent complet
4. Votre écosystème : GitHub, Anthropic, ou neutre

Mon conseil : essayez les trois avec leurs versions d’essai, puis choisissez (ou combinez) selon votre style.

Ce qui vous attend demain

Dans le Jour 20, nous terminerons avec une étude de cas complète : comment j’ai utilisé Claude Code pour créer Prelude of the Chambered Reborn.

Cet article fait partie de la série “Maîtriser Claude Code en 20 jours”. Jour 18 : Status line et terminal

For broader context on the state of AI in development, see my article AI and Development in 2025. And if you’re considering local alternatives, check out OpenAI GPT OSS vs Ollama.

Overview

Claude Code

Strengths

• Agentic: Can plan and execute complex tasks end-to-end
• Project context: CLAUDE.md, rules, hierarchical memory
• Extensible: Hooks, skills, subagents, MCP
• Terminal-native: Fast, scriptable, CI/CD integrable
• Autonomy: Can work on multiple files in sequence

Weaknesses

• Learning curve: #@/! syntax to master
• Price: More expensive than alternatives
• No integrated IDE: Requires your separate editor
• Less visual: No integrated graphical diff

Ideal for

• Terminal-first developers
• Complex multi-file projects
• CI/CD automation
• Advanced users seeking power

Cursor

Strengths

• Full IDE: VS Code fork with native AI
• Multi-model: GPT-4, Claude, local models
• Visual: Integrated diffs, contextual chat
• Composer: Agent mode for complex tasks
• Accessibility: Familiar VS Code interface

Weaknesses

• Locked in: Must use Cursor as IDE
• Limited terminal: No pure CLI usage
• Dependency: Fork that may diverge from VS Code
• Less extensible: Not as rich plugin system

Ideal for

• VS Code developers seeking native AI integration
• Teams wanting a unified tool
• Users preferring graphical interface
• Projects where visualization is important

GitHub Copilot

Strengths

• GitHub integration: Native PRs, Issues, Actions
• Accessible price: $10/month individual
• Ubiquity: Available in all major IDEs
• Real-time completion: Suggestions while typing
• Copilot Chat: Contextual conversation

Weaknesses

• Less agentic: No autonomous planning
• Limited context: Less suitable for large projects
• Microsoft-dependent: Tied to Microsoft ecosystem
• Less customizable: No rules, hooks, etc.

Ideal for

• AI assistant beginners
• Limited budget
• GitHub-centric projects
• Quick code completion

Detailed Comparison

Context Understanding

Agentic Capabilities

Customization

Pricing and Licenses

Compared Workflows

Module Refactoring

Claude Code:

> ultrathink. Refactor the auth module to use JWT.
> Make sure all tests pass.

→ Claude plans, modifies files, runs tests, fixes if needed.

Cursor:

1. Open Composer
2. Describe the refactoring
3. Review proposed changes
4. Accept/adjust
5. Run tests manually

Copilot:

1. Open Copilot Chat
2. Ask for refactoring suggestions
3. Apply file by file
4. Run tests manually

Bug Fix

Claude Code:

> The test UserService.test.ts fails at line 45.
> Find and fix the bug.

Cursor:

1. Right-click on error
2. “Fix with AI”
3. Review suggestion
4. Apply

Copilot:

1. Select problematic code
2. /fix in chat
3. Apply suggestion

New Project

Claude Code:

> Create a REST API with Express, TypeScript, Prisma.
> Structure according to best practices.
> Add JWT authentication.

Cursor:

1. Composer mode
2. Describe architecture
3. Generate file by file
4. Adjust as you go

Copilot:

1. Create files manually
2. Use suggestions for content
3. Copilot Chat for questions

When to Use What?

Use Claude Code if:

• You’re comfortable with terminal
• You work on complex projects
• You want automation (CI/CD, scripts)
• You need AI autonomy
• Budget is not the main constraint

Use Cursor if:

• You prefer VS Code
• You want an integrated experience
• You work visually (diffs)
• You want to switch models easily
• Moderate budget

Use Copilot if:

• You’re new to AI
• Limited budget
• You’re in the GitHub ecosystem
• You want real-time suggestions
• You use various IDEs

Recommended Combination

My personal stack:

┌─────────────────────────────────────────┐
│ Claude Code (terminal)                  │
│ - Complex tasks                         │
│ - Automation                            │
│ - CI/CD                                 │
├─────────────────────────────────────────┤
│ VS Code + Copilot                       │
│ - Daily editing                         │
│ - Real-time completion                  │
│ - Quick fixes                           │
└─────────────────────────────────────────┘

This combination offers:

• Claude’s power for heavy tasks
• Copilot’s speed for daily work
• Best of both worlds

Market Evolution

2024-2025 Trends

• More autonomy: Tools becoming more agentic
• Multi-model: LLM choice per task
• Integration: Less friction between tools
• Specialization: Tools by domain (web, mobile, data)

What’s Coming

• Claude Code continues adding agentic features
• Cursor pushes multi-model integration
• Copilot evolves toward more autonomy (Copilot Workspace)

Conclusion

There’s no universal “best” tool. The choice depends on:

1. Your workflow: Terminal vs GUI
2. Your budget: $10 to $200/month
3. Your needs: Completion vs Full Agent
4. Your ecosystem: GitHub, Anthropic, or neutral

My advice: try all three with their trial versions, then choose (or combine) according to your style.

What’s Coming Tomorrow

In Day 20, we’ll finish with a complete case study: how I used Claude Code to create Prelude of the Chambered Reborn.

This article is part of the “Master Claude Code in 20 Days” series. Day 18: Status line and terminal

La Status Line

Qu’est-ce que la status line ?

La barre en bas de l’écran qui affiche :

• Le modèle actif
• Le nombre de tokens utilisés
• Le coût de la session
• Le statut de connexion

Personnaliser la status line

Via la commande /config :

/config

Options de status line :

• Minimal : Juste le modèle
• Standard : Modèle + tokens
• Detailed : Tout (modèle, tokens, coût, latence)
• Hidden : Pas de status line

Configuration dans settings

{
  "statusLine": {
    "style": "detailed",
    "showCost": true,
    "showTokens": true,
    "showModel": true,
    "showLatency": false
  }
}

Le Mode Vim

Activer le mode vim

/vim

Ou au lancement :

claude --vim

Raccourcis vim disponibles

Configuration vim

{
  "editor": {
    "mode": "vim",
    "lineNumbers": true,
    "relativNumbers": false
  }
}

Thèmes et couleurs

Thèmes intégrés

Claude Code s’adapte au thème de votre terminal. Pour forcer un thème :

export CLAUDE_CODE_THEME=dark

Options :

• dark : Fond sombre
• light : Fond clair
• auto : Détection automatique

Couleurs personnalisées

Dans votre fichier de configuration terminal (.zshrc, .bashrc) :

# Couleurs Claude Code
export CLAUDE_CODE_COLOR_PRIMARY="#00ff00"
export CLAUDE_CODE_COLOR_SECONDARY="#0066ff"
export CLAUDE_CODE_COLOR_ERROR="#ff0000"
export CLAUDE_CODE_COLOR_SUCCESS="#00ff00"

Raccourcis clavier

Raccourcis par défaut

Personnaliser les raccourcis

{
  "keybindings": {
    "submit": "Enter",
    "newLine": "Shift+Enter",
    "cancel": "Ctrl+C",
    "clearScreen": "Ctrl+L",
    "rewind": "Esc Esc",
    "acceptEdits": "Shift+Tab",
    "history.up": "ArrowUp",
    "history.down": "ArrowDown"
  }
}

Autocomplétion

Complétion des fichiers

Tapez @ puis Tab pour voir les fichiers disponibles :

@sr[Tab]
→ @src/
→ @src/api/
→ @src/components/

Complétion des commandes

Tapez / puis Tab :

/co[Tab]
→ /compact
→ /config
→ /cost

Complétion intelligente

Claude Code propose des complétions basées sur :

• Le contexte actuel
• L’historique des commandes
• Les fichiers du projet

Configuration avancée du terminal

Taille de l’historique

{
  "history": {
    "maxSize": 1000,
    "saveToDisk": true
  }
}

Scroll buffer

{
  "terminal": {
    "scrollback": 10000,
    "wordWrap": true
  }
}

Format d’affichage

{
  "display": {
    "codeBlockStyle": "bordered",
    "syntaxHighlighting": true,
    "lineNumbers": true,
    "diffStyle": "unified"
  }
}

Intégration avec le shell

Alias utiles

Ajoutez à votre .zshrc ou .bashrc :

# Lancer Claude Code
alias cc='claude'

# Claude Code avec modèle spécifique
alias ccs='claude --model sonnet'
alias cco='claude --model opus'
alias cch='claude --model haiku'

# Continuer la dernière session
alias ccr='claude -c'

# Claude Code en mode print
alias ccp='claude -p'

Fonctions shell

# Analyser un fichier avec Claude
analyze() {
  cat "$1" | claude -p "Analyse ce fichier et identifie les problèmes potentiels"
}

# Générer des tests pour un fichier
gentest() {
  claude -p "Génère des tests pour @$1" --allowedTools Read,Write
}

# Review rapide
review() {
  git diff | claude -p "Review ces changements"
}

Multiplexeurs de terminal

Avec tmux

# Créer une session Claude Code
tmux new-session -s claude

# Dans tmux
claude

# Détacher : Ctrl+B, D
# Réattacher : tmux attach -t claude

Configuration tmux recommandée

# ~/.tmux.conf

# Status bar pour Claude Code
set -g status-right '#[fg=green]Claude #[fg=white]| #[fg=cyan]%H:%M'

# Couleurs adaptées
set -g default-terminal "screen-256color"

Avec screen

screen -S claude
claude
# Détacher : Ctrl+A, D
# Réattacher : screen -r claude

Notifications

Notifications de fin de tâche

{
  "notifications": {
    "onTaskComplete": true,
    "onError": true,
    "sound": false
  }
}

Notifications système

Avec libnotify (Linux) :

claude -p "Tâche longue" && notify-send "Claude terminé"

Avec osascript (macOS) :

claude -p "Tâche longue" && osascript -e 'display notification "Claude terminé"'

Profils de configuration

Créer des profils

~/.claude/
├── profiles/
│   ├── work.json
│   ├── personal.json
│   └── ci.json
└── settings.json

Profile “work”

{
  "model": "sonnet",
  "statusLine": { "style": "detailed" },
  "editor": { "mode": "vim" }
}

Profile “ci”

{
  "model": "haiku",
  "statusLine": { "style": "hidden" },
  "notifications": { "enabled": false }
}

Charger un profil

claude --profile work

Accessibilité

Mode haut contraste

{
  "accessibility": {
    "highContrast": true,
    "largeText": false,
    "screenReaderFriendly": true
  }
}

Désactiver les animations

{
  "display": {
    "animations": false,
    "progressIndicator": "text"
  }
}

Template de configuration complète

{
  "statusLine": {
    "style": "detailed",
    "showCost": true,
    "showTokens": true,
    "showModel": true
  },
  "editor": {
    "mode": "vim",
    "lineNumbers": true
  },
  "display": {
    "codeBlockStyle": "bordered",
    "syntaxHighlighting": true,
    "diffStyle": "unified",
    "animations": true
  },
  "history": {
    "maxSize": 1000,
    "saveToDisk": true
  },
  "keybindings": {
    "submit": "Enter",
    "newLine": "Shift+Enter",
    "cancel": "Ctrl+C"
  },
  "notifications": {
    "onTaskComplete": true,
    "onError": true
  }
}

Ce qui vous attend demain

Dans le Jour 19, nous ferons un comparatif Claude Code vs Cursor vs GitHub Copilot - comprendre les forces de chaque outil.

Cet article fait partie de la série “Maîtriser Claude Code en 20 jours”. Jour 17 : Troubleshooting

The Status Line

What is the status line?

The bar at the bottom of the screen that displays:

• Active model
• Tokens used
• Session cost
• Connection status

Customize the status line

Via the /config command:

/config

Status line options:

• Minimal: Just the model
• Standard: Model + tokens
• Detailed: Everything (model, tokens, cost, latency)
• Hidden: No status line

Configuration in settings

{
  "statusLine": {
    "style": "detailed",
    "showCost": true,
    "showTokens": true,
    "showModel": true,
    "showLatency": false
  }
}

Vim Mode

Enable vim mode

/vim

Or at launch:

claude --vim

Available vim shortcuts

Vim configuration

{
  "editor": {
    "mode": "vim",
    "lineNumbers": true,
    "relativNumbers": false
  }
}

Themes and Colors

Built-in themes

Claude Code adapts to your terminal theme. To force a theme:

export CLAUDE_CODE_THEME=dark

Options:

• dark: Dark background
• light: Light background
• auto: Automatic detection

Custom colors

In your terminal config file (.zshrc, .bashrc):

# Claude Code colors
export CLAUDE_CODE_COLOR_PRIMARY="#00ff00"
export CLAUDE_CODE_COLOR_SECONDARY="#0066ff"
export CLAUDE_CODE_COLOR_ERROR="#ff0000"
export CLAUDE_CODE_COLOR_SUCCESS="#00ff00"

Keyboard Shortcuts

Default shortcuts

Customize shortcuts

{
  "keybindings": {
    "submit": "Enter",
    "newLine": "Shift+Enter",
    "cancel": "Ctrl+C",
    "clearScreen": "Ctrl+L",
    "rewind": "Esc Esc",
    "acceptEdits": "Shift+Tab",
    "history.up": "ArrowUp",
    "history.down": "ArrowDown"
  }
}

Autocompletion

File completion

Type @ then Tab to see available files:

@sr[Tab]
→ @src/
→ @src/api/
→ @src/components/

Command completion

Type / then Tab:

/co[Tab]
→ /compact
→ /config
→ /cost

Smart completion

Claude Code suggests completions based on:

• Current context
• Command history
• Project files

Advanced Terminal Configuration

History size

{
  "history": {
    "maxSize": 1000,
    "saveToDisk": true
  }
}

Scroll buffer

{
  "terminal": {
    "scrollback": 10000,
    "wordWrap": true
  }
}

Display format

{
  "display": {
    "codeBlockStyle": "bordered",
    "syntaxHighlighting": true,
    "lineNumbers": true,
    "diffStyle": "unified"
  }
}

Shell Integration

Useful aliases

Add to your .zshrc or .bashrc:

# Launch Claude Code
alias cc='claude'

# Claude Code with specific model
alias ccs='claude --model sonnet'
alias cco='claude --model opus'
alias cch='claude --model haiku'

# Continue last session
alias ccr='claude -c'

# Claude Code in print mode
alias ccp='claude -p'

Shell functions

# Analyze a file with Claude
analyze() {
  cat "$1" | claude -p "Analyze this file and identify potential issues"
}

# Generate tests for a file
gentest() {
  claude -p "Generate tests for @$1" --allowedTools Read,Write
}

# Quick review
review() {
  git diff | claude -p "Review these changes"
}

Terminal Multiplexers

With tmux

# Create a Claude Code session
tmux new-session -s claude

# In tmux
claude

# Detach: Ctrl+B, D
# Reattach: tmux attach -t claude

Recommended tmux configuration

# ~/.tmux.conf

# Status bar for Claude Code
set -g status-right '#[fg=green]Claude #[fg=white]| #[fg=cyan]%H:%M'

# Adapted colors
set -g default-terminal "screen-256color"

With screen

screen -S claude
claude
# Detach: Ctrl+A, D
# Reattach: screen -r claude

Notifications

Task completion notifications

{
  "notifications": {
    "onTaskComplete": true,
    "onError": true,
    "sound": false
  }
}

System notifications

With libnotify (Linux):

claude -p "Long task" && notify-send "Claude finished"

With osascript (macOS):

claude -p "Long task" && osascript -e 'display notification "Claude finished"'

Configuration Profiles

Create profiles

~/.claude/
├── profiles/
│   ├── work.json
│   ├── personal.json
│   └── ci.json
└── settings.json

“work” profile

{
  "model": "sonnet",
  "statusLine": { "style": "detailed" },
  "editor": { "mode": "vim" }
}

“ci” profile

{
  "model": "haiku",
  "statusLine": { "style": "hidden" },
  "notifications": { "enabled": false }
}

Load a profile

claude --profile work

Accessibility

High contrast mode

{
  "accessibility": {
    "highContrast": true,
    "largeText": false,
    "screenReaderFriendly": true
  }
}

Disable animations

{
  "display": {
    "animations": false,
    "progressIndicator": "text"
  }
}

Complete Configuration Template

{
  "statusLine": {
    "style": "detailed",
    "showCost": true,
    "showTokens": true,
    "showModel": true
  },
  "editor": {
    "mode": "vim",
    "lineNumbers": true
  },
  "display": {
    "codeBlockStyle": "bordered",
    "syntaxHighlighting": true,
    "diffStyle": "unified",
    "animations": true
  },
  "history": {
    "maxSize": 1000,
    "saveToDisk": true
  },
  "keybindings": {
    "submit": "Enter",
    "newLine": "Shift+Enter",
    "cancel": "Ctrl+C"
  },
  "notifications": {
    "onTaskComplete": true,
    "onError": true
  }
}

What’s Coming Tomorrow

In Day 19, we’ll do a comparison: Claude Code vs Cursor vs GitHub Copilot - understand each tool’s strengths.

This article is part of the “Master Claude Code in 20 Days” series. Day 17: Troubleshooting

Problèmes de connexion

Erreur : “API Key invalid”

Error: Invalid API key

Solutions :

1. Vérifier la clé :

   echo $ANTHROPIC_API_KEY
   

2. Reconfigurer :

   claude config set apiKey sk-ant-...
   

3. Vérifier les permissions sur console.anthropic.com

Erreur : “Rate limit exceeded”

Error: Rate limit exceeded. Please retry after X seconds.

Solutions :

1. Attendre le délai indiqué
2. Réduire la fréquence des requêtes
3. Passer à un plan supérieur (Max 20x)
4. Utiliser /compact pour réduire les tokens

Erreur : “Connection timeout”

Error: Request timed out

Solutions :

1. Vérifier la connexion internet
2. Vérifier le statut : status.anthropic.com
3. Réessayer avec un timeout plus long :

   claude --timeout 120000
   

Problèmes de contexte

Erreur : “Context window exceeded”

Error: Maximum context length exceeded

Cause : La conversation + fichiers dépassent la limite de tokens.

Solutions :

1. Utiliser /compact immédiatement :

   /compact
   

2. Démarrer une nouvelle session :

   /clear
   

3. Limiter les fichiers référencés :

   ❌ @src/**/*.ts  (trop de fichiers)
   ✅ @src/api/auth.ts  (fichier spécifique)
   

Claude “oublie” des instructions

Cause : Le contexte est saturé et les anciennes instructions sont tronquées.

Solutions :

1. Ajouter les instructions au CLAUDE.md :

   # CLAUDE.md
   ## Règle importante
   Toujours utiliser des early returns
   

2. Répéter les instructions critiques :

   > Rappel : utilise TypeScript strict.
   > Maintenant, implémente la feature X.
   

3. Utiliser /compact puis reformuler

Fichier non trouvé

Error: File not found: @src/missing.ts

Solutions :

1. Vérifier le chemin :

   ls src/missing.ts
   

2. Utiliser le chemin relatif correct :

   @./src/missing.ts  (avec ./)
   @src/missing.ts    (sans ./)
   

3. Vérifier les permissions de lecture

Problèmes d’exécution

Commande bash bloquée

Claude is waiting for permission...

Solutions :

1. Accepter ou refuser manuellement
2. Ajouter aux permissions :

   {
     "permissions": {
    "allow": ["Bash(npm run:*)"]
     }
   }
   

3. Utiliser le mode Accept Edits (Shift+Tab)

Erreur : “Tool not available”

Error: Tool 'WebFetch' is not available

Cause : L’outil est désactivé ou non disponible.

Solutions :

1. Vérifier les permissions :

   /permissions
   

2. Activer l’outil dans settings.json

3. Vérifier que l’outil existe (certains sont expérimentaux)

Boucle infinie

Claude continue sans fin sur une tâche.

Solutions :

1. Interrompre avec Ctrl+C
2. Utiliser Esc Esc pour revenir en arrière
3. Reformuler avec une limite :

   > Fais cette tâche en maximum 3 étapes
   

Problèmes de performance

Réponses très lentes

Causes possibles :

• Contexte trop large
• Charge serveur élevée
• Connexion réseau lente

Solutions :

1. Réduire le contexte :

   /compact
   

2. Limiter les fichiers :

   > Analyse uniquement @src/api/auth.ts
   

3. Utiliser un modèle plus rapide :

   claude --model haiku
   

Coûts élevés

Diagnostic :

/cost

Solutions :

1. /compact régulièrement
2. Être plus précis dans les prompts
3. Éviter les lectures massives de fichiers
4. Utiliser Haiku pour les tâches simples

Problèmes d’installation

npm install échoue

npm install -g @anthropic-ai/claude-code
# Error: EACCES permission denied

Solutions :

1. Utiliser npx :

   npx @anthropic-ai/claude-code
   

2. Fixer les permissions npm :

   mkdir ~/.npm-global
   npm config set prefix '~/.npm-global'
   export PATH=~/.npm-global/bin:$PATH
   

3. Utiliser un gestionnaire de versions Node :

   nvm use 20
   npm install -g @anthropic-ai/claude-code
   

Version Node incompatible

Error: Unsupported Node.js version

Solution :

nvm install 18  # ou 20
nvm use 18

Problèmes avec les hooks

Hook ne s’exécute pas

Vérifications :

1. Syntaxe du hook :

   {
     "hooks": {
    "PreToolUse": [{
      "matcher": "Edit",
      "hooks": [{
        "type": "command",
        "command": "echo 'Hook triggered'"
      }]
    }]
     }
   }
   

2. Logs de debug :

   CLAUDE_CODE_DEBUG=1 claude
   

3. Permissions du script :

   chmod +x ./scripts/hook.sh
   

Hook bloque Claude

Hook returned: BLOCK

C’est intentionnel si le hook détecte un problème.

Solutions :

1. Vérifier les conditions du hook
2. Modifier le fichier concerné pour satisfaire le hook
3. Désactiver temporairement le hook

Problèmes avec MCP

Serveur MCP ne démarre pas

Error: Failed to connect to MCP server

Solutions :

1. Vérifier l’installation :

   npx postgres-mcp-server --version
   

2. Tester manuellement :

   npx postgres-mcp-server
   

3. Vérifier les variables d’environnement :

   echo $DATABASE_URL
   

Timeout MCP

Error: MCP server timed out

Solutions :

1. Augmenter le timeout :

   {
     "mcpServers": {
    "postgres": {
      "timeout": 30000
    }
     }
   }
   

2. Vérifier la connectivité réseau vers le service

Diagnostic général

Mode debug

CLAUDE_CODE_DEBUG=1 claude

Affiche des logs détaillés pour identifier le problème.

Vérifier la configuration

claude config list

Réinitialiser la configuration

rm -rf ~/.claude
claude config set apiKey sk-ant-...

Vérifier les logs

cat ~/.claude/logs/claude-code.log

Checklist de dépannage

□ Connexion internet OK ?
□ API Key valide ?
□ Version Node.js compatible (≥18) ?
□ Claude Code à jour ?
□ Permissions fichiers OK ?
□ Contexte pas saturé ?
□ Hooks configurés correctement ?
□ MCP servers accessibles ?

Obtenir de l’aide

Documentation officielle

/help

Communauté

• GitHub Issues : github.com/anthropics/claude-code/issues
• Discord Anthropic
• Stack Overflow tag claude-code

Support Anthropic

Pour les clients Enterprise : support.anthropic.com

Ce qui vous attend demain

Dans le Jour 18, nous explorerons la status line et personnalisation du terminal - configurez l’affichage de Claude Code selon vos préférences.

Cet article fait partie de la série “Maîtriser Claude Code en 20 jours”. Jour 16 : Facturation et coûts

Connection Problems

Error: “API Key invalid”

Error: Invalid API key

Solutions:

1. Verify the key:

   echo $ANTHROPIC_API_KEY
   

2. Reconfigure:

   claude config set apiKey sk-ant-...
   

3. Check permissions on console.anthropic.com

Error: “Rate limit exceeded”

Error: Rate limit exceeded. Please retry after X seconds.

Solutions:

1. Wait for the indicated delay
2. Reduce request frequency
3. Upgrade to a higher plan (Max 20x)
4. Use /compact to reduce tokens

Error: “Connection timeout”

Error: Request timed out

Solutions:

1. Check internet connection
2. Check status: status.anthropic.com
3. Retry with longer timeout:

   claude --timeout 120000
   

Context Problems

Error: “Context window exceeded”

Error: Maximum context length exceeded

Cause: Conversation + files exceed token limit.

Solutions:

1. Use /compact immediately:

   /compact
   

2. Start a new session:

   /clear
   

3. Limit referenced files:

   ❌ @src/**/*.ts  (too many files)
   ✅ @src/api/auth.ts  (specific file)
   

Claude “forgets” instructions

Cause: Context is saturated and old instructions are truncated.

Solutions:

1. Add instructions to CLAUDE.md:

   # CLAUDE.md
   ## Important rule
   Always use early returns
   

2. Repeat critical instructions:

   > Reminder: use strict TypeScript.
   > Now, implement feature X.
   

3. Use /compact then reformulate

File not found

Error: File not found: @src/missing.ts

Solutions:

1. Verify the path:

   ls src/missing.ts
   

2. Use correct relative path:

   @./src/missing.ts  (with ./)
   @src/missing.ts    (without ./)
   

3. Check read permissions

Execution Problems

Bash command blocked

Claude is waiting for permission...

Solutions:

1. Accept or reject manually
2. Add to permissions:

   {
     "permissions": {
    "allow": ["Bash(npm run:*)"]
     }
   }
   

3. Use Accept Edits mode (Shift+Tab)

Error: “Tool not available”

Error: Tool 'WebFetch' is not available

Cause: Tool is disabled or unavailable.

Solutions:

1. Check permissions:

   /permissions
   

2. Enable tool in settings.json

3. Verify tool exists (some are experimental)

Infinite loop

Claude continues endlessly on a task.

Solutions:

1. Interrupt with Ctrl+C
2. Use Esc Esc to go back
3. Reformulate with a limit:

   > Do this task in maximum 3 steps
   

Performance Problems

Very slow responses

Possible causes:

• Context too large
• High server load
• Slow network connection

Solutions:

1. Reduce context:

   /compact
   

2. Limit files:

   > Analyze only @src/api/auth.ts
   

3. Use a faster model:

   claude --model haiku
   

High costs

Diagnosis:

/cost

Solutions:

1. /compact regularly
2. Be more precise in prompts
3. Avoid massive file reads
4. Use Haiku for simple tasks

Installation Problems

npm install fails

npm install -g @anthropic-ai/claude-code
# Error: EACCES permission denied

Solutions:

1. Use npx:

   npx @anthropic-ai/claude-code
   

2. Fix npm permissions:

   mkdir ~/.npm-global
   npm config set prefix '~/.npm-global'
   export PATH=~/.npm-global/bin:$PATH
   

3. Use a Node version manager:

   nvm use 20
   npm install -g @anthropic-ai/claude-code
   

Incompatible Node version

Error: Unsupported Node.js version

Solution:

nvm install 18  # or 20
nvm use 18

Hook Problems

Hook doesn’t execute

Checks:

1. Hook syntax:

   {
     "hooks": {
    "PreToolUse": [{
      "matcher": "Edit",
      "hooks": [{
        "type": "command",
        "command": "echo 'Hook triggered'"
      }]
    }]
     }
   }
   

2. Debug logs:

   CLAUDE_CODE_DEBUG=1 claude
   

3. Script permissions:

   chmod +x ./scripts/hook.sh
   

Hook blocks Claude

Hook returned: BLOCK

This is intentional if the hook detects a problem.

Solutions:

1. Check hook conditions
2. Modify the file to satisfy the hook
3. Temporarily disable the hook

MCP Problems

MCP server won’t start

Error: Failed to connect to MCP server

Solutions:

1. Verify installation:

   npx postgres-mcp-server --version
   

2. Test manually:

   npx postgres-mcp-server
   

3. Check environment variables:

   echo $DATABASE_URL
   

MCP timeout

Error: MCP server timed out

Solutions:

1. Increase timeout:

   {
     "mcpServers": {
    "postgres": {
      "timeout": 30000
    }
     }
   }
   

2. Check network connectivity to the service

General Diagnosis

Debug mode

CLAUDE_CODE_DEBUG=1 claude

Displays detailed logs to identify the problem.

Check configuration

claude config list

Reset configuration

rm -rf ~/.claude
claude config set apiKey sk-ant-...

Check logs

cat ~/.claude/logs/claude-code.log

Troubleshooting Checklist

□ Internet connection OK?
□ API Key valid?
□ Node.js version compatible (≥18)?
□ Claude Code up to date?
□ File permissions OK?
□ Context not saturated?
□ Hooks configured correctly?
□ MCP servers accessible?

Getting Help

Official documentation

/help

Community

• GitHub Issues: github.com/anthropics/claude-code/issues
• Anthropic Discord
• Stack Overflow tag claude-code

Anthropic Support

For Enterprise customers: support.anthropic.com

What’s Coming Tomorrow

In Day 18, we’ll explore the status line and terminal customization - configure Claude Code display according to your preferences.

This article is part of the “Master Claude Code in 20 Days” series. Day 16: Billing and costs