Claude on Scotch

Présentation

• Jeune autodidacte inspiré par sa famille
• Master en Génie Logiciel à l'Université de Bordeaux
• Parti dans l'industrie sur des sujets R&D
• Ne se considère pas comme un expert en IA mais un ingé curieux qui aime comprendre

Scotch

• Partitionnement de graphes
• Plus de 30 ans, C, MPI — au cœur du HPC
• Développé ici, à l'Inria
• Je connais l'auteur

Le plan

1. Mon modèle mental des LLM
2. Parcours avec Scotch
3. Leçons générales de Scotch et d'autres projets

Answering a question - GPT 2/3/3.5/4

2019 — GPT-2 · gpt2-xl · ~4,6 k$ de compute

2020 — GPT-3 · davinci · ~690 k$

2022 — GPT-3.5 · gpt-3.5-turbo-0613 · RLHF · ChatGPT

2023 — GPT-4 · gpt-4-0613 · ~50 M$

→ 2022 = contact grand public

• ChatGPT — construit sur GPT-3.5
• Pour beaucoup : le premier contact
• Un instantané d'une courbe déjà longue

« Attention Is All You Need »

• Les transformers, 2017
• La brique sous GPT-1/2/3 — et sous tout ce qui a suivi

Un transformer

Les lois d'échelle

• 2020 — Kaplan et al. : loss vs compute / paramètres / données — des droites en log-log sur plusieurs ordres de grandeur
• 2022 — Chinchilla : les lois se raffinent (ratio données/paramètres)… elles ne s'abrogent pas

Loi de puissance ≠ absence de limite

