Latest / Le centre de gravité / Claude Code, ce que révèle la fuite

Transcript

Claude Code, ce que révèle la fuite · Le centre de gravité

0:00
Épisode cloud code, ce que révèle la fuite, un fichier de
0:03
débogage oublié sur NPM. Rien de spectaculaire en
0:07
apparence. Et pourtant, derrière cette
0:10
petite erreur, c'est tout un monde qui s'ouvre.
0:12
Chapitre un, le trou dans le mur.
0:15
Le 31 mars 2000 2061 objet minuscule ouvre une brèche
0:17
immense, pas un manifeste, pas un lanceur d'alerte, pas une
0:21
archive interne déposée dans la presse, un fichier point Maps.
0:26
Une source map, c'est un fichier de débogage qui permet de
0:29
remonter d'un code compressé vers un code source lisible.
0:32
En théorie ça sert au développeur, en pratique ce
0:35
jour-là ça sert à tout le monde. La version 2.1 .88 du paquet NPM
0:38
arobase anthropic tiret AI slash cloud tiret code contient ce
0:41
fichier par erreur et soudain, le code de cloud code devient
0:44
lisible. Pas les poids du modèle, pas le
0:47
cerveau statistique de Claude, pas les centaines de gigaoctets
0:49
qui font tourner le système derrière.
0:51
Non, ce qui fuit, c'est autre chose, le théâtre de travail.
0:55
Selon la couverture publique du 31 mars, notamment Numerama et
0:58
Clubic, on parle d'environ 1900 fichiers, de plus de 500000
1:01
lignes de code d'une quarantaine.
1:06
D'outils intégrés et d'une cinquantaine de commandes à
1:09
l'échelle d'un simple outil en ligne de commande, c'est déjà
1:12
extravagant. Et puis, il y a le détail qui
1:14
rend l'histoire encore plus étrange.
1:16
Dans les éléments repérés publiquement au moment de la
1:18
fuite, on voit apparaître Buddy, une fonctionnalité qui, selon
1:22
les notes relayées dans la presse, devait être teasée entre
1:25
le premier et le 7 avril. La fuite, elle, a lieu le 31
1:28
mars. Nous n'avons aucune preuve
1:30
qu'entropique a voulu cela, il faut être très clair, mais il y
1:33
a là dès le premier jour quelque chose de troublant.
1:36
Une fuite ordinaire expose une faiblesse, celle-ci expose
1:39
surtout une ambition. La réaction la plus simple
1:42
aurait été de commenter l'embarras, de résumer
1:44
l'incident, puis de passer à autre chose.
1:46
Nous avons fait l'inverse, nous avons ouvert les fichiers, ou
1:49
plus exactement nous avons commencé à descendre parce qu'un
1:53
code base de cette taille n'est pas un texte, c'est un terrain,
1:56
parce qu'un code base de cette taille ne se lit pas d'un seul
1:58
regard. Il s'explore par couches, on
2:00
liste, on charge quelques fichiers, on synthétise, on
2:04
décharge, puis on avance comme dans une galerie souterraine.
2:07
Et très vite, la sensation change.
2:09
On n'a plus l'impression d'être devant le code d'un assistant de
2:12
terminale un peu sophistiqué. On a l'impression d'être devant
2:16
la maquette d'autre chose, une machine de continuité, un
2:19
système qui ne veut pas seulement répondre, mais durer.
2:22
Et il y a une mise en abyme presque impossible à ignorer
2:24
pour lire cette fuite, pour l'ordonner, pour l'interpréter,
2:28
nous nous sommes aidés de modèle.
2:29
Claude, autrement dit, la même famille d'outils qui a contribué
2:32
à produire cet univers, aide maintenant à le disséquer.
2:36
Il ne faut pas surjouer l'étrangeté, mais il faut
2:38
l'avoir. Nous sommes entrés dans un
2:39
moment où des systèmes commencent à devenir lisibles
2:41
avec l'aide d'autres systèmes du même genre au début.
2:44
On croit entrer dans un leak. En réalité, on entre dans une
2:48
question beaucoup plus vaste, qu'est ce qu'il faut construire
2:50
autour d'une intelligence artificielle pour qu'elle cesse
2:53
d'être une simple réponse et commence à devenir un
2:55
collaborateur ? Et ça, le 31 mars 2000, 2061
2:58
petit fichier oublié sur NPM l'a rendu visible pour tout le
3:01
monde. Ce qui fuit ici, ce n'est pas le
3:03
cerveau du modèle, c'est son théâtre de travail.
3:08
Chapitre 2, lire sans se noyer on n'entre pas dans un code
3:11
pareil d'un seul regard, il faut avancer par couches comme dans
3:15
une mine. Et très vite, la galerie devient
3:17
plus vaste que prévu. La première chose que cette
3:19
fuite impose, c'est une discipline.
3:22
Pas seulement parce que le code est gros, parce qu'il est
3:24
trompeur. Un gros repo peut impressionner
3:26
sans rien dire. Il peut accumuler les dossiers,
3:29
les helpeurs, les dépendances et au fond n'être qu'un produit
3:32
banal habillé d'ampleur. Il fallait donc éviter 2
3:35
erreurs, l'adoration immédiate et le résumé paresseux.
3:39
Alors la méthode a compté. On a commencé par la carte, les
3:42
dossiers, les points d'entrée, les zones de densité.
3:44
Puis on a pris le Repo. Comme on prend un massif par
3:47
travers ses courtes, on charge quelques fichiers centraux, on
3:51
lit, on extrait une hypothèse, on coupe, on repart.
3:54
Cette méthode est importante parce qu'elle épouse déjà le
3:57
problème que Claude code semble lui même essayer de résoudre,
4:00
comment travailler avec beaucoup de matière sans se noyer dedans.
4:04
Et ce détail compte plus qu'il n'en a l'air.
4:06
Beaucoup de produits d'i a impressionnent sur une tâche,
4:09
très peu savent déjà organiser une durée, une reprise, une
4:12
progression. Dès le départ, ce repo nous
4:14
force donc à regarder au bon endroit, pas seulement
4:17
l'intelligence locale du modèle, mais l'architecture qui lui
4:20
permet de rester exploitable dans le temps.
4:22
C'est souvent là que se joue la différence entre une démo
4:25
brillante et un vrai système de travail.
4:28
Les premières couches sont encore trompeuses, on voit 1CLI1
4:30
point d'entrée des commandes slash, des outils de fichiers,
4:33
des commandes d'installation. Jusque là, rien qui dépasse
4:36
vraiment l'état de l'art. Et puis on tombe sur les phase
4:39
pass du démarrage. Des cas spéciaux routés avant
4:43
même que l'interface principale ne s'ouvre, des modes démons,
4:46
des sessions en arrière-plan, des commandes pour attacher,
4:49
tuer, relire des logs. Tout cela pour un outil que
4:53
beaucoup de gens imaginent encore comme une simple boîte de
4:55
chat branchée à un modèle. C'est là que la sensation
4:58
bascule. Ce repo n'est pas d'abord
5:00
organisé autour d'une conversation.
5:02
Il est organisé autour d'un État de travail, d'un processus,
5:06
d'une session qu'on relance, qu'on reprend, qu'on suspend,
5:09
qu'on transporte. La requête n'est plus l'unité
5:11
naturelle, la session commence à le devenir et ça change tout.
5:15
Plus on avance, plus les noms de fichiers deviennent révélateurs,
5:18
coordinator, local mind session, Task agent, tool session,
5:23
Memory, autodream, bridge main, Remote session Manager,
5:27
Teleport, commit attribution. Même sans les lire encore, ils
5:31
dessinent déjà un imaginaire, pas celui d'une intelligence qui
5:35
répond, celui d'une intelligence qu'on essaie de faire tenir dans
5:38
le temps. Avec des outils, des traces des
5:41
collègues, des reprises, des garde-fous, la matière est
5:44
suffisamment riche pour produire une fausse compréhension.
5:47
Très vite, on pourrait s'arrêter à la surface et dire voilà
5:50
anthropique a ajouté beaucoup de fonctionnalités autour de cloud.
5:54
Ce serait vrai et ce serait insuffisant.
5:56
Parce que ce qu'on commence à voir, ce n'est pas seulement un
5:59
empilement de features, c'est une hypothèse de design, une
6:02
réponse à un problème fondamental des grands modèles.
6:05
Ils sont forts mais ponctuels, ils savent impressionner, ils
6:09
savent moins bien continuer, ils savent beaucoup de choses, ils
6:12
savent mal durer et soudain toute la lecture change de
6:15
focale. Les fichiers n'apparaissent plus
6:17
comme des modules isolés mais comme des morceaux de réponse à
6:20
une seule question, comment transformer 1LLM ponctuel en
6:23
partenaire de travail relativement stable ?
6:24
À partir de là, le Repo s'éclaire différemment, le
6:28
coordinateur n'est plus un détail, la mémoire n'est plus un
6:32
bonus, la compaction n'est plus une rustine.
6:35
Le bridge n'est plus une intégration distante, tout
6:38
devient lisible comme une lutte contre l'oubli, la saturation,
6:41
la fragmentation, l'arrêt brutal.
6:44
Et cette cohérence est peut être la première vraie preuve de
6:47
maturité du produit. Un bricolage accumule des
6:49
fonctions, une vision cohérente relie des problèmes qui au
6:53
premier regard n'avaient rien à voir, et cette prise de
6:56
conscience modifie aussi notre manière d'écouter le reste.
6:59
On ne va plus chercher seulement les fonctions les plus
7:01
spectaculaires, on va chercher ce qu'elles essayent de réparer.
7:05
Quelle faiblesse structurelle du modèle elle compense, quelle
7:08
forme de continuité elle fabrique ?
7:10
C'est là et seulement là que le code commence vraiment à parler.
7:13
À cette échelle, lire n'est déjà plus une simple consultation,
7:17
c'est une forme d'archéologie. Chapitre 3, l'orchestre on
7:22
croyait trouver un assistant, on tombe sur un coordinateur des
7:25
sous agents des forks des rôles. Ce n'est déjà plus une voix,
7:30
c'est une organisation. La première grande surprise du
7:32
Repo, c'est qu'anthropique semble déjà penser au-delà du
7:34
modèle solitaire, pas dans les discours marketing.
7:37
Dans l'architecture elle même, il y a au cœur de cloud code un
7:40
mode coordinateur. Et ce coordinateur ne se
7:42
contente pas d'appeler des outils, il peut lancer d'autres
7:45
agents, leurs délégués du travail, reprendre leurs fils,
7:48
synthétiser leurs résultats, arbitrer entre eux.
7:50
Là, il faut définir un premier concept propre à ce code à fork
7:53
dans cloudcode, c'est un sous ageant lancé avec une partie du
7:56
contexte du parent, un spawn. À l'inverse, c'est un agent
7:59
frais lancé à 0. La distinction n'est pas
8:02
cosmétique, elle répond à un problème très concret, faut-il
8:05
repartir avec l'historique et le cash de contexte où créer un
8:08
travailleur vierge pour une tâche séparée ?
8:10
Le code ne traite pas ça comme un détail d'implémentation, il
8:12
en fait une décision structurante.
8:14
Plus fort encore, le système prompte du coordinateur contient
8:17
une règle qui vaut presque manifeste, ne jamais déléguer la
8:20
compréhension elle même. En clair, on ne doit pas dire à
8:23
un sous agent, trouve ce que tu veux et je M Alignerai sur toi,
8:26
le parent doit comprendre ce qu'il confie comprendre.
8:28
Prendre ce qu'il reçoit, puis décider.
8:30
Cette règle à l'air abstraite, en réalité, elle est très
8:32
concrète. Elle dit qu'une bonne délégation
8:34
n'est pas l'abandon du jugement, c'est son extension contrôlée.
8:37
On voit aussi apparaître 2 interdictions très révélatrices,
8:40
ne pas regarder par-dessus l'épaule du sous ageent pendant
8:42
qu'il travaille et ne pas anticiper ses conclusions avant
8:45
son retour. Ces règles sont là pour éviter
8:47
de re contaminer le contexte principal avec du bruit et pour
8:50
éviter que le parent fabrique une réponse avant même d'avoir
8:53
reçu le résultat. Ce n'est pas seulement élégant,
8:55
c'est une manière très claire de reconnaître les limites
8:57
structurelles d'un. Il se pollue vite, il sature
9:00
vite, il mélange tout. Dans cette architecture, le
9:02
modèle n'est plus simplement une voix qui répond à la prochaine
9:05
ligne, il devient une répartition du travail.
9:07
Il y a des agents built in, des spécialisations, des expériences
9:11
déployées derrière future flags. Même les agents intégrés
9:14
semblent testés, ajustés, parfois activés progressivement.
9:16
Cela raconte un produit encore en mouvement, mais déjà
9:19
convaincu d'une chose, le futur ne sera probablement pas un
9:22
super agent unique, il ressemblera davantage à une
9:25
petite organisation, et cette intuition est fonctionnellement.
9:28
Une des plus intelligentes du Repo le vrai problème d'un agent
9:31
solitaire, ce n'est pas seulement qu'il peut se tromper,
9:33
c'est qu'il doit tout faire dans la même tête, explorer,
9:36
planifier, exécuter, relire, résumer, surveiller.
9:39
Très vite, il paye cette centralisation en confusion, en
9:42
saturation de contexte en collision.
9:44
L'architecture de cloud code tente une autre réponse, séparer
9:48
les lignes de travail, isoler des espaces, distribuer
9:50
l'effort, puis faire revenir le tout vers un centre.
9:53
Si cette logique tient, l'interface utile de demain ne
9:55
sera peut être plus parler à une I à mais diriger.
9:58
Une petite équipe DIA avec des rôles, des retours, des
10:00
arbitrages et une mémoire de ce qui a déjà été confié.
10:03
C'est une bascule considérable. Elle veut dire que la valeur ne
10:06
sera plus seulement dans la qualité d'une réponse, mais dans
10:09
la capacité à distribuer le travail, à garder la trace de ce
10:12
qui a été tenté et à faire revenir vers un centre des
10:14
lignes d'effort séparées. On peut dire les choses
10:16
simplement, ce code ne pense déjà plus comme un individu, il
10:19
pense comme une structure, et c'est l'un des moments où
10:22
l'image du simple assistant commence à se fissurer pour de
10:24
bon. L'unité de base, ici, ce n'est
10:26
plus l'agent, c'est l'organisation.
10:29
Chapitre 4, les collègues dans les murs, des pannes de
10:32
terminal, des permissions synchronisées, un chef d'équipe,
10:34
des spécialistes. Le terminal cesse d'être une
10:37
fenêtre, il commence à ressembler à un bureau.
10:39
Si le coordinateur est l'idée, le soir en est la
10:41
matérialisation. Dans une autre partie du Repo,
10:44
on découvre un système de TEAM eight, des instances cloud qui
10:48
peuvent travailler en parallèle, visibles dans des pain séparées
10:51
via Teamux via I Term 2 ou même à l'intérieur du même processus.
10:55
Là encore, le mot important n'est pas l'exploit technique,
10:58
c'est le déplacement d'imaginaire.
11:00
Le terminal n'est plus un point de dialogue unique, il devient
11:02
un espace de cohabitation. Le dispositif est
11:06
remarquablement concret, il YA1 chef d'équipe réservé des
11:09
membres des modes de permission, des chemins autorisés partagés,
11:12
des réglages synchronisés entre les peines.
11:15
Le leader peut modifier le mode d'un autre agent.
11:17
Un chemin débloqué peut être rendu disponible au reste de
11:20
l'équipe. Un layout manager organise la
11:22
disposition. Tout cela fait moins penser à un
11:25
plugin malin qu'à l'ébauche d'un bureau distribué.
11:29
Et c'est là qu'apparaît l'une des intuitions les plus fortes
11:31
du produit. Pour beaucoup de systèmes IA, la
11:33
parallélisation reste abstraite. On sait qu'il y a plusieurs
11:36
appels, on sait qu'il y a des branches, mais tout reste
11:39
comprimé dans une seule interface.
11:40
Ici anthropique donne une forme visible.
11:43
À cette pluralité, le travail parallèle devient visible, il
11:47
acquiert presque une spatialité. Vous n'avez plus seulement un
11:50
modèle qui fait plusieurs tâches.
11:51
Vous avez plusieurs présences de travail installées autour de
11:54
vous. Fonctionnellement, c'est très
11:57
intelligent parce que le principal problème des agents
11:59
parallèles, en pratique, ce n'est pas seulement de les
12:01
lancer, c'est de garder une compréhension humaine de ce qui
12:04
se passe, qui travaille sur quoi, qui peut écrire, qui a
12:08
besoin de permission, qui est bloqué.
12:10
Dès qu'on met tout dans le même flux, on retrouve de la
12:13
confusion. En séparant les coéquipiers, le
12:15
système gagne en lisibilité mentale.
12:18
Et cette lisibilité compte autant que la puissance brute.
12:21
Une parallélisation invisible impressionne, peut être en démo
12:24
une parallélisation visible, elle devient vraiment
12:27
supervisable. C'est la différence entre un
12:29
tour de magie et un vrai poste de travail.
12:32
Et c'est aussi sans doute une condition d'adoption réelle,
12:35
tant que plusieurs agents travaillent dans un brouillard
12:37
opaque, l'humain hésite à déléguer.
12:40
Dès qu'il peut voir la pièce, les rôles, les blocages et les
12:43
permissions, la délégation cesse d'être mystique, elle devient
12:46
managériale. Il y a aussi quelque chose de
12:49
plus discret, mais très important dans ce choix.
12:52
Le produit ne se contente pas d'automatiser, il met en scène
12:55
le travail, il rend visible la division du travail, il donne à
12:59
l'utilisateur la sensation d'une équipe et pas seulement d'un
13:02
service opaque. Cette visibilité n'est pas
13:05
secondaire, elle aide à faire confiance, à superviser, à
13:08
reprendre la main. Une équipe d'agents que l'on ne
13:10
peut ni voir ni comprendre ressemble vite à une magie
13:13
noire. Ici, anthropique essaie d'en
13:16
faire un espace administrable. Ce chapitre du code dit donc 2
13:20
choses à la fois. D'abord, anthropique semble
13:22
convaincu que la prochaine interface utile pour l'i a n'est
13:25
pas l'agent unique. Ensuite, il semble comprendre
13:29
qu'une équipe d'agents n'est exploitable que si l'humain peut
13:31
encore voir la pièce, les rôles, les trajectoires.
13:35
Le clavier est toujours le même. Le monde derrière lui, lui, a
13:38
déjà changé. Chapitre 5, la lutte contre
13:42
l'oubli. Un agent sans mémoire s'épuise
13:46
un agent qui se souvient de tout s'effondre entre les 2.
13:50
Il faut inventer une discipline et c'est là que le code devient
13:54
vraiment intéressant. Il y.
13:55
A une erreur très fréquente. Quand on parle de mémoire pour
13:57
les modèles, on imagine qu'il suffit d'en avoir plus.
14:00
Plus de contexte, plus d'historique, plus de documents,
14:03
plus de tout. Le Repo de Claude Code semble
14:05
répondre exactement l'inverse. Le vrai problème n'est pas
14:08
d'empiler. Le vrai problème c'est de
14:09
hiérarchiser. Il faut définir ici une notion
14:12
simple, la compaction dans ce système.
14:14
C'est l'art de réduire ce qu'un agent garde en tête pour éviter
14:17
la saturation. Concrètement, quand une
14:18
conversation devient trop longue, cloud code résume,
14:21
coupe, réorganise et tente de préserver ce qui reste vraiment
14:25
utile pour la suite. Cette idée n'est pas nouvelle en
14:27
soi, ce qui l'est davantage, c'est le soin avec lequel elle
14:30
est déclinée. Il y a plusieurs couches,
14:31
d'abord un fichier d'instruction durable, Claude point, MD, qui
14:35
dit à Claude comment travailler dans un projet donné.
14:37
Ensuite, une mémoire de cession, un fichier de notes tenues en
14:40
arrière-plan au fil de la conversation, puis un système
14:42
d'extraction qui. Après, certaines réponses
14:45
essaient de capter ce qui mérite de survivre.
14:47
A côté de cela, il y a des types de mémoires distincts,
14:50
utilisateur, projet, feedback, référence.
14:53
Autrement dit, tout n'a pas le même statut, tout ne mérite pas
14:56
le même type de persistance. Cette architecture est brillante
14:59
pour une raison simple, elle comprend qu'une bonne mémoire
15:01
artificielle n'est pas une mémoire plus grosse, c'est une
15:03
mémoire mieux rangée. Une mémoire qui distingue ce qui
15:06
sert maintenant, ce qui servira demain, ce qui relève d'une
15:09
habitude personnelle, ce qui relève d'une convention d'équipe
15:12
et ce qui peut être retrouvé ailleurs.
15:14
Dans le code ou dans git, le système dit même explicitement
15:17
qu'il ne faut pas sauver ce qui est déjà dérivable du Repo.
15:20
Là, on touche quelque chose de très mûr.
15:22
La mémoire n'est pas là pour dupliquer le monde, elle est là
15:24
pour garder ce que le monde ne sait pas dire tout seul, et
15:27
c'est probablement l'un des vrais chemins d'avenir pour les
15:29
agents de travail. Le long contexte promet de tout
15:32
garder. Ce code part d'une idée plus
15:33
réaliste, tout garder n'aide pas à travailler, il faut classer,
15:37
extraire, oublier puis stabiliser.
15:39
C'est plus sobre que le fantasme de la mémoire infinie et
15:42
beaucoup plus crédible un collaborateur utile.
15:44
N'est pas celui qui n'oublie jamais rien, c'est celui qui
15:46
sait quoi retenir, quoi retrouver et quoi laisser
15:48
retomber. A cela s'ajoute une autre
15:50
finesse, une partie du mécanisme sert non pas à créer des
15:53
souvenirs, mais à faire de la place.
15:55
Il existe une version plus chirurgicale de la compaction,
15:58
le micro compact. L'idée est simple, retirer
16:00
certains blocs lourds devenus peu utiles, notamment des
16:03
résultats d'outils, sans repartir entièrement de 0.
16:06
Le code cherche même à faire cela sans casser le cash de
16:08
contexte côté serveur. Dit autrement, il essaie
16:11
d'alléger ce que Claude traîne avec lui sans payer à nouveau.
16:14
Tout le prix de la mémoire immédiate.
16:16
Et ce n'est pas la seule réponse du produit à ce problème.
16:18
Il y a aussi les skills. Un skill ici, ce n'est pas juste
16:21
un prompt pratique, c'est une compétence encapsulée avec son
16:24
nom, ses arguments, ses outils autorisés, parfois ses fichiers
16:27
de référence, parfois même son propre agent.
16:30
Le geste est important, au lieu d'entasser toutes les procédures
16:32
dans la tête de Claude ou dans un énorme fichier d'instruction,
16:35
le système les externalise dans des unités réutilisables.
16:38
On ne demande plus au modèle de tout garder en tête, on lui
16:41
donne les moyens de charger la bonne procédure au bon moment.
16:44
Et cela aussi, c'est une gestion de budget, budget de contexte,
16:47
budget d'attention, budget de complexité.
16:49
On sent ici une obsession saine, ne pas oublier ce qui compte, ne
16:53
pas s'encombrer du reste, ne pas transformer l'historique en
16:55
marécage. C'est une obsession
16:57
fonctionnelle mais presque philosophique aussi.
16:59
Entre l'amnésie et l'encombrement, le produit
17:02
invente une discipline et c'est peut être au fond le cœur du
17:04
sujet. Claude code ne cherche pas
17:06
seulement à augmenter un modèle, il cherche à lui fabriquer une
17:09
durée soutenable. Chapitre 6, le rêve, puis le
17:12
code se met à parler d'autre chose.
17:14
De consolidation de souvenirs de sommeil ?
17:17
Presque à ce moment-là, l'enquête change de régime.
17:20
Puis un mot apparaît dans le code auto Dream.
17:23
Il faut prendre une 2nde pour mesurer ce que cela veut dire.
17:26
Pas dans un article, pas dans un prototype de labo, dans un
17:29
produit réel, une fonction de rêve.
17:32
Il faut ici définir ce concept avec précision.
17:35
Le rêve dans cloud code désigne une phase différée où le système
17:39
relie ce qu'il a accumulé pour en extraire des souvenirs plus
17:41
stables. Il ne le fait pas en continu, il
17:43
attend un certain temps un certain nombre de sessions, puis
17:47
il déclenche une consolidation sous verrou avec retour arrière
17:50
possible en cas d'échec. Le plus frappant, c'est que
17:53
l'image n'est pas seulement poétique, elle est
17:55
fonctionnellement exacte. Si vous essayez de tout
17:57
consolider à chaud dans le flux principal, vous polluez la
18:01
conversation. Si vous ne consolidez jamais,
18:03
vous accumulez de la dette contextuelle.
18:05
Si vous le faites trop souvent, vous gaspillez du calcul.
18:08
Le rêve répond à ce problème comme une maintenance cognitive
18:11
à froid, hors du fil après coup. Autrement dit, l'agent ne se
18:15
contente plus de vivre des sessions, il commence à
18:17
retraiter son expérience à distance du flux comme une
18:20
matière qu'il faut rendre à nouveau exploitable.
18:23
Et c'est là que la perspective devient vraiment forte.
18:25
Si ce type de logique se généralise, les agents de demain
18:28
ne se contenteront plus d'accumuler des échanges.
18:31
Ils réviseront leurs habitudes, consolideront leurs
18:33
apprentissages utiles. Et convertiront leur passé en
18:36
structure de travail. Le prompte de cette phase est
18:39
lui même révélateur, le système doit s'orienter, relire,
18:42
rassembler, fusionner puis nettoyer.
18:45
On n'est plus dans la simple conservation, on est déjà dans
18:48
la digestion. C'est probablement l'une des
18:50
intuitions les plus fortes de tout le repo pour qu'un agent
18:53
dur. Il ne suffit pas qu'il garde, il
18:55
faut aussi qu'il transforme ce qu'il a gardé en quelque chose
18:58
de plus compact, de plus structuré, de plus habitable
19:01
pour la suite. Et c'est là que le produit cesse
19:03
d'être seulement ingénieux pour devenir, disons, le fascinant.
19:07
Parce qu'un outil qui se met à rêver ne fait pas qu'ajouter une
19:09
fonction, il change de régime d'imaginaire.
19:12
Il suggère qu'une IA de travail ne doit pas seulement répondre
19:14
vite, mais revenir sur son expérience, leur donner.
19:19
La retravailler, la stabiliser. On peut trouver le mot un peu
19:22
trop beau, mais il y a de la rigueur derrière lui.
19:24
Ce n'est pas encore un esprit ? Bien sûr que non, mais c'est
19:27
déjà une tentative de fabriquer une forme de durée mentale.
19:30
Le produit cesse D accumuler, il commence à digérer et à partir
19:34
de là, le mot assistant devient vraiment trop petit.
19:37
Chapitre 7, la paranoïa du chêne, il suffit d'une commande
19:40
pour casser un monde. Alors ici, chaque espace, chaque
19:44
côté, chaque caractère invisible devient une menace.
19:47
La poésie s'arrête, la méfie. Elle commence jusqu'ici.
19:50
On a beaucoup parlé d'organisation, de mémoire, de
19:53
continuité. Et puis on tombe sur bash tool.
19:56
Là, l'atmosphère change brutalement parce qu'à partir du
19:58
moment où un agent peut toucher au Shell, il peut toucher à tout
20:01
vos fichiers, votre dépôt, vos secrets, votre machine.
20:05
Le code le sait et il réagit avec une prudence presque
20:08
obsessionnelle. Ce passage mérite une définition
20:10
simple, la couche de sécurité bâche ici n'est pas juste une
20:14
pop up de confirmation. C'est un ensemble de règles qui
20:17
essaie de comprendre si une commande est dangereuse,
20:19
ambiguë, contournable ou volontairement obfusquée.
20:21
Et la profondeur de ce travail est saisissante.
20:23
On trouve des dizaines de checks, substitutions de
20:26
commandes variables piégées, espace unicode, invisible
20:29
commentaires qui désynchronisent la lecture, modules et des sages
20:32
capables d'ouvrir des chemins d'écriture ou de réseau là où on
20:36
ne les attend pas. Ce qui est remarquable, ce n'est
20:37
pas seulement la liste des menaces, c'est la philosophie
20:40
qu'elle révèle. Le Shell n'est pas traité comme
20:42
un simple canal d'exécution, il est traité comme un langage
20:44
hostile. Un langage où la moindre
20:46
ambiguïté syntaxique peut devenir une brèche.
20:49
Et cette lucidité là compte énormément.
20:51
Beaucoup de produits agentiques semblent encore penser que la
20:53
sécurité se résume à une sandbox et à 2 alertes.
20:55
Ici on voit autre chose, une tentative de lire le danger dans
20:59
la grammaire. L il y a même dans ce code une
21:02
forme de pédagogie de la catastrophe.
21:04
Les règles autour de git sont explicites, ne pas forcer
21:06
certains comportements, ne pas faire comme si un amant raté
21:09
était anodin, ne pas avaler un dépôt entier par paresse.
21:12
Ce sont des consignes qui sentent l'expérience.
21:15
Le produit n'est pas en train d'imaginer des accidents
21:17
théoriques. Il a l'air d'avoir rencontré des
21:19
modes d'échecs très concrets et d'en avoir tiré une doctrine
21:22
fonctionnellement. C'est l'une des parties les plus
21:24
rassurantes de tout le repo, non parce qu'elle éliminerait le
21:26
risque, mais parce qu'elle montre qu'anthropique comprend
21:29
où se situe la frontière réelle entre l'agent utile et le
21:32
sabotage involontaire. Dès qu'un agent touche au Shell,
21:34
chaque caractère devient politique et parfois, la vraie
21:37
frontière entre l'agent et la catastrophe tient à un caractère
21:40
invisible. C'est là qu'on voit la
21:42
différence entre un jouet impressionnant et un système
21:44
déployable. Le modèle le plus brillant du
21:46
monde vaut peu s'il reste impossible à laisser agir sans
21:49
peur. Et c'est peut être l'une des
21:51
leçons économiques du Repo dans l'i a appliquée.
21:53
L'avantage ne viendra pas seulement du modèle le plus
21:56
fort, il viendra aussi de l'architecture qui permet de
21:58
laisser ce modèle agir dans le réel sans transformer chaque
22:01
action en Paris. Chapitre 8, la machine est
22:04
tendue à mesure qu'on avance, Claude Code cesse d'habiter un
22:08
terminal. Il traverse des ponts, change de
22:10
machine, reprend son travail ailleurs, l'outil devient
22:14
mobile, presque nomade. Une autre lecture naïve du
22:17
produit consisterait à dire très bien Claude code est un bon
22:20
outil local avec beaucoup de mémoire, beaucoup de sécurité et
22:24
quelques sous agents. Là encore, le Repo répond non
22:27
parce qu'il est traversé de part en part par une logique de
22:29
transport. MCP, bridge, Remote session,
22:32
Téléportation ultra plan. Tout cela raconte un système qui
22:36
pense déjà au-delà de la machine sur laquelle il a été lancé.
22:39
Prenons d'abord un mot qu'on peut utiliser vite ici, le
22:42
bridge. Dans cloud code, le bridge est
22:45
la couche qui relie une session locale à une infrastructure
22:47
distante capable de la maintenir, de la reconnecter, de
22:51
la déplacer, parfois de la relancer.
22:54
Le détail important n'est pas le vocabulaire, c'est le geste
22:57
architectural. Le produit n'est plus défini par
23:00
un terminal fixe, il est défini par la continuité d'un travail à
23:03
travers plusieurs lieux d'exécution.
23:05
On le voit très bien dans la téléportation, là encore il faut
23:09
être concret, téléporter une session ici, c'est reprendre le
23:13
même fil de travail sur une autre machine ou dans un autre
23:16
environnement, avec une branche guide cohérente, un État
23:19
restauré, un contexte remis d'aplomb.
23:22
Autrement dit, cloud code ne veut pas seulement conserver un
23:25
dialogue, il veut transporter un poste de travail.
23:28
Et cette idée culmine dans ultra plan où le terminal peut devenir
23:32
rampe de lancement vers cloud code sur le web pour une
23:35
planification plus ample avant retour vers l'exécution.
23:38
Le mot important n'est même pas web, c'est l'idée de déport.
23:41
On peut commencer ici, penser là-bas, revenir ailleurs.
23:45
On est déjà sorti du modèle du simple programme local.
23:49
Fonctionnellement, c'est très fort parce que l'un des plus
23:52
gros problèmes des outils IA en usage réel, c'est la rupture.
23:55
On ferme, on change de machine, on perd le contexte.
23:58
On ne sait plus ce qui était stable, ce qui était local, ce
24:02
qui était transportable. Claude code semble affronter ce
24:05
problème de face, le terminal n'est plus un lieu fixe, c'est
24:08
un point de passage. Et si cette logique va au bout,
24:11
cloud code cessera d'être perçu comme un simple programme.
24:14
Il commencera à ressembler à un poste de travail déplaçable pour
24:18
intelligence artificielle. C'est une idée beaucoup plus
24:21
profonde qu'une simple fonction de synchronisation.
24:23
Cela veut dire qu'un agent pourrait demain appartenir moins
24:26
à une machine qu'à un continuum d'environnement local.
24:30
Distant web équipe infra le terminal ne serait plus sa
24:35
maison, seulement l'une de ses portes.
24:37
Et ce n'est peut être déjà plus seulement une hypothèse.
24:40
Dans d'autres zones du code, on voit apparaître le navigateur
24:43
comme canal d'action à part entière.
24:44
On voit aussi poindre côté Mac OS des couches de contrôle
24:48
d'ordinateur, capture d'écran, souris, clavier, permission
24:52
système. Le détail compte parce qu'il
24:55
élargit la scène. Ce que ce repo Assemble, ce
24:58
n'est peut être pas simplement un assistant de terminale plus
25:01
sophistiqué, c'est peut être le début d'un environnement général
25:04
d'action pour agent logiciel. Un lieu où mémoire,
25:07
coordination, navigateur, machine et transport commence à
25:11
parler le même langage. Chapitre 9, le petit animal.
25:16
Et puis, au milieu de cette architecture sévère, on trouve
25:20
un compagnon, une petite présence à côté du champ de
25:22
saisie, comme si quelqu'un avait glissé un tamagotchi dans une
25:25
machine de guerre. Il.
25:26
Y a des moments dans une lecture de code où un détail change la
25:29
lumière de tout le reste. Buddy dans cette histoire joue
25:31
ce rôle. On découvre un compagnon généré
25:34
à partir de l'identité de l'utilisateur avec des.
25:36
Espèces, une rareté, parfois une version shiny, des accessoires,
25:39
des statistiques et même une sorte de vocabulaire intérieur
25:42
fait d'os et d'âme. Il faut être prudent ici.
25:45
Ce détail ne résume pas le produit, mais il ne faut surtout
25:47
pas le traiter comme une simple plaisanterie parce qu'il dit
25:49
quelque chose que le reste du ripo suggérait déjà, sans
25:52
l'avouer, complètement anthropique ne cherche pas
25:54
seulement à fabriquer une machine utile, il cherche aussi
25:57
une forme de présence. Le Buddy n'exécute pas bash, il
26:00
ne gère pas le bridge, il ne compacte pas le contexte, mais
26:02
sa simple existence indique qu'au cœur de cette architecture
26:05
extrêmement sérieuse. Quelqu'un pense aussi à
26:07
l'attachement, à la familiarité, à la continuité sensible d'une
26:11
relation d'usage. C'est une intuition plus
26:13
importante qu'elle n'en a l'air. À mesure que les agents
26:15
deviennent plus persistants, plus mémoriels, plus présents
26:18
dans le quotidien de travail, l'interface ne peut pas rester
26:20
purement instrumentale, il y aura de la présence, qu'on le
26:23
veuille ou non. Le Buddy ici sert presque de
26:25
révélateur, il rend visible la part affective que d'autres
26:28
couches du produit portent déjà de manière plus discrète, la
26:31
reprise, la continuité, la mémoire, le nom des sessions, la
26:35
persistance des. D'habitude, ce petit compagnon
26:38
n'est donc pas seulement mignon. Il est une hypothèse, une
26:40
hypothèse sur la manière dont les humains accepteront de
26:42
cohabiter durablement avec des systèmes qui travaillent à côté
26:45
d'eux plus. Agent reste longtemps près de
26:47
vous. Plus la question de la présence
26:49
cesse d'être accessoire et cela aussi a des conséquences
26:52
fonctionnelles. La présence n'est pas seulement
26:54
du design affectif, c'est aussi une manière de rendre
26:56
supportable, familier, presque naturel, le fait de travailler
27:00
chaque jour avec une entité logicielle persistante au cœur
27:03
de la machine. Quelqu'un a laissé entrer un
27:05
petit animal ? Chapitre 10, signé, le code
27:08
écrit, le Code agit, le code se souvient.
27:11
Restait une dernière question, est ce qu'il laisser une trace
27:13
de sa part dans ce qu'il produit ?
27:15
La réponse elle aussi. Et dans git.
27:17
La dernière grande surprise du Repo est peut être la plus
27:19
politique. Cloud code ne se contente pas
27:21
d'aider à produire du code, il cherche aussi à mesurer puis à
27:24
inscrire la part de cette aide dans ce qui a été fait.
27:26
Dans le système d'attribution de commit, on voit apparaître une
27:29
estimation de contribution par cloud par humaine, surface
27:32
concernée, métadonnées de cession.
27:33
Dit autrement, le produit commence à compter sa part.
27:36
Il faut définir ici une notion très simplement, l'attribution
27:39
de commit, c'est le fait de laisser dans git une trace
27:41
structurée de la contribution estimée de Claude dans le
27:44
travail livré. Le détail technique importe
27:46
moins. Que la bascule symbolique, tant
27:47
que l'outil aide sans signer, il reste périphérique.
27:50
À partir du moment où il s'attribue une part, la relation
27:53
change. Ce changement est majeur parce
27:55
qu'il déplace la question, on ne demande plus seulement est ce
27:57
que l'outil est utile ? On demande aussi quelle part du
28:00
travail lui revient, comment la mesurer, comment la raconter,
28:03
comment l'assumer. Et immédiatement, le sujet cesse
28:05
d'être purement technique, il devient social, juridique,
28:08
managérial, presque moral. Ce choix est là encore
28:11
remarquablement lucide, si les agents deviennent des
28:13
collaborateurs durables, on ne pourra pas éternellement.
28:16
Comme si leurs traces se dissolvaient naturellement dans
28:18
le geste humain. Il faudra des conventions, des
28:20
comptes, des manières d'écrire cette participation.
28:23
Le Commit devient ici un lieu de cohabitation mesuré entre
28:26
humains et machines. Dès que l'i a cesse d'être
28:28
ponctuelle pour devenir persistante.
28:30
La vraie question n'est plus seulement ce qu'elle fait, c'est
28:32
comment sa part devient visible, attribuable et gouvernable.
28:35
Et cette question va dépasser très vite git, elle touchera le
28:38
droit, la responsabilité, le management, l'évaluation du
28:41
travail et même la définition ordinaire de l'auteur dans les
28:44
métiers d'écran. Et c'est peut être la meilleure
28:46
manière. Refermer l enquête parce qu'au
28:47
point d'arrivée, Claude Code ne ressemble ni à un simple
28:50
chatbot, ni même à 1IDE1 peu plus avancé, il ressemble à une
28:53
tentative encore inachevée, parfois étrange, parfois
28:54
brillante, de fabriquer autour d'un modèle tout ce qui lui
28:58
manque pour devenir un vrai partenaire de travail, une
29:00
mémoire des collègues, des garde-fous, des transports, une
29:03
continuité, une présence et une signature.
29:05
Et plus on regarde le ripault dans son ensemble, plus l'image
29:08
s'élargit. Terminal, navigateur, machine,
29:09
bridge, équipe, mémoire, session.
29:12
Il faut désormais y ajouter autre chose.
29:16
Des skills et des plugins, c'est à dire des procédures, des
29:19
agents, des hooks, parfois des serveurs MCP Empactés pour être
29:22
réinjectés à la demande. Non pas une fonction de plus
29:24
autour d'un modèle, plutôt le brouillon d'un environnement
29:27
d'action cohérent capable non seulement de se souvenir mais
29:29
aussi de modulariser du savoir faire.
29:31
Et c'est peut être cela au bout du compte que cette fuite rend
29:34
visible non pas un produit fini mais une direction.
29:37
À partir du moment où l'outil signe, la question n'est plus
29:40
technique, elle devient politique.
29:42
Vous écoutiez Claude code ce que révèle la fuite.
29:45
Merci d'avoir écouté cette. Épisode jusqu'au bout si ce
29:47
travail vous plaît, vous pouvez vous abonner, partager l'épisode
29:50
et nous laisser une note.