Épingler, Extraire, Évaluer: Un guide pratique de everything‑claude‑code
Reproduire la performance des modèles pour les tâches de codage repose sur une chose: la discipline de configuration. Avec Claude Code, des petits changements dans l’échantillonnage ou les schémas d’outils peuvent influencer le déterminisme, casser des appels d’outils ou gonfler les coûts. Ce dont les équipes ont besoin, c’est d’un flux de travail sans conjecture: épingler une collection de configurations reconnues, extraire chaque paramètre directement du dépôt, valider avec un test de fumée, exécuter des benchmarks de codage standard, et capturer des artefacts pour la traçabilité. Ce guide couvre ce processus de bout en bout.
Le guide suivant montre comment épingler la dernière collection de configuration dans affaan-m/everything-claude-code, extraire automatiquement un manifeste lisible par machine de chaque réglage, exécuter un test de fumée Claude client minimal, exécuter HumanEval, MBPP, SWE-bench, et LiveCodeBench, structurer les ablations. Il couvre également la capture de métriques/journaux, la comparaison avec les tags précédents et les lignes de base par défaut, le dépannage des pannes courantes, et le renforcement pour CI. Vous finirez avec un pipeline reproductible que votre équipe entière peut exécuter—aucune conjecture, aucune dérive, aucune surprise de configuration.
Détails de l’architecture/implémentation
Prérequis et environnement
Vous aurez besoin de:
- Git, GitHub CLI (gh), curl, jq
- Python 3.9+ et pip
- ANTHROPIC_API_KEY exporté dans le shell
- Facultatif: Docker ou des bacs à sable spécifiques au langage si vous exécutez les testeurs localement
Variables d’environnement recommandées:
- ANTHROPIC_API_KEY défini dans votre shell ou magasin de secrets CI
- GH_TOKEN (optionnel) pour GitHub CLI avec des limites API plus élevées
Épingler la dernière collection de configuration (tag + SHA)
Travaillez toujours à partir d’un tag épinglé et d’un SHA de commit pour que les résultats soient reproductibles.
Clonez et inspectez les versions:
- gh repo clone affaan-m/everything-claude-code && cd everything-claude-code
- gh release list —limit 50
- gh release view —latest —json tagName,url,publishedAt
Si aucune version n’existe, revenez aux tags:
- git fetch —tags && git tag —sort=-creatordate | head -n 10
Épinglez un tag:
- git checkout <TAG_NAME>
- git rev-parse HEAD > COMMIT_SHA.txt
Confirmez éventuellement le commit de la collection de configuration en vérifiant les répertoires de configuration:
- git log -n 1 — config/ configs/ settings/ orchestration/ eval/
Vous pouvez aussi interroger les points de terminaison REST de GitHub si l’utilisation du CLI est restreinte:
- curl -s https://api.github.com/repos/affaan-m/everything-claude-code/releases | jq ’. | {tag_name, published_at, html_url}’
- curl -s https://api.github.com/repos/affaan-m/everything-claude-code/tags | jq ’. | {name, commit}’
Enregistrez à la fois le tag lisible par humain et le SHA exact. Toutes les extractions, tests de fumée et benchmarks devraient faire référence à ces identificateurs.
Générer le manifeste complet de configuration
L’objectif est d’extraire chaque valeur de configuration concrète du dépôt—modèles, paramètres de messages, schémas d’outils, mode JSON, stratégies de contexte, paramètres d’index de récupération, délais d’expiration, tentatives, et commandes de bac à sable.
Installez les dépendances:
- python -m pip install pyyaml
Créez tools/extract_config.py avec le contenu suivant:
import json, os, re, glob
try:
import yaml
except ImportError:
yaml = None
KEYS = re.compile(r"\b(model|temperature|top_p|max_tokens|stop_sequences|system|tools|tool_choice|json|response_format|stream|timeout|retry|retries|backoff|cache|prompt|chunk|embedding|context|memory|rag|summar)\b", re.I)
def parse_file(path):
data = {}
try:
if path.endswith((".yaml", ".yml")) and yaml:
with open(path, "r", encoding="utf-8") as f:
data = yaml.safe_load(f)
elif path.endswith(".json"):
with open(path, "r", encoding="utf-8") as f:
data = json.load(f)
else:
with open(path, "r", encoding="utf-8") as f:
txt = f.read()
hits = sorted(set(m.group(0) for m in KEYS.finditer(txt)))
if hits:
data = {"_text_matches": hits}
except Exception as e:
data = {"_error": str(e)}
return data
roots = ["config", "configs", "settings", "orchestration", "eval", "src", "examples", "."]
manifest = {}
for root in roots:
for path in glob.glob(os.path.join(root, "**"), recursive=True):
if os.path.isfile(path) and any(path.endswith(ext) for ext in [".yaml",".yml",".json",".toml",".py",".ts",".tsx",".js"]):
parsed = parse_file(path)
if parsed:
manifest[path] = parsed
print(json.dumps(manifest, indent=2))Exécutez l’extracteur:
- python tools/extract_config.py > config_manifest.json
- jq ’.’ config_manifest.json
Considérez config_manifest.json comme la surface de configuration canonique. Si une catégorie n’est pas présente, assumez qu’elle est désactivée ou gérée de manière externe.
Utilisez ce manifeste pour vérifier:
- Les modèles sont des variantes de codage Claude 3.x à long contexte actuelles pour la génération et les modifications au niveau des dépôts.
- Les paramètres de messages sont alignés avec les meilleures pratiques de codage (température, top_p, max_tokens, séquences d’arrêt, invites système/développeurs).
- Les schémas d’outils sont explicites, minimaux, et sûrs; le choix de l’outil est clairement défini.
- Les sorties structurées sont activées là où c’est nécessaire via response_format.
- La stratégie de contexte et les paramètres de récupération (modèle d’ancrage, tailles de blocs, chevauchement, top‑k, rerank) existent et sont raisonnables.
- Le streaming, les limites de concurrence, les tentatives/backoff avec jitter, et la mise en cache des invites sont configurés.
- Les commandes de bac à sable/test runner et les délais d’expiration sont explicites par langage.
- Les garde-fous existent (listes blanches de chemins, rédaction de secrets).
Exécuter un test de fumée client Claude minimal
Installez le SDK:
- python -m pip install anthropic
Créez tools/anthropic_client.py:
import os
from anthropic import Anthropic
client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
def call(model, system, messages, temperature=0.1, top_p=0.9, max_tokens=1024, tools=None, tool_choice=None, response_format=None, stream=False):
kwargs = {
"model": model,
"system": system,
"messages": messages,
"temperature": temperature,
"top_p": top_p,
"max_tokens": max_tokens,
}
if tools is not None:
kwargs["tools"] = tools
if tool_choice is not None:
kwargs["tool_choice"] = tool_choice
if response_format is not None:
kwargs["response_format"] = response_format
if stream:
with client.messages.stream(**kwargs) as s:
out = []
for event in s:
if event.type == "content_block_delta":
text = event.delta.get("text", "")
print(text, end="", flush=True)
out.append(text)
print()
return "".join(out)
else:
resp = client.messages.create(**kwargs)
return "".join([c.text for c in resp.content if hasattr(c, "text")])Créez tools/smoke_test.py:
from anthropic_client import call
SYSTEM = "You are Claude Code, an expert software engineer. Follow instructions precisely. Return valid code and tests."
messages = [
{"role": "user", "content": "Write a Python function fib(n) in O(n) time and O(1) space and include simple tests."}
]
print(call(
model="claude-3-sonnet-20240229",
system=SYSTEM,
messages=messages,
temperature=0.1,
top_p=0.9,
max_tokens=600,
response_format=None # or {"type": "json_object"} if producing structured output
))Exécutez le test:
- python tools/smoke_test.py
Cela valide que votre clé API, la sélection du modèle et les paramètres de base fonctionnent. Si le mode JSON ou les outils sont utilisés dans les flux du dépôt, copiez ces entrées à partir de config_manifest.json dans cet appel.
Exécuter des benchmarks: HumanEval, MBPP, SWE‑bench, LiveCodeBench
La suite d’évaluation couvre les langages et les types de tâches qui reflètent les workflows de codage typiques. Utilisez le tag/commit épinglé et les paramètres exacts/schémas d’outils de config_manifest.json pour des comparaisons en toute équité.
-
HumanEval et MBPP (avec notation basée sur l’exécution):
-
python -m pip install evalplus
-
Utilisez les scripts d’échantillonnage EvalPlus pour produire pass@1 et pass@5. Configurez le modèle, la température, top_p et max_tokens pour correspondre au manifeste. Métriques spécifiques non disponibles ici; exécutez-les localement pour les générer.
-
SWE‑bench / SWE‑bench‑lite:
-
Suivez la configuration du harnais. Assurez-vous que les protocoles d’utilisation des outils—apply_patch, run_tests—et les invites correspondent au manifeste épinglé. Enregistrez les taux d’acceptation et de résolution des correctifs; métriques spécifiques non disponibles dans cet article.
-
LiveCodeBench:
-
Configurez les modèles à long contexte et les paramètres de récupération comme déclarés dans le manifeste. Capturez les résultats réussis de construction + test au niveau du dépôt; métriques spécifiques non disponibles ici.
Exécutez trois semences ou balayages de température ou plus pour quantifier la variance et le déterminisme à des paramètres fixes. Appliquez des délais d’expiration stricts par requête et par appel d’outil.
Capturer des métriques, journaux, et artefacts
Conservez tout dans un seul run.json et des dossiers structurés:
- Tag, SHA de commit, valeurs de paramètres, semences
- Comptes de tokens par catégorie (invite/sortie/outil)
- Latence (médiane et p95)
- Comptes et taux de réussite des appels d’outils (charges utiles valides au schéma, succès d’exécution, résultats de test)
- Utilisation du contexte (proportions de contexte récupéré vs. brut)
- Résultats notés: pass@k, acceptation de correctif, succès au niveau du dépôt
- Différences et correctifs pour analyse post-hoc
Stockez les journaux bruts et stdout/stderr des testeurs. Cette piste d’audit est essentielle pour le débogage de régression et le contrôle en CI.