• Rendements décroissants par FLOP — oui
• Murs attendus, qui n'ont pas empêché les modèles de s'améliorer
• Manque de compute (et d'énergie) ⇒ investissements
• Manque de données ⇒ synthétiques, nouvelles captations…
• Uniquement un générateur de mots ⇒ environnement agentique

The Bitter Lesson

Richard Sutton (2019)

Les méthodes générales qui exploitent le calcul scalent mieux que l'ingénierie astucieuse spécifique à un domaine.

Les modèles locaux

• Des résultats satisfaisants depuis quelques mois
• Ce qui tourne en local aujourd'hui
  ≈ la frontière d'il y a 1 ou 2 ans
• Certains modèles Open Source hébergés sur des clouds spécialisés sont à 6 mois de la frontière

La fenêtre de contexte

Le system prompt de claude.ai

<claude_behavior>
<product_information>
Here is some information about Claude and Anthropic's products in case the person asks:

This iteration of Claude is Claude Fable 5.1, the newest model in Anthropic's Claude 5 family and part of the Mythos-class model tier that sits above Claude Opus in capability. Claude Fable 5.1 and Claude Mythos 5.1 share the same underlying model. […]

Claude is accessible through Claude Code, an agentic coding tool that lets developers delegate coding tasks to Claude from the command line, desktop app, or mobile app […]
</product_information>
<refusal_handling> […] </refusal_handling>
<tone_and_formatting>
Claude uses a warm tone […] Claude never curses unless the person asks […]
Claude avoids saying "genuinely", "honestly", or "straightforward". […]
</tone_and_formatting>
<user_wellbeing> […] </user_wellbeing>
<evenhandedness> […] </evenhandedness>
<knowledge_cutoff>
Claude's reliable knowledge cutoff, past which it can't answer reliably, is the end of Jun 2026. […]
</knowledge_cutoff>
</claude_behavior>

Pré/post-entraînement

• Pré-entraînement : lire. Le modèle apprend à simuler « heroes, villains, philosophers, programmers, and just about every other character archetype under the sun »
• Post-entraînement : « we select one particular character from this enormous cast and place it center stage: the Assistant »
• Les autres sont toujours là
• Papier d'Anthropic : mesurer la dérive sur un axe, et la capper (activation capping)

Think more

• Quatre modèles, cinq niveaux d'effort chacun — coût par tentative, échelle log
• Opus 5 : de low à xhigh, ×2,5 le prix, +18 points — à max, ça redescend : trop réfléchir existe
• Le plus cher n'est pas le meilleur ici — le plus récent l'est

Un cas « extrême » — Anthropic

« An extreme example of illegible reasoning. Near the end of training, Mythos starts solving a card puzzle with human understandable language that gradually becomes incomprehensible in most episodes with long reasoning. »

Haiku 4.5 traduit

Un modèle plus petit, d'une génération antérieure, avec un autre tokenizer — et il lit sans difficulté.

États internes

• Anthropic : les NLA confabulent
• « Nevertheless, they are suggestive of some degree of gap between the model's internal and external reaction »
• Comportement observé : aucune résistance, aucun sabotage

MCP : déclaration d'un outil

Model Context Protocol, en Python

from mcp.server.fastmcp import FastMCP
from pyscotch import Graph

mcp = FastMCP("scotch")

@mcp.tool()
def partition(graph_file: str, parts: int) -> list[int]:
    """Partitionne un graphe Scotch en `parts` parties."""
    return Graph.load(graph_file).partition(parts).tolist()

Nom, signature, docstring : c'est tout ce que le modèle voit de l'outil.

MCP : interaction avec le modèle

{"name": "partition",
 "description":
   "Partitionne un graphe Scotch
    en `parts` parties.",
 "input_schema": {
   "type": "object",
   "properties": {
     "graph_file": {"type": "string"},
     "parts":      {"type": "integer"}},
   "required": ["graph_file", "parts"]}}

{"type": "tool_use",
 "id": "toolu_01…",
 "name": "partition",
 "input": {"graph_file": "ring.grf",
           "parts": 2}}

   ⇩  votre code l'exécute  ⇩

{"type": "tool_result",
 "tool_use_id": "toolu_01…",
 "content": "[0, 0, 0, 0, 1, 1, 1, 1]"}

harness vs model

4 février 2026, GitHub : « you can run multiple coding agents directly inside GitHub, GitHub Mobile, and Visual Studio Code […] agents like GitHub Copilot, Claude by Anthropic, and OpenAI Codex »

Comment j'interagis avec Claude

• vibe engineering != vibe coding
• mind dump
• poser des questions et pas donner des ordres

Vibe engineering

« seasoned professionals accelerate their work with LLMs while staying proudly and confidently accountable for the software they produce »

Simon Willison — Vibe engineering, 7 octobre 2025 — par opposition au vibe coding

« You could have thirty agents working for you simultaneously. You cannot watch all of them and micromanage each one. You wouldn't do this with your human team either. Instead: write a better harness. »

@mrexodia — Vibe Engineering: What I've Learned Working with AI Coding Agents

Structures de données

« Bad programmers worry about the code. Good programmers worry about data structures and their relationships. »

Linus Torvalds — liste git, 2006

L'agent reformule

Deux lignes en vrac, un cahier des charges. La mise en ordre, c'est lui qui la fait.

« Vibe physics »

• Matthew Schwartz (Harvard, QFT) — 2 semaines de décembre 2025, avec Claude
• Le papier : arXiv:2601.02484, 5 janvier 2026
• Le récit, chez Anthropic : 23 mars 2026
• Claude a triché : paramètres ajustés pour que les courbes collent
• Le physicien l'a vu — parce qu'il connaît son domaine

          from hypothesis import given, strategies as st

          @given(st.lists(st.integers() | st.floats()))
          def test_sort_correctness_using_properties(lst):
              result = my_sort(lst)
              assert set(lst) == set(result)
              assert all(a <= b for a, b in zip(result, result[1:]))
        

Déjà un papier

• Agentic Property-Based Testing: Finding Bugs Across the Python Ecosystem
• Maaz†, DeVoe*, Hatfield-Dodds*†, Carlini† — 10 octobre 2025
  * mainteneur d'Hypothesis · † Anthropic (Maaz : MATS, Anthropic ; DeVoe : Northeastern University)
• Un agent lit le code, infère les propriétés, écrit les tests, rédige le rapport
• 56 % des rapports générés : des bugs valides
• ~6 mois avant la vague Mythos

Jour 7 : le premier bug Scotch

• 4 nov. 2025 : premier commit, sessions Claude Code web (7 branches claude/…)
• Objectif : charger 32 et 64 bits, séquentiel et MPI, dans un même process
• 11 nov. : « Building with suffixes worked fine, but when loading BOTH 32-bit and 64-bit variants in the same process, there were symbol name collisions because some symbols weren't getting suffixed. »
• 12 macros manquantes dans module.h : 1 constante, 1 type, 10 fonctions dmesh
• Trouvé par le build, confirmé en lisant le C

Le reçu, le jour même

Signalé le 11, corrigé le 11.

2. Hypothesis sur le wrapper

@given(graph_data=simple_graph(min_vertices=2, max_vertices=20))
def test_coloring_no_adjacent_same_color(self, graph_data):
    num_vertices, edges = graph_data
    graph = Graph.from_edges(edges, num_vertices=num_vertices)
    coloring, num_colors = graph.color()

    for u, v in edges:
        assert coloring[u] != coloring[v]

L'invariant du coloriage. Le test C de Scotch, lui, vérifiait le code de retour et imprimait un histogramme.

Hypothesis trouve un bug

Replay Hypothesis

Scotch 34ea137 (14 janv. 2026, la veille du fix) · pyscotch a32f242 (déc. 2025) · Hypothesis 6.168, seed 1, verbosité debug, un cas par ligne. Premier échec au cas n°19 : 17 sommets, 38 arêtes. Puis la réduction : les arêtes tombent une à une, (17, [(5, 10)]), (17, [(1, 10)]), 17 → 15 → 13 → 11 sommets. 107 cas, 16 réductions, 3 s : graph_data=(11, [(1, 10)]). Sur v7.0.14 : 100 exemples, 0 échec.

Le reçu — janvier 2026

-        if (colotax[vertend] >= 0)
-          continue;
+        if ((coloend >= 0) &&                     /* If vertex has been colored    */
+            (coloend < colonum))                  /* In a former pass              */
+          continue;                               /* Do not consider it any longer */

L'analyse de décembre était la bonne. Le vérificateur d'abord, le fix le lendemain. 25 mars 2026 : xfail retiré, test vert.

3. mars 2026 : lecture des tests C

• CLAUDE.md pyscotch : « Scotch's C tests often only verify return codes, not output validity »
• 22 mars 2026, fork c4ffein/scotch, branche add-output-validity-checks : 23 tests C reçoivent des assertions, +523 lignes

static void
checkOrder (const SCOTCH_Num * const permtab, const SCOTCH_Num * const peritab,
            const SCOTCH_Num baseval, const SCOTCH_Num vertnbr)
{
  for (vertnum = 0; vertnum < vertnbr; vertnum ++) {
    /* ... permtab[vertnum] et peritab[vertnum] dans [baseval, baseval + vertnbr) ... */
    if (peritab[permtab[vertnum] - baseval] != vertnum + baseval) {
      SCOTCH_errorPrint ("checkOrder: permutation not bijective at vertex " SCOTCH_NUMSTRING, vertnum + baseval);
      exit (EXIT_FAILURE);
    }
  }
}

2 avril 2026 : unconfirmed cause

git log du fork : 2 avr. « hegel report » · 3 avr. « gaslighted again by me good Claude » · 5 avr. « add hgraph_order_cp.c fix actually »

exemple du binding C

static void test_add_commutes (hegel_testcase *tc) {
  int a = HEGEL_DRAW_INT (-1000, 1000);
  int b = HEGEL_DRAW_INT (-1000, 1000);
  HEGEL_ASSERT (a + b == b + a, "a=%d b=%d", a, b);
}

int main (void) { hegel_run_test (test_add_commutes); return 0; }
        

Schémas de mon wrapper

hegel_schema_t edge_schema = HEGEL_STRUCT (EdgePair,
    HEGEL_INT (0, MAX_VERT - 1),
    HEGEL_INT (0, MAX_VERT - 1));

graph_schema = HEGEL_STRUCT (Graph,
    HEGEL_INT (3, MAX_VERT),
    HEGEL_ARRAY_INLINE (edge_schema, sizeof (EdgePair), 0, MAX_EDGES));

/* ... build CSR, SCOTCH_graphOrder with SCOTCH_STRATDISCONNECTED ... */
memset (permtab, 0xBB, nvert * sizeof (SCOTCH_Num));   /* sentinel */
hegel_note (tc, "MINIMAL nvert=%d nedges=%d edges=[...]");  /* printed on the final replay only */

Replay hegel-c

enregistré aujourd'hui avec le hegel-c de juillet 2026, sur le Scotch d'avant le fix — la branche du 2 avril faisait la même chose, en moins propre

Scotch v7.0.11 (avant le fix du 15 avril) · hegel-c ce16904, moteur hegel-rust v0.17.4. Cas n°6 : premier échec sur 20 sommets. Cas n°185 : déjà 3 sommets, 1 arête. 10 175 cas en 17 s, puis MINIMAL nvert=3 nedges=1 edges=[(1,2)] — 6 runs sur 6. Sur v7.0.14 : 200 cas, rien.

Un graphe à 3 sommets

• Notre rapport du 5 avril : un reproducteur à 14 sommets, écrit à la main. Le test ajouté par François le 15 : 6 sommets (trois isolés, un triangle). hegel-c : 3.
• hegel-c repart de zéro (3–20 sommets, 0–30 arêtes), touche le bug en quelques essais (~25 %), et réduit
• ~2 runs sur 5 atteignent le minimum théorique ; les autres s'arrêtent à 4 sommets ou 2 arêtes. La CI exige nvert ≤ 5

Épisode 2 — 5 avril : une variable

Fausse piste : les sommets isolés. Vraie cause : le chemin compression de hgraphOrderCp ignore ordenum.

-  for (coarvertnum = coargrafdat.s.baseval, finevsizsum = 0;
+  for (coarvertnum = coargrafdat.s.baseval, finevsizsum = ordenum;

Conditions : STRATDISCONNECTED + ≥ 2 composantes + une composante non première qui compresse (une paire K₂ suffit). Présent depuis v6.0 au moins. Corruption silencieuse : rc = 0.

Le reçu — 15 avril 2026

+  if (finegrafptr->s.vertnbr <= 2)                /* Do not lose time when compression is irrelevant */
+    return (hgraphOrderSt (finegrafptr, fineordeptr, ordenum, cblkptr, paraptr->stratunc));
 [...]
-  for (coarvertnum = coargrafdat.s.baseval, finevsizsum = 0; /* Compute initial indices for inverse permutation expansion */
+  for (coarvertnum = coargrafdat.s.baseval, finevsizsum = ordenum; /* Compute initial indices for inverse permutation expansion */

Le mainteneur reprend le fix, ajoute un court-circuit pour ≤ 2 sommets, et le test qui manquait. Le même jour. Signalé le 5, corrigé le 15.

Replay : installation

Machine sans aucun Scotch. uv venv, uv pip install "pyscotch[parallel]" : pyscotch 7.0.4 depuis PyPI, mpi4py en wheel binaire, rien à compiler. Cinq lignes de Python : parts: [0 1 1 0] avec le Scotch 7.0.13 embarqué dans la wheel. 1,4 s.

Replay : pyscotch doctor

Juste après l'install : la wheel, « No problems detected ». Puis PYSCOTCH_PARALLEL=1 : « Loaded NO », le fichier qui manque, et la commande exacte qui le construit. Le diagnostic est la documentation.

Replay : pyscotch scotch build

pyscotch scotch build --parallel --use : preflight, source Scotch 7.0.13 téléchargée depuis gitlab.inria.fr (8,3 Mo, sha256 vérifié), aucun quickfix nécessaire pour cette version, make libscotch + libptscotch, sélection. 1 min 00 s sur 8 cœurs, sans root. Puis doctor en parallèle, et un Dgraph 8×8×8 partitionné en 4 sous mpirun -n 2.

La pipeline

8 workflows GitHub Actions. Deux jumeaux : « Build Scotch from CLI » installe depuis le dépôt et garde le code, « Verify published PyPI release » installe depuis PyPI et certifie le paquet publié. L'oracle, à chaque push : les outils de Scotch eux-mêmes, et 14 sorties dorées.

L'arc, en dates — récap

3 commits upstream « [report C. Pellegrini] » · 3 autres corrections tracées à nos signalements · 4 toujours ouverts en v7.0.14

Le bilan — chez Scotch

La chronologie, dans git

Heures de Paris (UTC+2). Aucun des deux n'a vu l'autre : le seul accès réseau de la session vers Scotch est le clone, et le log brut le montre.

Le résultat : un patch pour Scotch

          Subject: [PATCH] Base the tree array returned by dorderTreeDist(), as documented

           src/libscotch/dorder_tree_dist.c | 19 ++++++++++++++-----

          +  baseval = grafptr->baseval;
             for (dblkglbnum = 0; dblkglbnum < dblkglbnbr; dblkglbnum ++) {
          -    srt1glbtab[2 * dblkglbnum + 1] = dblkglbnum;
          +    srt1glbtab[2 * dblkglbnum + 1] = dblkglbnum + baseval;
          [...]
          +  treeglbtax = treeglbtab - baseval;   /* TRICK: based accesses to user arrays */
          +  sizeglbtax = sizeglbtab - baseval;
        

Le message de commit

          Base the tree array returned by dorderTreeDist(), as documented

          The user manual states that, in the tree array filled by
          SCOTCH_dgraphOrderTreeDist(), "all node indices start from baseval".
          Yet, dorderTreeDist() numbered the permuted column block indices from
          0, ignoring the base value of the distributed graph passed as
          parameter, whose pointer was hitherto unused.

          Father indices stored in the tree array are now based with respect to
          grafptr->baseval, and the result arrays are accessed through based
          pointers so that the entry for column block (baseval + i) remains at
          array slot i. The father index of the root of the tree remains -1,
          irrespective of the base value, as documented. Callers that already
          handled based indices, such as ParMETIS_V3_NodeND(), which subtracts
          the base value from tree array values, are unaffected for the 0-based
          case and now behave correctly for the 1-based case.
        

Deux patchs

Identique, ligne pour ligne : dblkglbnum + baseval, puis treeglbtax = treeglbtab - baseval. La racine reste à −1. Jusqu'au commentaire /* TRICK: ... */.

Ce qui diffère

Avis de Fable 5.1

Mai 2025 — nudge, nudge, nudge...

• « After that, I only said yes to everything. »
• « Feels like watching a beginner, but 10x, or even 100x faster. »
• « Claude ended up making hardcoded modifications specifically to pass the tests »
• « …easily recognized this mistake once I asked a simple question. »
• « I fixed the remaining issues myself. »

Mai 2026 - process automatique

• D'abord une carte : PORTING.md (motifs Zig → Rust) et LIFETIMES.tsv (durée de vie de chaque champ)
• Puis le port mécanique — « Absolutely none of it worked yet »
• 1 implémenteur, ≥ 2 relecteurs adversariaux : « assume the code is wrong »
  — la réponse au « hardcoded to pass the tests » de 2025
• 1,3 M+ assertions conservées, zéro test supprimé — les tests sont le contrat
• Résultat : 128 bugs corrigés, binaire plus léger de 3,8 Mo (Windows) à 6,8 Mo (Linux), 2 à 5 % plus rapide

« This would've taken 3 engineers a year. »

— Jarred Sumner, créateur de Bun

Oracle > Code

• Un même clone de Medium, 100+ implémentations
• Je maintiens la spec, les tests et la démo
• specs/api : openapi.yml + 13 fichiers Hurl (source de vérité)
  → 156 requêtes Bruno, générées, synchro vérifiée en CI
• specs/e2e : 15 suites Playwright + SELECTORS.md pour les fronts
• Spec + tests livrés avant l'implémentation ⇒ le port devient automatique,
  vers n'importe quel langage, n'importe quel framework

Conséquences pour la recherche

« I think we'll be there in three to six months—where AI is writing 90 percent of the code. And then in twelve months, we may be in a world where AI is writing essentially all of the code. »

Dario Amodei — Council on Foreign Relations, 10 mars 2025

• 6 mois plus tard : potentiellement valide
• Mai 2026 : Bun, 1,3 M de lignes portées en 11 jours
• 18 mois plus tard : un fix sur Scotch fait depuis mon téléphone, sans relecture

« Thus, it's my guess that powerful AI could at least 10x the rate of these discoveries, giving us the next 50-100 years of biological progress in 5-10 years. »

Dario Amodei — Machines of Loving Grace, octobre 2024

• 20 mois après l'essai : Claude Science

Un balayage à 8 bras envoyé sur les A100 du cluster du labo, le notebook partagé avec l'agent, en direct. Le compute, c'est le vôtre.

Cinq agents en parallèle, et un relecteur qui signale un PMID attribué à deux papiers — les relecteurs adversariaux de Bun, version labo.