Avis sur le Claude Opus 5 : le nouveau modèle de Anthropic vaut-il le coup ?
Olivia Carter
Dernière mise à jour le 29 juillet 2026
Avis sur le Claude Opus 5 : le nouveau modèle de Anthropic vaut-il le coup ?
Vérification des faits effectuée le 28 juillet 2026.
Avis rapide : Ce test du modèle Claude Opus 5 met en avant un modèle haut de gamme particulièrement intéressant pour les développeurs, les flux de travail métier complexes et les acheteurs qui recherchent des performances proches de la pointe sans avoir à payer systématiquement le prix du modèle Fable 5. Le modèle Anthropic facture $5 par million de tokens d'entrée et $25 par million de tokens de sortie, tout en prenant en charge une fenêtre de contexte d'un million de tokens et jusqu'à 128 000 tokens de sortie dans l'API Messages synchrone. Ce n’est pas le choix le plus judicieux pour les discussions simples, les résumés courts ou les requêtes à fort volume et à faible valeur.
L’argument le plus convaincant est d’ordre pratique plutôt que théorique : Opus 5 allie une grande marge de manœuvre en matière de raisonnement à des coûts plus raisonnables que ceux du niveau « frontier » de Anthropic. Lors de notre seul test de débogage, il a identifié avec précision le bug lié à la correspondance de préfixes, proposé le correctif le plus minimal, ajouté un test de régression ciblé et fourni une commande de vérification qui a réussi localement. Il s’agit là d’une preuve utile pour cette tâche, mais pas d’une garantie que le modèle réussira toutes les missions de programmation.
Meilleur pour : les développeurs, l'analyse de contexte à long terme, l'automatisation d'entreprise et les équipes dont les échecs coûteux justifient un modèle haut de gamme. À éviter dans les cas suivants : La rapidité et le coût unitaire priment sur la qualité du raisonnement dans la dernière partie.
Le Claude Opus 5 est le modèle haut de gamme de la gamme Anthropic, destiné à un usage quotidien pour le codage agentique complexe et les tâches professionnelles. Anthropic l'a annoncé le 24 juillet 2026, le qualifiant de bien pensé, proactif et plus efficace que les autres modèles. Il a remplacé le Claude Opus 4.8, est devenu le modèle par défaut sur le Claude Max et le modèle le plus performant disponible sur le Claude Pro.
Le 24 juillet 2026, Anthropic a annoncé la sortie du Claude Opus 5 et a indiqué qu'il était disponible dès ce jour-là.
L'argumentaire de vente de ce produit sort de l'ordinaire pour une sortie d'Opus : il n'est pas présenté uniquement comme un modèle à intelligence maximale. Anthropic souhaite qu'il soit utilisé au quotidien, avec un niveau d'effort ajustable et un profil de latence modéré. Cela facilite son adoption pour les agents s'exécutant sur de longues durées et les tâches de production complexes, tandis que les charges de travail plus simples peuvent toujours être redirigées vers un modèle plus rapide et moins coûteux.
L'accès dépend de la méthode choisie. Les particuliers peuvent accéder à Opus 5 via les forfaits Claude éligibles ; les développeurs peuvent l'utiliser via l'API Claude et les plateformes cloud prises en charge. GlobalGPT dispose également d'une page produit dédiée. Les lecteurs souhaitant comparer les niveaux d'abonnement de Anthropic peuvent utiliser le Comparaison des formules Free, Pro et Max de Claude avant de choisir un mode de facturation.
Claude Opus 5 : Prix, API et caractéristiques techniques principales
L'officiel Prix de l'API Claude est $5 par million de jetons d'entrée et $25 par million de jetons émis. Il s'agit là des tarifs de base de l'API, et non du prix d'un abonnement grand public Claude ou d'une formule proposée par une plateforme tierce. La mise en cache des réponses et le traitement par lots font l'objet de tarifs distincts ; il convient donc de comparer l'ensemble du profil de requêtes plutôt que de se contenter de multiplier le prix de base annoncé.
Champ
Claude Opus 5
Ce que cela signifie
ID API Claude
claude-opus-5
Utilisez exactement cette valeur de modèle dans les requêtes officielles de l'API Claude.
Prix d'entrée de base
$5 / MTok
Taux standard de jetons d'entrée avant mise en cache ou remises par lot.
Prix de base à la production
$25 / MTok
Les agents qui génèrent beaucoup de données peuvent rapidement devenir coûteux.
Fenêtre de contexte
1 million de jetons
Convient aux grands dépôts et aux vastes collections de documents, sous réserve de la qualité des requêtes et de la stratégie de recherche.
Puissance maximale
128K jetons
S'applique à l'API Messages synchrone ; les lots de messages disposent d'un parcours bêta distinct pouvant aller jusqu'à 300 000.
Seuil de fiabilité des connaissances
mai 2026
C'est une méthode récente selon les normes actuelles, mais elle ne remplace pas la récupération en temps réel.
Latence comparative
Modéré
Ce n'est pas le modèle le plus rapide de Anthropic ; la latence varie toujours en fonction de l'effort fourni, des outils utilisés et de la charge de travail.
La plateforme Claude identifie « claude-opus-5 » comme l'identifiant API et l'alias actuels d'Opus 5.La plateforme Claude affiche pour Opus 5 un taux de $5/$25 par million de jetons d'entrée/sortie, avec une fenêtre contextuelle de 1 million de jetons, une sortie maximale de 128 000 jetons et des dates limites fixées en mai 2026.La plateforme Claude indique une fenêtre de contexte de 1 million, un débit maximal de 128 k et des dates limites en mai 2026.
Pour les particuliers, Anthropic présente le Claude Pro à raison de $20 par mois ou de $17 par mois lorsque le forfait $200 est facturé annuellement ; le forfait Claude Max commence à $100 par mois. Selon Anthropic, Opus 5 est le modèle le plus performant sur Pro et le modèle par défaut sur Max, mais les quotas des forfaits et les fonctionnalités des produits sont distincts de l'utilisation mesurée de l'API.
Si vous avez besoin d'une ventilation plus détaillée des coûts, le Guide des forfaits AI et des tarifs des API Claude distingue les abonnements grand public, la facturation des API et les limites d'utilisation. Cette distinction est importante : “ inclus dans un forfait ” ne signifie pas que les appels API sont illimités, et le tarif d'une API ne vous indique pas le volume d'accès au chat grand public dont vous disposez.
Claude Opus 5 Résultats des tests de performance
Limite importante : Les chiffres ci-dessous sont tests de performance publiés par Anthropic, et non des mesures indépendantes réalisées dans le cadre de cette analyse. Elles permettent de mieux comprendre le positionnement visé par Anthropic en termes de performances et de coûts, mais ne garantissent pas les mêmes résultats avec vos prompts, vos outils, votre référentiel ou votre budget de latence.
Évaluation
Allégation publiée par Anthropic
Comment le lire
Frontier-Bench v0.1
Opus 5 offre plus du double des performances de Opus 4.8, pour un coût par tâche inférieur.
Un indicateur général de la performance des agents, et non une amélioration universelle de 100 %.
CursorBench 3.2
À pleine puissance, Opus 5 se situe à moins de 0,51 TP40T du score maximal de Fable 5, pour un coût par tâche deux fois moins élevé.
Une économie d'agent de codage solide dans le cadre du paramétrage d'effort testé de Anthropic.
Zapier AutomationBench
Environ 1,5 fois le taux de réussite du deuxième meilleur système, pour un coût par tâche identique.
C'est prometteur pour l'automatisation de bout en bout des processus métier ; la conception des flux de travail reste toutefois essentielle.
OSWorld 2.0
Dépasse le meilleur résultat de Fable 5 pour un coût représentant à peine plus d'un tiers de celui-ci.
Ce test de performance met en évidence une efficacité de fonctionnement de l'ordinateur particulièrement intéressante.
Selon Anthropic, l’Opus 5 atteint un score CursorBench 3.2 à moins de 0,5% du score maximal obtenu par le Fable 5, pour un coût par tâche deux fois moins élevé.Anthropic fait état d'un taux de réussite 1,5 fois supérieur sur Zapier AutomationBench et d'un avantage en termes de coût sur OSWorld 2.0.
L'effort fait partie intégrante du résultat. Anthropic indique qu'Opus 5 utilise par défaut un niveau d'effort élevé dans l'API Claude et le code Claude, tandis que ses comparaisons utilisent également les paramètres « high », « xhigh » ou « max ». Un effort plus élevé peut améliorer le taux de réussite des tâches difficiles tout en augmentant le nombre de jetons, la latence, ou les deux. Le coût de référence par tâche est donc plus révélateur que le prix par jeton seul — mais aucun de ces indicateurs ne remplace un test pilote sur votre propre charge de travail.
Comment nous avons testé le Claude Opus 5
Nous avons lancé une tâche de débogage ciblée visant à identifier la cause première sur un ensemble de trois fichiers CommonJS. L'invite demandait au modèle d'identifier la cause première avant toute modification, de proposer le correctif le plus minimal possible, d'ajouter un test de régression ciblé, d'éviter toute modification non pertinente et de fournir la commande de vérification exacte.
Nous avons ensuite vérifié le correctif de manière indépendante, plutôt que de considérer la réponse comme correcte simplement parce qu’elle semblait sûre d’elle. La commande locale était : node --test test/account-summary.test.cjs. Avant la correction, la suite de tests affichait un test réussi et un test échoué. Après l'application du correctif concernant l'égalité exacte, elle affichait deux tests réussis et aucun test échoué.
Cette méthode nous apporte des informations utiles sur un processus de débogage : le diagnostic, la rigueur dans l'application des correctifs, la qualité des tests de régression et la vérifiabilité. Elle ne mesure pas les compétences générales en matière de codage, la fiabilité à long terme des agents, la rapidité ni les performances dans l'ensemble des langages.
Test pratique du Claude Opus 5
Débogage à la source : correct, minimal et vérifiable
Lors de notre test, le Claude Opus 5 a correctement localisé le défaut à normalizedQuery.startsWith(account.id.toLowerCase()). Avec la requête ACCT-10, la vérification du préfixe a abouti acct-1 d'abord, donc Array.prototype.find a renvoyé le mauvais compte avant d'avoir trouvé l'identifiant exact.
La correction proposée a remplacé la correspondance par préfixe par une égalité exacte et a ajouté un cas de régression pour les chaînes complétées par des espaces et comportant des majuscules et des minuscules. ACCT-10 entrée. Il n'a pas réécrit de code sans rapport avec le sujet. Cette retenue est importante dans les dépôts réels, où un “ nettoyage ” trop général peut générer davantage de travail de révision que le bug d'origine.
La partie la plus convaincante était le cycle complet : identifier la cause première, expliquer pourquoi le test existant ne l'avait pas détectée, apporter la modification la plus minime possible, ajouter le test de régression approprié et indiquer la commande permettant de le vérifier. Le résultat est cohérent avec le positionnement d'Opus 5 en tant qu’« agent de codage », mais il ne s'agit là que d'un seul test. Pour une introduction plus générale au flux de travail, voir comment utiliser Claude AI pour coder.
Sujets complets des épreuves T1 à T4, réponses et code à copier
T1 : Débogage à la source
Réussite — identification du défaut lié à la correspondance des préfixes, proposition du correctif le plus minimal possible et ajout d'un test de régression ciblé.
A identifié la correspondance par préfixe comme étant le défaut ; a expliqué pourquoi l'ancien test ne l'avait pas détecté ; a proposé un test de régression basé sur l'égalité exacte plus un.
Afficher l'énoncé complet de la question T1 et la réponse
Consigne complète
Vous déboguez un fixture CommonJS volontairement simple. Travaillez uniquement à partir des trois fichiers ci-dessous et de la reproduction indiquée.
Exigences :
1. Identifiez la cause première avant de proposer toute modification.
2. Proposez le correctif le plus minimal possible qui corrige le bogue.
3. Ajoutez un test de régression ciblé qui échoue avant la correction et réussit après celle-ci.
4. Indiquez la commande de vérification exacte à exécuter depuis la racine du fixture.
5. Ne réécrivez pas de code sans rapport avec le problème. Ne renommez pas les fichiers, n’ajoutez pas de dépendances et ne modifiez pas l’API publique.
6. Renvoyez exactement ces sections dans l’ordre suivant : `CAUSE FONDAMENTALE`, `CORRECTIF`, `VÉRIFICATION`, `LIMITATIONS`.
7. Dans `CORRECTIF`, fournissez un diff unifié dans un bloc `diff` délimité. Dans `VÉRIFICATION`, fournissez une commande dans un bloc `text` délimité.
Reproduction : `summarizeAccount(accounts, ' ACCT-10 ')` devrait renvoyer `{ id: 'acct-10', name: 'Nimbus', seats: 24 }`, mais il renvoie le compte `acct-1`.
Fichier : `src/find-account.cjs`
```js
function findAccount(accounts, query) {
const normalizedQuery = query.trim().toLowerCase();
return accounts.find((account) =>
normalizedQuery.startsWith(account.id.toLowerCase()),
);
}
module.exports = { findAccount };
```
Fichier : `src/account-summary.cjs`
```js
const { findAccount } = require('./find-account.cjs');
function summarizeAccount(accounts, requestedId) {
const account = findAccount(accounts, requestedId);
if (!account) return null;
return { id: account.id, name: account.name, seats: account.seats };
}
module.exports = { summarizeAccount };
```
Fichier : `test/account-summary.test.cjs`
```js
const test = require('node:test');
const assert = require('node:assert/strict');
const { summarizeAccount } = require('../src/account-summary.cjs');
const accounts = [
{ id: 'acct-1', name: 'Atlas', seats: 5 },
{ id: 'acct-10', name: 'Nimbus', seats: 24 },
];
test('résume un ID de compte exact', () => {
assert.deepEqual(summarizeAccount(accounts, 'acct-1'), {
id: 'acct-1',
name: 'Atlas',
seats: 5,
});
});
```
Claude Opus 5
CAUSE FONDAMENTALE
La méthode `findAccount` effectue une recherche par préfixe, et non par égalité :
La méthode `Array.prototype.find` renvoie le premier élément satisfaisant au prédicat. Pour ‘ ACCT-10 ‘, la requête normalisée est ‘ acct-10 ’, et l’ID du premier compte, ‘ acct-1 ’, en est un préfixe ; par conséquent, startsWith renvoie vrai et « acct-1 » met fin prématurément à la recherche avant même que « acct-10 » ne soit testé. La normalisation effectuée par trim().toLowerCase() est correcte : les espaces et la casse ne posent pas de problème. La fonction summarizeAccount ne fait que relayer les données et n'est pas en cause. Le test actuel ne permet pas de détecter ce cas : ‘ acct-1 ’ est un préfixe de lui-même et constitue le premier élément ; par conséquent, la correspondance par préfixe et la correspondance exacte sont impossibles à distinguer pour cette entrée.
PATCH
diff
1--- a/src/find-account.cjs2+++ b/src/find-account.cjs3@@ -1,8 +1,8 @@4 function findAccount(accounts, query) {5 const normalizedQuery = query.trim().toLowerCase();6- return accounts.find((account) =>7- normalizedQuery.startsWith(account.id.toLowerCase()),8- );9+ return accounts.find(10+ (account) => account.id.toLowerCase() === normalizedQuery,11+ );12 }1314 module.exports = { findAccount };15--- a/test/account-summary.test.cjs16+++ b/test/account-summary.test.cjs17@@ -14,3 +14,11 @@18 test('summarizes an exact account ID', () => {19 seats: 5,20 });21 });22+23+test('matches the full ID rather than a prefix, with padding and mixed case', () => {24+ assert.deepEqual(summarizeAccount(accounts, ' ACCT-10 '), {25+ id: 'acct-10',26+ name: 'Nimbus',27+ seats: 24,28+ });29+});
--- a/src/find-account.cjs
+++ b/src/find-account.cjs
@@ -1,8 +1,8 @@
function findAccount(accounts, query) {
const normalizedQuery = query.trim().toLowerCase();
- return accounts.find((account) =>
- normalizedQuery.startsWith(account.id.toLowerCase()),
- );
+ return accounts.find(
+ (account) => account.id.toLowerCase() === normalizedQuery,
+ );
}
module.exports = { findAccount };
--- a/test/account-summary.test.cjs
+++ b/test/account-summary.test.cjs
@@ -14,3 +14,11 @@
test('résume un identifiant de compte exact', () => {
seats: 5,
});
});
+
+test('correspond à l’identifiant complet plutôt qu’à un préfixe, avec des caractères de remplissage et des majuscules/minuscules', () => {
+ assert.deepEqual(summarizeAccount(accounts, ' ACCT-10 '), {
+ id: 'acct-10',
+ name: 'Nimbus',
+ seats: 24,
+ });
+});
Avant la correction, le nouveau test échoue avec l'objet « acct-1 / Atlas / 5 » ; après la correction, il réussit.
VÉRIFICATION
texte
1node --test test/account-summary.test.cjs
node --test test/account-summary.test.cjs
LIMITATIONS
• Portée : modification d'un opérateur. Aucun changement de nom, aucune nouvelle dépendance ; les signatures et les types de retour des méthodes `findAccount` et `summarizeAccount` restent inchangés. • Comportement préexistant qui n'a pas été corrigé (hors du champ d'application de ce bug) : • Une valeur requestedId qui n'est pas une chaîne de caractères (null ou un nombre) provoque toujours une exception lors de l'appel de .trim(). • Les identifiants de compte ne sont pas eux-mêmes tronqués ; ainsi, une valeur stockée telle que ‘ acct-10 ’ ne correspondra toujours pas — seule la requête est normalisée. • La conversion de casse utilise simplement la fonction toLowerCase() ; elle n'effectue ni normalisation Unicode ni conversion tenant compte des paramètres régionaux. • Les identifiants en double renvoient toujours à la première occurrence, et la recherche reste de complexité O(n). • Couverture de test : le test de régression unique cible précisément le cas de reproduction signalé. Le chemin introuvable (nul) et les données d'entrée mal formées ne sont pas testés.
ROOT CAUSE
findAccount matches by prefix, not by equality:
```js
normalizedQuery.startsWith(account.id.toLowerCase())
```
Array.prototype.find returns the first element satisfying the predicate. For ' ACCT-10 ' the normalized query is 'acct-10', and the first account's ID 'acct-1' is a prefix of it, so startsWith is true and acct-1 short-circuits the search before acct-10 is ever tested.
The trim().toLowerCase() normalization is correct — whitespace and casing are not the problem. summarizeAccount is a pass-through and is not at fault.
The existing test cannot catch this: 'acct-1' is a prefix of itself and is the first element, so prefix matching and exact matching are indistinguishable for that input.
PATCH
```diff
--- a/src/find-account.cjs
+++ b/src/find-account.cjs
@@ -1,8 +1,8 @@
function findAccount(accounts, query) {
const normalizedQuery = query.trim().toLowerCase();
- return accounts.find((account) =>
- normalizedQuery.startsWith(account.id.toLowerCase()),
- );
+ return accounts.find(
+ (account) => account.id.toLowerCase() === normalizedQuery,
+ );
}
module.exports = { findAccount };
--- a/test/account-summary.test.cjs
+++ b/test/account-summary.test.cjs
@@ -14,3 +14,11 @@
test('summarizes an exact account ID', () => {
seats: 5,
});
});
+
+test('matches the full ID rather than a prefix, with padding and mixed case', () => {
+ assert.deepEqual(summarizeAccount(accounts, ' ACCT-10 '), {
+ id: 'acct-10',
+ name: 'Nimbus',
+ seats: 24,
+ });
+});
```
Before the fix the new test fails with the acct-1 / Atlas / 5 object; after the fix it passes.
VERIFICATION
```text
node --test test/account-summary.test.cjs
```
LIMITATIONS
• Scope: one operator changed. No renames, no new dependencies, and findAccount / summarizeAccount signatures and return shapes are unchanged.
• Pre-existing behavior left alone (out of scope for this bug):
• A non-string requestedId (null, a number) still throws on .trim().
• Account IDs themselves are not trimmed, so a stored ' acct-10' still will not match — only the query is normalized.
• Casing uses plain toLowerCase(); no Unicode normalization or locale-aware folding.
• Duplicate IDs still resolve to the first match, and lookup remains O(n).
• Test coverage: the single regression test targets exactly the reported reproduction. The not-found (null) path and malformed input remain untested.
T2 : Analyse de l'état du compte
Partiel — les indicateurs clés ont été calculés et les actions classées par ordre de priorité, mais la réponse saisie ne comportait pas le marqueur « Recheck » demandé.
Calcul du MRR à risque : $34 800 (94,31%) ; escalade de l'E-505 et hiérarchisation des actions de suivi ; réponse fournie sans le marqueur de « nouvelle vérification » demandé.
Afficher l'énoncé complet de l'épreuve T2 et la réponse
Consigne complète
Analysez le fichier `account-health.csv` fourni en tant qu’ensemble de données fermé. N’utilisez pas d’informations externes et n’inventez pas de valeurs manquantes.
Règles de risque (évaluez chacune d’entre elles indépendamment) :
- `inactivité` : `days_since_login >= 30`
- `payment` : `failed_payments >= 2`
- `low_utilization` : `seats_used / seats_purchased = 80` alors que le compte est « at-risk ».
- `weak_health_without_risk` : `health_score = 9` et `open_tickets >= 3`.
Exigences :
1. Calculez les indicateurs de risque et les indicateurs de contradiction déclenchés pour chaque compte.
2. Présentez les totaux de l’ensemble de données concernant les comptes, le MRR, les comptes à risque, le MRR à risque, les comptes à escalader, les lignes de contradiction, les licences achetées et les licences utilisées.
3. Générer un tableau d’actions comportant exactement cinq colonnes : `Compte | Déclencheurs de risque | Contradictions | Priorité | Action recommandée`.
4. Placer les valeurs calculées directement sous l’en-tête `Faits mesurés` et les décisions discrétionnaires sous l’en-tête `Inférence`.
5. Sous « Vérification », présentez suffisamment de calculs pour permettre de revérifier de manière indépendante chaque total et chaque seuil, y compris le cas d’égalité à 0,50.
6. Ne corrigez ni ne réinterprétez les règles sans le signaler. Si un signal semble contre-intuitif, enregistrez-le comme une contradiction plutôt que de modifier sa classification.
`account-health.csv` :
```csv
account_id,account_name,plan,mrr_usd,days_since_login,failed_payments,seats_purchased,seats_used,health_score,nps,open_tickets
A-101,Aster,Enterprise,12000,45,0,100,82,92,9,1
B-202,Beacon,Pro,4200,4,2,20,18,70,7,0
C-303, Cinder, Pro, 3 600, 12, 0, 20, 8, 65, 10, 4
D-404, Dahlia, Starter, 900, 5, 0, 5, 4, 42, 6, 0
E-505, Ember, Enterprise, 15 000, 65, 3, 200, 70, 35, 3, 6
F-606, Fjord, Starter, 1 200, 29, 1, 4, 2, 85, 9, 3
```
Claude Opus 5
Faits avérés
Source : account-health.csv, 6 lignes, considérées comme clôturées. Aucune valeur n'a été imputée.
Évaluation des règles par compte
Compte jours ≥ 30 échecs ≥ 2 util < 0,50 Nombre de risques Statut A-101 Aster ✅ 45 ❌ 0 ❌ 0,82 1 à risque Balise B-202 ❌ 4 ✅ 2 ❌ 0,90 1 à risque C-303 Cendres ❌ 12 ❌ 0 ✅ 0,40 1 à risque D-404 Dahlia ❌ 5 ❌ 0 ❌ 0,80 0 non à risque E-505 Ember ✅ 65 ✅ 3 ✅ 0,35 3 à risque + escalade F-606 Fjord ❌ 29 ❌ 1 ❌ 0,50 0 non à risque Signaux d'alerte de contradiction par compte Compte une_santé_solide_malgré_les_risques santé_fragile_sans_risque promoteur_avec_billet_chargé A-101 Aster ✅ (92 ≥ 80, à risque) ❌ ❌ (NPS 9 ✓, tickets 1 ✗) Balise B-202 ❌ (70 < 80) ❌ (70 ≥ 50) ❌ (NPS 7) C-303 Cendres ❌ (65 < 80) ❌ (65 ≥ 50) ✅ (NPS : 10, nombre de billets : 4) D-404 Dahlia ❌ ✅ (42 < 50, pas de risque) ❌ (NPS 6) E-505 Ember ❌ (35 < 80) ❌ (35 < 50, mais fait partie d'un groupe à risque) ❌ (NPS 3) F-606 Fjord ❌ (85 ≥ 80 mais pas à risque) ❌ (85 ≥ 50) ✅ (NPS : 9, billets : 3) Totaux des ensembles de données Métrique Valeur Comptes 6 MRR total $36,900 Comptes à risque 4 (A-101, B-202, C-303, E-505) MRR à risque $34 800 (soit 94,311 TP40T du total) Transmettre les dossiers 1 (E-505) Lignes de contradiction 4 (A-101, C-303, D-404, F-606) Indicateurs de contradiction 4 (1 « santé_solide_avec_risque », 1 « santé_fragile_sans_risque », 2 « promoteur_avec_billet_chargé ») Places achetées 349 Sièges utilisés 184 Inférence L'ordre de priorité et les actions recommandées ci-dessous relèvent d'une appréciation subjective et ne constituent pas le résultat d'une application stricte de règles. Mon classement accorde la priorité, dans l'ordre, à l'escalade de statut, puis au MRR à risque, et enfin aux signaux de contradiction. Compte Facteurs déclencheurs de risque Contradictions Priorité Mesure recommandée E-505 Ember inactivité, paiement, faible_utilisation - P0 Ces trois règles se déclenchent pour le compte le plus important ($15 000 MRR). Considérer comme une perte de client active : récupérer le moyen de paiement, puis procéder à un examen par la direction concernant les 130 licences inutilisées. A-101 Aster inactivité une_santé_solide_malgré_les_risques P1 $ : 12 000 MRR avec 45 jours d'inactivité, malgré un score de 92 et un taux d'utilisation satisfaisant de 82%. Vérifiez si cette interruption de connexion correspond à un réel désengagement ou à un artefact de suivi (SSO, utilisation exclusivement via API) avant de prendre des mesures en fonction du score. C-303 Cendres faible_utilisation promoteur_avec_billet_chargé P1 Promoteur (nps 10) disposant de 4 billets ouverts avec un taux d'utilisation de 40%. Le nombre de billets en attente constitue probablement un obstacle à l'adoption ; il convient de vider la file d'attente, puis de favoriser l'activation des sièges. Balise B-202 paiement - P2 Cas clair à cause unique : 2 paiements échoués, connexion récente datant de 4 jours et utilisation du code 90%. Suivi de facturation uniquement, aucune intervention du service client n'est nécessaire. F-606 Fjord - promoteur_avec_billet_chargé P3 Se situe tout juste dans les limites fixées (29 jours, 1 paiement non effectué, taux d'utilisation exactement égal à 0,50). N'est pas considéré comme à risque selon les règles, mais un jour supplémentaire d'inactivité ou un autre paiement non effectué suffirait à faire basculer la situation. Surveillez la situation et réglez les 3 tickets. D-404 Dahlia - santé_fragile_sans_risque P3 Score de 42 sans déclenchement de règle et utilisation de 80% sur un MRR $900. Soit
Données mesurées
Source : account-health.csv, 6 lignes, considérées comme clôturées. Aucune valeur n’a été imputée.
Évaluation des règles par compte
Compte
jours ≥ 30
échecs ≥ 2
utilisation < 0,50
Nombre de risques
Statut
A-101 Aster
✅ 45
❌ 0
❌ 0,82
1
à risque
B-202 Beacon
❌ 4
✅ 2
❌ 0,90
1
à risque
C-303 Cinder
❌ 12
❌ 0
✅ 0,40
1
à risque
D-404 Dahlia
❌ 5
❌ 0
❌ 0,80
0
pas à risque
E-505 Ember
✅ 65
✅ 3
✅ 0,35
3
à risque + escalade
F-606 Fjord
❌ 29
❌ 1
❌ 0,50
0
pas à risque
Indicateurs de contradiction par compte
Compte
état_solide_avec_risque
état_fragile_sans_risque
promoteur_avec_charge_de_tickets
A-101 Aster
✅ (92 ≥ 80, à risque)
❌
❌ (NPS 9 ✓, tickets 1 ✗)
B-202 Beacon
❌ (70 < 80)
❌ (70 ≥ 50)
❌ (NPS 7)
C-303 Cinder
❌ (65 < 80)
❌ (65 ≥ 50)
✅ (NPS 10, tickets 4)
D-404 Dahlia
❌
✅ (42 < 50, pas à risque)
❌ (NPS 6)
E-505 Ember
❌ (35 < 80)
❌ (35 < 50 mais à risque)
❌ (NPS 3)
F-606 Fjord
❌ (85 ≥ 80 mais pas à risque)
❌ (85 ≥ 50)
✅ (NPS 9, tickets 3)
Totaux de l'ensemble de données
Indicateur
Valeur
Comptes
6
MRR total
$36 900
Comptes à risque
4 (A-101, B-202, C-303, E-505)
MRR à risque
$34 800 (94,31% du total)
Comptes à escalader
1 (E-505)
Lignes présentant des contradictions
4 (A-101, C-303, D-404, F-606)
Indicateurs de contradiction
4 (1 « strong_health_with_risk », 1 « weak_health_without_risk », 2 « promoter_with_ticket_load »)
Places achetées
349
Places utilisées
184
Conclusion
L'ordre de priorité et les actions recommandées ci-dessous relèvent d'un jugement subjectif et ne constituent pas le résultat d'une application de règles. Mon système de pondération du classement privilégie d’abord le statut « escalade », puis le MRR à risque, puis les signaux de contradiction.
Compte
Déclencheurs de risque
Contradictions
Priorité
Action recommandée
E-505 Ember
inactivité, paiement, faible_utilisation
—
P0
Les trois règles se déclenchent sur le plus gros compte ($15 000 MRR). Traiter comme un désabonnement actif : récupérer le moyen de paiement, puis effectuer un examen par la direction concernant les 130 places inutilisées.
A-101 Aster
inactivité
santé_solide_avec_risque
P1
$12 000 MRR avec 45 jours d’inactivité malgré un score de 92 et une utilisation saine de 82%. Vérifier si l’intervalle entre les connexions correspond à un réel désengagement ou à un artefact de suivi (SSO, utilisation via API uniquement) avant d’agir sur la base du score.
C-303 Cinder
faible_utilisation
promoteur_avec_charge_de_tickets
P1
Promoteur (NPS 10) ayant 4 tickets ouverts avec une utilisation de 40%. La charge de tickets est probablement un frein à l’adoption ; résorber la file d’attente, puis favoriser l’activation de la licence.
B-202 Beacon
paiement
—
P2
Cas clair à cause unique : 2 paiements échoués avec une dernière connexion datant de 4 jours et un taux d’utilisation de 90%. Suivi de facturation uniquement, aucune intervention du service client n’est nécessaire.
F-606 Fjord
—
promoter_with_ticket_load
P3
Se situe tout juste à l’intérieur de chaque seuil (29 jours, 1 paiement échoué, taux d’utilisation exactement égal à 0,50). N’est pas à risque selon les règles, mais un jour d’inactivité supplémentaire ou un paiement échoué de plus ferait basculer la situation. Surveiller et effacer les 3 tickets.
D-404 Dahlia
—
weak_health_without_risk
P3
Score de 42 sans déclenchement de règle et un taux d’utilisation de 80% sur un MRR de $900. Soit
T3 : Génération d'une interface utilisateur adaptative
Partiel — a produit une implémentation autonome complète et un auto-contrôle, tout en admettant explicitement qu’il avait inspecté la page plutôt que de l’avoir affichée à l’exécution.
A rédigé une réponse complète de 21 907 caractères ; a abordé les aspects liés aux ordinateurs de bureau, aux appareils mobiles, au débordement et à l'accessibilité ; a précisé que la mise en page avait été inspectée et n'était pas générée à l'exécution.
Afficher l'énoncé complet de l'épreuve T3 et la réponse
Consigne complète
Créez une interface de comparaison de produits soignée sous la forme d’un fichier HTML exécutable unique en utilisant uniquement les données produit ci-dessous.
Exigences :
1. Renvoyez exactement un bloc de code `html` délimité, suivi d’une section `SELF-CHECK`. Ne divisez pas le code HTML, CSS ou JavaScript en fichiers séparés.
2. Utilisez uniquement du HTML sémantique, du CSS intégré et du JavaScript " vanilla " intégré : aucun framework externe, package, police, image, requête réseau ou étape de compilation n’est autorisé.
3. Fournissez trois onglets accessibles au clavier (" Overview ", " Pricing ", " Limits ") avec une sémantique correcte pour les éléments `tablist`, `tab` et `tabpanel`. Les touches Flèche gauche/Flèche droite doivent permettre de se déplacer entre les onglets et de les activer ; les touches Début/Fin doivent permettre d’accéder au premier/dernier onglet et de l’activer. Le focus doit rester visible.
4. L’onglet sélectionné doit être indiqué par `aria-selected`, `tabindex` et le panneau visible ; les panneaux inactifs doivent être masqués.
5. Cible pour ordinateur de bureau : 1 440 px de large. Cible pour mobile : 390 px de large, sans débordement horizontal de la page, sans contrôles tronqués, avec des cibles tactiles d’au moins 44 px de haut et des fiches comparatives empilées sur une seule colonne.
6. Inclure un en-tête concis, une recommandation claire, trois fiches produit et un tableau comparatif compact. Préserver un contraste lisible et éviter les animations décoratives.
7. Utiliser exactement ces informations sur les produits et ne pas ajouter d’allégations :
- Atlas : `$19/mo`, `20 projets`, `10 Go`, `Assistance par e-mail`, idéal pour le travail en solo.
- Beacon : `$49/mo`, `Projets illimités`, `100 Go`, `Assistance prioritaire`, le meilleur choix global pour les équipes en pleine croissance.
- Cove : `$99/mo`, `Projets illimités`, `1 To`, `Assistance dédiée`, idéal pour les opérations réglementées.
8. Attribuez à Beacon une mention visible " Meilleur choix global " sans donner l’impression que les autres fiches sont désactivées.
9. Dans " SELF-CHECK ", indiquez explicitement vos vérifications concernant les onglets sémantiques, le comportement du clavier, la mise en page à 1 440 px, la mise en page à 390 px, le débordement horizontal et les dépendances externes. Ne prétendez pas avoir réellement affiché une fenêtre d’affichage à moins de l’avoir fait ; faites la distinction entre l’inspection du code et la vérification en exécution.
Fichier de test du produit (également stocké sous `fixtures/T3-responsive-ui/product-data.json`) :
```json
{
"products": [
{"name":"Atlas","price":"$19/mo","projects":"20 projets","storage":"10 Go","support":"Assistance par e-mail","bestFor":"travail en solo"},
{"name":"Beacon","price":"$49/mo","projects":"Projets illimités","storage":"100 Go","support" : "Assistance prioritaire", "bestFor" : "équipes en pleine croissance", "badge" : "Meilleur choix global"},
{"name" : "Cove", "price" : "$99/mo", "projects" : "Projets illimités", "storage":"1 To","support":"Assistance dédiée","bestFor":"activités soumises à une réglementation"}
]
}
```
Toutes les affirmations ci-dessous sont issues uniquement de l'inspection du code. Je n'ai pas ouvert de navigateur, ni affiché de fenêtre d'affichage, ni lancé de lecteur d'écran, ni exécuté les gestionnaires de clavier ; rien ici n'a donc été vérifié en temps d'exécution. Lorsqu'une affirmation dépend du comportement du moteur de mise en page, je le précise. Onglets sémantiques — vérifiés, cohérents Un élément div[role="tablist"] avec l'attribut aria-label="Vues de comparaison des forfaits" contient trois boutons [type="button"][role="tab"]. Chaque onglet possède un identifiant unique et un attribut aria-controls pointant vers un élément section[role="tabpanel"] ; chaque panneau comporte un attribut aria-labelledby renvoyant vers son onglet correspondant. J’ai tracé manuellement les trois paires : tab-overview/panel-overview, tab-pricing/panel-pricing, tab-limits/panel-limits. Pas d’identifiants en double, pas de références orphelines. Les panneaux utilisent `tabindex="0"`, ce qui permet d’accéder au corps du panneau après l’onglet. Comportement du clavier — vérifié, mais non exécuté Un seul écouteur keydown sur la liste d'onglets gère les touches Flèche droite, Flèche gauche, Début et Fin, appelle event.preventDefault() uniquement pour ces quatre touches, et quitte prématurément dans le cas contraire. Les touches fléchées permettent de revenir au début ou à la fin de la liste. Comme la méthode `activate()` met à jour à la fois les attributs `aria-selected`, `tabindex` et `hidden` tout en déplaçant le focus, les touches fléchées ainsi que les touches Home et End permettent de se déplacer et d’activer un élément en une seule étape, ce qui correspond au modèle d’activation automatique requis par les spécifications. La navigation avec les touches Tab et Maj+Tab repose sur un tabindex itinérant : un seul élément a un tabindex="0", les autres ont un tabindex="-1", géré par la fonction activate(). La visibilité du focus est assurée par une règle globale :focus-visible avec un contour de 3 px et un décalage de 2 px ; je n’ai ni redéfini ni supprimé le contour par défaut. Je n’ai pas vérifié le fonctionnement des touches dans un navigateur réel. Réflexion dans un état sélectionné — vérifiée La fonction `activate()` définit les trois attributs dans la même boucle, ce qui évite que `aria-selected="true"`, `tabindex="0"` et l'absence de l'attribut `hidden` ne se désynchronisent. Les panneaux inactifs se voient attribuer l’attribut hidden, et [hidden] { display: none !important; } empêche les règles d’affichage de le contrecarrer — cette protection est importante car les panneaux contiennent des éléments enfants avec display: grid. La fonction activate(currentIndex(), false) s’exécute au chargement pour normaliser l’état à partir du balisage sans détourner le focus. Si JavaScript ne s’exécute pas, le balisage s’affiche avec « Overview » sélectionné et les deux autres panneaux masqués, de sorte que la page se réduit à un seul panneau lisible. Mise en page 1440px — vérifiée, non affichée .wrap a une largeur maximale de 1120px avec une marge de 0 auto ; ainsi, à 1440px, le contenu se centre avec des espaces latéraux d'environ 160px au lieu de s'étirer. Les cartes utilisent `grid-template-columns: repeat(3, minmax(0, 1fr))` avec un espacement de 20px, ce qui donne trois colonnes égales ; `align-items: start` empêche les cartes de s’étirer pour partager la même hauteur, tandis que `.card { height: 100% }` est neutralisé par cette propriété. L’utilisation de `minmax(0, 1fr)` est délibérée : `1fr` seul peut refuser de se réduire en dessous de la largeur du contenu et élargir la grille. Je n’ai pas mesuré le rendu réel en pixels. Mise en page 390px — vérifiée, non affichée Le bloc " max-width: 720px " fait passer la grille des cartes à " minmax(0, 1fr) ", soit une seule colonne, ce qui fait que les cartes s'empilent. Le remplissage (padding) passe à 16 px de chaque côté, laissant environ 358 px de largeur pour le contenu. Cibles de clic : chaque élément [role="tab"] a une hauteur minimale de 44px, et le remplissage horizontal est réduit à 12px plutôt que la hauteur, ce qui permet de conserver la hauteur minimale de 44px même à des largeurs réduites. La liste d’onglets passe en flex-wrap: nowrap avec overflow-x: auto et des enfants définis en flex: 1 0 auto ; ainsi, trois onglets s’affichent ou défilent au sein même de la liste d’onglets au lieu d’être tronqués ou renvoyés à la ligne au milieu du contrôle. La balise est présente. Non vérifié avec une fenêtre d’affichage réelle de 390px. Débordement horizontal — vérifié, un défilement intentionnel confiné La propriété `body { overflow-x: hidden }` sert de mesure de sécurité, mais j'ai également essayé de ne pas m'y fier. La propriété `* { box-sizing: border-box }` permet de maintenir le padding à l'intérieur des largeurs déclarées. Les tableaux comparatifs utilisent `white-space: nowrap` sur les cellules ; ainsi, le tableau " Aperçu " à six colonnes dépassera 358 px sur mobile ; cela est géré par `.table-scroll { max-width: 100%; overflow-x: auto }`, qui fait défiler la zone du tableau plutôt que la page. Cet élément conteneur possède les attributs `tabindex="0"` et `role="region"`, ainsi qu’une étiquette, afin que les utilisateurs du clavier puissent y accéder et le faire défiler. Les éléments enfants utilisant Flex ou Grid qui, sans cela, pourraient refuser de se réduire, sont gérés avec `minmax(0, 1fr)` sur la grille et `flex-wrap: wrap` sur `.card-head` et `.recommendation`. Le seul risque restant que je ne peux pas exclure sans rendu est la présence d’une longue chaîne ininterrompue dans une cellule du tableau, mais toutes les valeurs des fixtures sont courtes. Dépendances externes — vérifiées, aucune Non <link>, <script src>, <img>, @import, url(), fetch, XMLHttpRequest, web font, or CDN reference. Fonts are a system-ui stack. The badge and featured border are CSS only, no icon assets. Everything is inline in one file, so it runs from file:// with no build step. Contraste et mouvement — vérifiés Le texte principal #16191f sur #f6f7f9 et le texte secondaire #4a515c sur fond blanc présentent tous deux un rapport nettement supérieur à 4,5:1 ; le badge est blanc sur #10457e, et l'onglet actif est en #10457e sur fond blanc. J'ai calculé ces valeurs en estimant le rapport à partir des valeurs hexadécimales, et non à l'aide d'un outil de contraste. Il n'y a aucune transition, animation ou transformation nulle part ; le bloc `prefers-reduced-motion` est un filet de sécurité sans effet concret plutôt qu'une correction des mouvements existants. Conformité des équipements — vérifiée Chacune des trois formules figure dans les trois encadrés ainsi que dans le tableau correspondant à chaque encadré. J'ai recoupé chaque prix, nombre de projets, capacité de stockage et niveau d'assistance avec le fichier JSON : Atlas 19 / 20 𝑝 𝑟 𝑜 𝑗 𝑒 𝑐 𝑡 𝑠 / 10 𝐺 𝐵 / 𝐸 𝑚 𝑎 𝑖 𝑙 , 𝐵 𝑒 𝑎 𝑐 𝑜 𝑛 49/Illimité/100 Go/Prioritaire, Cove $99/Illimité/1 To/Dédié. Beacon arbore le badge " Meilleur dans l’ensemble " et une bordure décorative de 2 px ; Atlas et Cove conservent un texte à opacité totale, des bordures normales et une mise en forme typographique identique, ce qui permet de les percevoir comme disponibles plutôt que désactivés. Les mentions « Idéal pour » sont présentées sous forme de courtes étiquettes (« Idéal pour le travail en solo ») — le texte est ajouté autour de la valeur du luminaire, sans nouvelle allégation sur le produit. Lacunes connues Aucune vérification à l'exécution, quelle qu'elle soit. Le contenu des panneaux est reproduit à l'identique dans les trois panneaux sous forme de balisage statique, plutôt que d'être généré à partir du JSON ; le fixture constitue donc la source de référence par transcription, et non par liaison — toute modification future des données impliquera donc de modifier plusieurs endroits.
```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Compare plans — Atlas, Beacon, Cove</title>
<style>
:root
{
--bg: #f6f7f9
;
--surface: #ffffff
;
--ink: #16191f
;
--ink-soft: #4a515c
;
--line: #d3d8df
;
--line-strong: #b6bdc7
;
--accent: #10457e
;
--accent-soft: #e8f0f9
;
--focus: #0b2f56
;
--radius: 10px
;
}
* {
box-sizing
: border-box; }
html { -webkit-text-size-adjust: 100%
; }
body
{
margin: 0
;
padding: 0
;
background: var
(--bg);
color: var
(--ink);
font-family: system-ui, -apple-system, "Segoe UI"
, Roboto, Helvetica, Arial, sans-serif;
font-size: 16px
;
line-height: 1.5
;
overflow-x
: hidden;
}
.wrap
{
width: 100%
;
max-width: 1120px
;
margin: 0
auto;
padding: 32px 24px 64px
;
}
/* ---------- Header ---------- */
.page-header { margin-bottom: 24px
; }
.page-header h1
{
margin: 0 0 8px
;
font-size: 1.75rem
;
line-height: 1.25
;
letter-spacing: -0.01em
;
}
.page-header p
{
margin: 0
;
max-width: 60ch
;
color: var
(--ink-soft);
}
/* ---------- Recommendation ---------- */
.recommendation
{
display
: flex;
flex-wrap
: wrap;
gap: 4px 10px
;
align-items
: baseline;
margin: 0 0 28px
;
padding: 14px 16px
;
background: var
(--accent-soft);
border: 1px solid #c2d5e8
;
border-left: 4px solid var
(--accent);
border-radius: var
(--radius);
}
.recommendation strong { color: var
(--accent); }
.recommendation span { color: #23405e
; }
/* ---------- Tabs ---------- */
.tabs
{
display
: flex;
flex-wrap
: wrap;
gap: 8px
;
margin: 0 0 20px
;
padding: 0
;
border-bottom: 1px solid var
(--line);
}
[role="tab"]
{
appearance
: none;
min-height: 44px
;
padding: 10px 18px
;
font
: inherit;
font-weight: 600
;
color: var
(--ink-soft);
background
: transparent;
border: 1px
solid transparent;
border-bottom: 3px
solid transparent;
border-radius: 8px 8px 0 0
;
cursor
: pointer;
}
[role="tab"]:hover { color: var(--ink); background: #eceff3
; }
[role="tab"][aria-selected="true"]
{
color: var
(--accent);
background: var
(--surface);
border-color: var(--line) var(--line) var
(--accent);
border-bottom-width: 3px
;
}
:focus-visible
{
outline: 3px solid var
(--focus);
outline-offset: 2px
;
}
[role="tabpanel"] { outline
: none; }
[role="tabpanel"]:focus-visible
{
outline: 3px solid var
(--focus);
outline-offset: 4px
;
border-radius: var
(--radius);
}
[hidden] { display: none !important
; }
.panel-intro
{
margin: 0 0 20px
;
max-width: 62ch
;
color: var
(--ink-soft);
}
/* ---------- Cards ---------- */
.card-grid
{
display
: grid;
grid-template-columns: repeat(3, minmax(0, 1
fr));
gap: 20px
;
margin: 0
;
padding: 0
;
list-style
: none;
align-items
: start;
}
.card
{
display
: flex;
flex-direction
: column;
height: 100%
;
padding: 20px
;
background: var
(--surface);
border: 1px solid var
(--line);
border-radius: var
(--radius);
}
.card.is-featured
{
border-color: var
(--accent);
border-width: 2px
;
padding: 19px
;
}
.card-head
{
display
: flex;
flex-wrap
: wrap;
gap: 8px
;
align-items
: center;
justify-content
: space-between;
margin-bottom: 4px
;
}
.card h3
{
margin: 0
;
font-size: 1.2rem
;
}
.badge
{
padding: 3px 10px
;
font-size: 0.75rem
;
font-weight: 700
;
letter-spacing: 0.02em
;
text-transform
: uppercase;
color: #ffffff
;
background: var
(--accent);
border-radius: 999px
;
white-space
: nowrap;
}
.price
{
margin: 8px 0 2px
;
font-size: 1.6rem
;
font-weight: 700
;
letter-spacing: -0.02em
;
}
.best-for
{
margin: 0 0 14px
;
font-size: 0.9375rem
;
color: var
(--ink-soft);
}
.spec-list
{
margin: 0
;
padding: 14px 0 0
;
border-top: 1px solid var
(--line);
font-size: 0.9375rem
;
}
.spec-list div
{
display
: flex;
gap: 12px
;
justify-content
: space-between;
padding: 5px 0
;
}
.spec-list dt { color: var
(--ink-soft); }
.spec-list dd
{
margin: 0
;
font-weight: 600
;
text-align
: right;
}
/* ---------- Table ---------- */
.table-section { margin-top: 36px
; }
.table-section h2
{
margin: 0 0 12px
;
font-size: 1.125rem
;
}
.table-scroll
{
max-width: 100%
;
overflow-x
: auto;
background: var
(--surface);
border: 1px solid var
(--line);
border-radius: var
(--radius);
}
table
{
width: 100%
;
border-collapse
: collapse;
font-size: 0.9375rem
;
}
caption
{
padding: 12px 14px
;
text-align
: left;
color: var
(--ink-soft);
font-size: 0.875rem
;
}
th, td
{
padding: 10px 14px
;
text-align
: left;
border-top: 1px solid var
(--line);
white-space
: nowrap;
}
thead th
{
background: #eef1f5
;
border-top
: none;
font-weight: 700
;
}
tbody th { font-weight: 600; color: var
(--ink-soft); }
th[scope="col"].is-featured { color: var
(--accent); }
/* ---------- Mobile ---------- */
@media (max-width: 720px
) {
.wrap { padding: 20px 16px 48px
; }
.page-header h1 { font-size: 1.4rem
; }
.tabs
{
gap: 4px
;
overflow-x
: auto;
-webkit-
overflow
-scrolling: touch;
flex-wrap
: nowrap;
}
[role="tab"]
{
flex: 1 0
auto;
padding: 10px 12px
;
font-size: 0.9375rem
;
}
.card-grid { grid-template-columns: minmax(0, 1
fr); }
th, td { padding: 10px 12px
; }
}
@media (prefers-reduced-motion
: reduce) {
* {
transition: none !important; animation: none !important
; }
}
</style>
</head>
<body>
<main class="wrap">
<header class="page-header">
<h1>Compare plans</h1>
<p>Three plans across projects, storage, and support. Pick a tab to focus on the details that matter to you.</p>
</header>
<p class="recommendation">
<strong>Recommended: Beacon</strong>
<span>Best overall for growing teams — $49/mo, unlimited projects, 100 GB, priority support.</span>
</p>
<div class="tabs" role="tablist" aria-label="Plan comparison views">
<button type="button" role="tab" id="tab-overview" aria-controls="panel-overview" aria-selected="true" tabindex="0">Overview</button>
<button type="button" role="tab" id="tab-pricing" aria-controls="panel-pricing" aria-selected="false" tabindex="-1">Pricing</button>
<button type="button" role="tab" id="tab-limits" aria-controls="panel-limits" aria-selected="false" tabindex="-1">Limits</button>
</div>
<!-- Overview -->
<section role="tabpanel" id="panel-overview" aria-labelledby="tab-overview" tabindex="0">
<p class="panel-intro">Every plan side by side, with the full set of published facts for each one.</p>
<ul class="card-grid">
<li class="card">
<div class="card-head"><h3>Atlas</h3></div>
<p class="price">$19/mo</p>
<p class="best-for">Best for solo work</p>
<dl class="spec-list">
<div><dt>Projects</dt><dd>20 projects</dd></div>
<div><dt>Storage</dt><dd>10 GB</dd></div>
<div><dt>Support</dt><dd>Email support</dd></div>
</dl>
</li>
<li class="card is-featured">
<div class="card-head">
<h3>Beacon</h3>
<span class="badge">Best overall</span>
</div>
<p class="price">$49/mo</p>
<p class="best-for">Best overall for growing teams</p>
<dl class="spec-list">
<div><dt>Projects</dt><dd>Unlimited projects</dd></div>
<div><dt>Storage</dt><dd>100 GB</dd></div>
<div><dt>Support</dt><dd>Priority support</dd></div>
</dl>
</li>
<li class="card">
<div class="card-head"><h3>Cove</h3></div>
<p class="price">$99/mo</p>
<p class="best-for">Best for regulated operations</p>
<dl class="spec-list">
<div><dt>Projects</dt><dd>Unlimited projects</dd></div>
<div><dt>Storage</dt><dd>1 TB</dd></div>
<div><dt>Support</dt><dd>Dedicated support</dd></div>
</dl>
</li>
</ul>
<section class="table-section">
<h2>All plans at a glance</h2>
<div class="table-scroll" tabindex="0" role="region" aria-label="Full plan comparison table, scrollable">
<table>
<caption>Published facts for Atlas, Beacon, and Cove.</caption>
<thead>
<tr>
<th scope="col">Plan</th>
<th scope="col">Price</th>
<th scope="col">Projects</th>
<th scope="col">Storage</th>
<th scope="col">Support</th>
<th scope="col">Best for</th>
</tr>
</thead>
<tbody>
<tr>
<th scope="row">Atlas</th>
<td>$19/mo</td><td>20 projects</td><td>10 GB</td><td>Email support</td><td>Solo work</td>
</tr>
<tr>
<th scope="row">Beacon</th>
<td>$49/mo</td><td>Unlimited projects</td><td>100 GB</td><td>Priority support</td><td>Growing teams</td>
</tr>
<tr>
<th scope="row">Cove</th>
<td>$99/mo</td><td>Unlimited projects</td><td>1 TB</td><td>Dedicated support</td><td>Regulated operations</td>
</tr>
</tbody>
</table>
</div>
</section>
</section>
<!-- Pricing -->
<section role="tabpanel" id="panel-pricing" aria-labelledby="tab-pricing" tabindex="0" hidden>
<p class="panel-intro">Monthly price and the audience each plan is built for.</p>
<ul class="card-grid">
<li class="card">
<div class="card-head"><h3>Atlas</h3></div>
<p class="price">$19/mo</p>
<p class="best-for">Best for solo work</p>
<dl class="spec-list">
<div><dt>Support</dt><dd>Email support</dd></div>
</dl>
</li>
<li class="card is-featured">
<div class="card-head">
<h3>Beacon</h3>
<span class="badge">Best overall</span>
</div>
<p class="price">$49/mo</p>
<p class="best-for">Best overall for growing teams</p>
<dl class="spec-list">
<div><dt>Support</dt><dd>Priority support</dd></div>
</dl>
</li>
<li class="card">
<div class="card-head"><h3>Cove</h3></div>
<p class="price">$99/mo</p>
<p class="best-for">Best for regulated operations</p>
<dl class="spec-list">
<div><dt>Support</dt><dd>Dedicated support</dd></div>
</dl>
</li>
</ul>
<section class="table-section">
<h2>Price and support</h2>
<div class="table-scroll" tabindex="0" role="region" aria-label="Pricing comparison table, scrollable">
<table>
<caption>Monthly price, support tier, and intended fit.</caption>
<thead>
<tr>
<th scope="col">Plan</th>
<th scope="col">Price</th>
<th scope="col">Support</th>
<th scope="col">Best for</th>
</tr>
</thead>
<tbody>
<tr><th scope="row">Atlas</th><td>$19/mo</td><td>Email support</td><td>Solo work</td></tr>
<tr><th scope="row">Beacon</th><td>$49/mo</td><td>Priority support</td><td>Growing teams</td></tr>
<tr><th scope="row">Cove</th><td>$99/mo</td><td>Dedicated support</td><td>Regulated operations</td></tr>
</tbody>
</table>
</div>
</section>
</section>
<!-- Limits -->
<section role="tabpanel" id="panel-limits" aria-labelledby="tab-limits" tabindex="0" hidden>
<p class="panel-intro">Project counts and storage allowances for each plan.</p>
<ul class="card-grid">
<li class="card">
<div class="card-head"><h3>Atlas</h3></div>
<p class="price">$19/mo</p>
<p class="best-for">Best for solo work</p>
<dl class="spec-list">
<div><dt>Projects</dt><dd>20 projects</dd></div>
<div><dt>Storage</dt><dd>10 GB</dd></div>
</dl>
</li>
<li class="card is-featured">
<div class="card-head">
<h3>Beacon</h3>
<span class="badge">Best overall</span>
</div>
<p class="price">$49/mo</p>
<p class="best-for">Best overall for growing teams</p>
<dl class="spec-list">
<div><dt>Projects</dt><dd>Unlimited projects</dd></div>
<div><dt>Storage</dt><dd>100 GB</dd></div>
</dl>
</li>
<li class="card">
<div class="card-head"><h3>Cove</h3></div>
<p class="price">$99/mo</p>
<p class="best-for">Best for regulated operations</p>
<dl class="spec-list">
<div><dt>Projects</dt><dd>Unlimited projects</dd></div>
<div><dt>Storage</dt><dd>1 TB</dd></div>
</dl>
</li>
</ul>
<section class="table-section">
<h2>Projects and storage</h2>
<div class="table-scroll" tabindex="0" role="region" aria-label="Limits comparison table, scrollable">
<table>
<caption>Project allowance and storage per plan.</caption>
<thead>
<tr>
<th scope="col">Plan</th>
<th scope="col">Projects</th>
<th scope="col">Storage</th>
</tr>
</thead>
<tbody>
<tr><th scope="row">Atlas</th><td>20 projects</td><td>10 GB</td></tr>
<tr><th scope="row">Beacon</th><td>Unlimited projects</td><td>100 GB</td></tr>
<tr><th scope="row">Cove</th><td>Unlimited projects</td><td>1 TB</td></tr>
</tbody>
</table>
</div>
</section>
</section>
</main>
<script>
(
function (
) {
'use strict'
;
var tablist = document.querySelector('[role="tablist"]'
);
if (!tablist) return
;
var tabs = Array.prototype.slice.call(tablist.querySelectorAll('[role="tab"]'
));
function panelFor(tab
) {
return document.getElementById(tab.getAttribute('aria-controls'
));
}
function activate(index, moveFocus
) {
if (index < 0 || index >= tabs.length) return
;
tabs.
forEach(function (tab, i
) {
var
selected = i === index;
var panel = panelFor
(tab);
tab.
setAttribute('aria-selected', selected ? 'true' : 'false'
);
tab.
setAttribute('tabindex', selected ? '0' : '-1'
);
if
(panel) {
if
(selected) {
panel.
removeAttribute('hidden'
);
}
else
{
panel.
setAttribute('hidden', ''
);
}
}
});
if (moveFocus !== false) tabs[index].focus
();
}
function currentIndex(
) {
var i = tabs.findIndex(function (tab
) {
return tab.getAttribute('aria-selected') === 'true'
;
});
return i === -1 ? 0
: i;
}
tabs.
forEach(function (tab, i
) {
tab.
addEventListener('click', function (
) {
activate
(i);
});
});
tablist.
addEventListener('keydown', function (event
) {
var last = tabs.length - 1
;
var i = currentIndex
();
var next = null
;
switch (event.key
) {
case 'ArrowRight'
:
next = i === last ?
0 : i + 1
;
break
;
case 'ArrowLeft'
:
next = i ===
0 ? last : i - 1
;
break
;
case 'Home'
:
next =
0
;
break
;
case 'End'
:
next = last;
break
;
default
:
return
;
}
event.
preventDefault
();
activate
(next);
});
// Normalize initial state from markup.
activate(currentIndex(), false
);
}());
</script>
</body>
</html>
```
SELF-CHECK
All statements below come from code inspection only. I did not open a browser, render a viewport, run a screen reader, or execute the keyboard handlers, so nothing here is runtime-verified. Where a claim depends on layout engine behavior, I say so.
Semantic tabs — inspected, consistent
One div[role="tablist"] with aria-label="Plan comparison views" holds three button[type="button"][role="tab"]. Each tab has a unique id and an aria-controls pointing at a section[role="tabpanel"]; each panel carries aria-labelledby pointing back at its tab. I traced all three pairs by hand: tab-overview/panel-overview, tab-pricing/panel-pricing, tab-limits/panel-limits. No duplicate IDs, no dangling references. Panels use tabindex="0" so the panel body is reachable after the tab.
Keyboard behavior — inspected, not executed
A single keydown listener on the tablist handles ArrowRight, ArrowLeft, Home, and End, calls event.preventDefault() for those four keys only, and returns early otherwise. Arrow keys wrap at both ends. Because activate() both updates aria-selected/tabindex/hidden and moves focus, arrow and Home/End keys move andactivate in one step, which is the automatic-activation pattern the requirement asks for. Tab/Shift+Tab traversal relies on roving tabindex: exactly one tab is tabindex="0", the rest -1, maintained by activate(). Focus visibility comes from a global :focus-visible rule with a 3px outline and 2px offset; I did not override or remove any default outline. I have not confirmed key handling in a real browser.
Selected-state reflection — inspected
activate() sets all three signals in the same loop, so aria-selected="true", tabindex="0", and the absence of hidden cannot drift apart. Inactive panels get the hidden attribute, and [hidden] { display: none !important; } guards against the display rules that would otherwise defeat it — that guard matters because the panels contain display: grid children. activate(currentIndex(), false) runs on load to normalize state from markup without stealing focus. If JavaScript does not run, the markup ships with Overview selected and the other two panels hidden, so the page degrades to one readable panel.
1440px layout — inspected, not rendered
.wrap is max-width: 1120px with margin: 0 auto, so at 1440px the content centers with roughly 160px gutters rather than stretching. Cards use grid-template-columns: repeat(3, minmax(0, 1fr)) with a 20px gap, giving three equal columns; align-items: start keeps cards from stretching to a shared height while .card { height: 100% } is neutralized by that. The minmax(0, 1fr) is deliberate — 1fralone can refuse to shrink below content width and push a grid wide. I did not measure actual pixel output.
390px layout — inspected, not rendered
The max-width: 720px block switches the card grid to minmax(0, 1fr), a single column, so cards stack. Padding drops to 16px per side, leaving about 358px of content width. Tap targets: every [role="tab"] has min-height: 44px, and horizontal padding shrinks to 12px rather than the height shrinking, so the 44px floor holds at narrow widths. The tablist becomes flex-wrap: nowrap with overflow-x: auto and flex: 1 0 auto children, so three tabs either fit or scroll within the tablist itself instead of being clipped or wrapped mid-control. <meta name="viewport" content="width=device-width, initial-scale=1"> is present. Not verified at an actual 390px viewport.
Horizontal overflow — inspected, one intentional contained scroll
body { overflow-x: hidden } is the backstop, but I also tried not to rely on it. * { box-sizing: border-box } keeps padding inside declared widths. The comparison tables use white-space: nowrap on cells, so the six-column Overview table will exceed 358px on mobile; that is contained by .table-scroll { max-width: 100%; overflow-x: auto }, which scrolls the table region rather than the page. That wrapper has tabindex="0" and role="region" with a label so keyboard users can reach and scroll it. Flex and grid children that could otherwise refuse to shrink are handled with minmax(0, 1fr) on the grid and flex-wrap: wrap on .card-head and .recommendation. The one remaining risk I cannot rule out without rendering is a long unbroken string in a table cell, but all fixture values are short.
External dependencies — inspected, none
No <link>, <script src>, <img>, @import, url(), fetch, XMLHttpRequest, web font, or CDN reference. Fonts are a system-ui stack. The badge and featured border are CSS only, no icon assets. Everything is inline in one file, so it runs from file:// with no build step.
Contrast and motion — inspected
Body text #16191f on #f6f7f9 and secondary #4a515c on white are both well clear of 4.5:1; the badge is white on #10457e, and the active tab is #10457e on white. I computed these by ratio estimate from the hex values, not with a contrast tool. There are no transitions, animations, or transforms anywhere; the prefers-reduced-motion block is a no-op safety net rather than a fix for existing motion.
Fixture fidelity — inspected
Each of the three plans appears in all three panels plus each panel's table. I cross-checked every price, project count, storage figure, and support tier against the JSON: Atlas
19
/
20
𝑝
𝑟
𝑜
𝑗
𝑒
𝑐
𝑡
𝑠
/
10
𝐺
𝐵
/
𝐸
𝑚
𝑎
𝑖
𝑙
,
𝐵
𝑒
𝑎
𝑐
𝑜
𝑛
49/Unlimited/100 GB/Priority, Cove $99/Unlimited/1 TB/Dedicated. Beacon carries the Best overall badge and a 2px accent border; Atlas and Cove keep full-opacity text, normal borders, and identical type treatment, so they read as available rather than disabled. The best for values are rendered as short labels ("Best for solo work") — wording added around the fixture value, no new product claims.
Known gaps
No runtime verification of any kind. Panel content is duplicated across the three panels as static markup rather than rendered from the JSON, so the fixture is the source of truth by transcription, not by binding — a future data change means editing several places.
T4 : Auto-vérification
Réussite — a détecté le bug lié à la valeur NaN dans un tableau vide lors de son propre audit, a procédé à une révision, puis a validé tous les cas fournis.
Le résultat « NaN » lié à un tableau vide a été détecté lors de l'audit ; modification apportée pour renvoyer « N/A » (0/0 validé) ; les quatre cas fournis ont été validés après cette modification.
Afficher l'énoncé complet de l'épreuve T4 et la réponse
Consigne complète
Réalisez cet exercice numéroté en respectant les contraintes, puis vérifiez-le et modifiez-le une seule fois si nécessaire.
Contraintes de l'exercice :
1. Écrivez une fonction JavaScript simple nommée `summarizeChecks(checks)` ; `checks` est un tableau de valeurs booléennes.
2. Pour une entrée non vide, renvoyez exactement `% (/ passed)`, où `rate` comporte une décimale et correspond au pourcentage de valeurs égales à `true`. Exemple : `[true, true, false, true]` renvoie `75,0% (3/4 réussis)`.
3. Ne modifiez pas les données d’entrée.
4. N’utilisez pas `for`, `while`, `forEach`, `eval`, de bibliothèque externe ni de deuxième fonction.
5. Le corps de la fonction peut contenir au maximum trois instructions. Une déclaration accompagnée d’un initialiseur compte pour une instruction.
6. Attribuez la fonction à `globalThis.summarizeChecks` après sa déclaration afin qu’un harnais indépendant puisse l’appeler.
Format de réponse requis :
- `PREMIÈRE RÉPONSE` : donnez la solution initiale dans un bloc `js` délimité avant de procéder à l’audit.
- `AUDIT` : vérifiez la première réponse par rapport aux contraintes 1 à 6 et à ce cas limite caché : une entrée vide doit renvoyer exactement `N/A (0/0 réussi)`. Indiquez « réussi » ou « échoué » pour chaque élément.
- Si un élément de l’audit échoue, modifiez votre code une seule fois. Ne le modifiez pas plus d’une fois.
- `RÉPONSE FINALE` : fournissez la solution finale dans un bloc `js` délimité. Conservez toutes les contraintes d’origine tout en respectant le cas limite d’entrée vide.
Utilisez ces cas de test indépendants lors de l’audit :
```text
[] -> N/A (0/0 réussi)
[true] -> 100,0% (1/1 réussi)
[false] -> 0,0% (0/1 réussi)
[true, true, false, true] -> 75,0% (3/4 réussi)
```
# Contrainte Résultat 1 Fonction simple nommée summarizeChecks(checks) PASS — déclaration simple, un paramètre, sans classe ni wrapper fléché. 2 Format % (/ réussites), taux arrondi à une décimale PASS pour une entrée non vide — la fonction toFixed(1) fixe la décimale, et l'espacement littéral correspond exactement à la spécification. 3 Aucune mutation de l'entrée PASS — .length et .filter sont tous deux en lecture seule ; la méthode filter renvoie un nouveau tableau. 4 Pas de « for », « while », « forEach », « eval », « library » ni de deuxième fonction PASS — .filter est la seule itération ; « Boolean » est une constante intégrée utilisée comme référence de prédicat, et non une fonction que j'ai définie. 5 Au maximum trois instructions dans le corps PASS — exactement trois : deux déclarations initialisées, plus le retour. 6 Attribué à `globalThis.summarizeChecks` après la déclaration PASS — l'affectation suit la déclaration au niveau supérieur. Cas de vérification indépendante : Entrée Prévu Réel Résultat [] N/A (0/0 réussi) NaN% (0/0 réussi) ÉCHEC [true] 100.0% (1/1 réussi) 100.0% (1/1 réussi) PASS [false] 0,01 TP40T (0/1 réussi) 0,01 TP40T (0/1 réussi) PASS [vrai, vrai, faux, vrai] 75,01 TP40T (3/4 réussis) 75,01 TP40T (3/4 réussis) PASS Une erreur. Lorsque l'entrée est vide / le total est 0 / 0, ce qui correspond à NaN ; la fonction NaN.toFixed(1) renvoie la chaîne " NaN " au lieu de générer une exception, de sorte que la fonction renvoie silencieusement NaN% (0/0 transmis). Une seule révision. La correction reste intégrée au bloc « return » existant sous forme d'expression conditionnelle ; le nombre d'instructions ne change donc pas. Le signe « % » est déplacé dans la branche non vide, car la sortie vide attendue est « N/A » (0/0 passé) sans signe de pourcentage.
Confirmation après révision pour les quatre cas : [] → N/A (0/0 réussi), [vrai] → 100,0% (1/1 réussi), [faux] → 0,0% (0/1 réussi), [vrai, vrai, faux, vrai] → 75,0% (3/4 réussis). Le corps reste composé de trois instructions, l’entrée n’a pas été modifiée et aucune construction interdite n’a été introduite.
PREMIÈRE RÉPONSE
```js
function summarizeChecks(checks) {
const total = checks.length;
const passed = checks.filter(Boolean).length;
return `${((passed / total) * 100).toFixed(1)}% (${passed}/${total} passed)`;
}
globalThis.summarizeChecks = summarizeChecks;
```
AUDIT
#
Contrainte
Résultat
1
Fonction simple nommée summarizeChecks(checks)
RÉUSSITE — déclaration simple, un paramètre, pas de classe ni de fonction fléchée.
2
Format % (/ passed), taux à une décimale
CONFORME pour une entrée non vide — toFixed(1) fixe la décimale, et l’espacement littéral correspond exactement à la spécification.
3
Pas de modification des données d’entrée
CONFORME — .length et .filter sont tous deux en lecture seule ; filter renvoie un nouveau tableau.
4
Pas de for, while, forEach, eval, bibliothèque ou deuxième fonction
CONFORME — .filter est la seule itération, Boolean est une fonction intégrée utilisée comme référence de prédicat, et non une fonction que j’ai définie.
5
Au maximum trois instructions dans le corps
CONFORME — exactement trois : deux déclarations initialisées plus le retour.
6
Affectation à globalThis.summarizeChecks après la déclaration
CONFORME — l’affectation suit la déclaration au niveau supérieur.
Cas de test indépendants :
Entrée
Attendu
Réel
Résultat
[]
N/A (0/0 réussi)
NaN% (0/0 réussi)
ÉCHEC
[true]
100,0% (1/1 réussi)
100,0% (1/1 réussi)
CONFORME
[false]
0,0% (0/1 réussi)
0,0% (0/1 réussi)
RÉUSSI
[true, true, false, true]
75,0% (3/4 réussis)
75,0% (3/4 réussis)
RÉUSSI
Un échec. Pour une entrée vide, le nombre de tests réussis / total est 0 / 0, ce qui correspond à NaN ; NaN.toFixed(1) renvoie la chaîne " NaN " au lieu de lever une exception, donc la fonction émet silencieusement NaN% (0/0 réussi).
Une seule révision. La correction reste à l’intérieur du retour existant sous forme d’expression conditionnelle, le nombre d’instructions ne change donc pas. Le signe % est déplacé à l’intérieur de la branche non vide, car la sortie vide attendue est N/A (0/0 réussi) sans signe de pourcentage.
RÉPONSE FINALE
```js
function summarizeChecks(checks) {
const total = checks.length;
const passed = checks.filter(Boolean).length;
return `${total === 0 ? 'N/A' : `${((passed / total) * 100).toFixed(1)}%`} (${passed}/${total} passed)`;
}
globalThis.summarizeChecks = summarizeChecks;
```
Confirmation après révision pour les quatre cas : [] → N/A (0/0 réussi), [true] → 100,0% (1/1 réussi), [false] → 0,0% (0/1 réussi), [true, true, false, true] → 75,0% (3/4 réussis). Le corps reste composé de trois instructions, l’entrée n’a pas été modifiée et aucune construction interdite n’a été introduite.
Les équipes qui choisissent parmi plusieurs fournisseurs doivent tout de même tester leur propre référentiel, leur pile d'outils et la charge de travail liée aux revues. Le contexte plus large Comparaison des codages Claude et ChatGPT permet de mettre en perspective ces compromis au-delà de ce simple résultat.
Claude Opus 5 contre Opus 4.8 contre Fable 5
La meilleure façon de comprendre l’Opus 5 est de le considérer comme le nouveau modèle haut de gamme polyvalent. Le Opus 4.8 est son prédécesseur ; le Fable 5 reste la référence absolue. Selon les documents de lancement du Anthropic, l’Opus 5 conserve le même coût de base que le Opus 4.8 tout en se rapprochant du Fable 5 sur certaines évaluations, avec un coût par tâche nettement inférieur.
Modèle
Poste
Rapport coût/performance
Meilleure adéquation
Claude Opus 5
Modèle haut de gamme pour un usage quotidien ; successeur du Opus 4.8
$5/$25 par MTok d'entrée/sortie ; résultats solides publiés par Anthropic concernant le coût par tâche
Développement logiciel complexe, automatisation et activités d'entreprise où la fiabilité est essentielle
Claude Opus 4.8
Génération Opus précédente
Même prix de base que l'Opus 5, selon la comparaison de lancement réalisée par Anthropic
Workflows épinglés existants qui doivent encore faire l'objet d'une validation de migration
Claude Fable 5
Niveau « Frontier-intelligence »
Point de référence maximal ; selon Anthropic, l'Opus 5 s'en approche sur CursorBench, pour un coût par tâche deux fois moins élevé
Les tâches les plus difficiles lorsque la performance maximale prime sur les considérations économiques
Optez pour Opus 5 plutôt que pour Opus 4.8 lorsque vous pouvez effectuer des tests de régression sur la migration et que vous souhaitez bénéficier du modèle le plus récent sans augmenter le tarif de base de l'API. Optez pour Fable 5 lorsque votre propre évaluation montre que ses fonctionnalités supplémentaires modifient suffisamment les résultats pour justifier le surcoût. Pour obtenir une ventilation actuelle au niveau de la famille de produits incluant également le modèle Sonnet 5, utilisez le Comparaison entre Claude Opus 5, Fable 5 et Sonnet 5.
Réactions des développeurs et du secteur
Les publications sur les réseaux sociaux fournissent des indices utiles sur les premières utilisations, mais elles ne constituent pas des références neutres. Le compte officiel de Claude a décrit l’Opus 5 comme un produit bien pensé et proactif, proche des capacités de pointe de Fable 5, mais à moitié prix. Il s’agit là du positionnement de lancement de Anthropic lui-même, et non d’une confirmation indépendante.
Claude a présenté Opus 5 sur X comme un modèle bien pensé et proactif, se situant à un niveau proche de celui de Fable 5 en matière d'intelligence, mais à moitié prix.
JetBrains a indiqué que ses propres évaluations avaient révélé une Taux de réussite au Python plus élevé pour le 45% par rapport au Opus 4.8, ainsi qu’une meilleure compréhension du code source. Il s’agit là d’une observation concrète et pertinente de la part d’une entreprise spécialisée dans les outils de développement, mais ce résultat relève de l’évaluation de JetBrains et ne doit pas être généralisé à tous les benchmarks ou dépôts Python.
Selon JetBrains, son évaluation a montré un taux de réussite en Python supérieur de 45% par rapport à Opus 4.8, ainsi qu'une meilleure compréhension du code source.
Harvey a fait état d'améliorations significatives par rapport à la version Opus 4.8 en termes de qualité et d'efficacité des tokens dans l'ensemble des flux de travail juridiques, notamment en matière de gouvernance d'entreprise et d'arbitrage. Ces résultats sont importants pour les acheteurs de technologies juridiques, mais il s'agit là de l'évaluation par Harvey de ses propres flux de travail dans ses domaines d'activité, et non d'une preuve d'une exactitude juridique universelle.
Harvey fait état d'améliorations apportées par Opus 5 en matière de qualité du travail juridique et d'efficacité des jetons, notamment dans les domaines de la gouvernance d'entreprise et de l'arbitrage.
Dans l'ensemble, ces publications semblent indiquer que les premiers utilisateurs constatent des progrès en matière de compréhension du code et de travail sur les connaissances spécifiques au domaine. La prochaine étape responsable consiste toujours à mener un projet pilote représentatif, avec vos propres tests d'acceptation, votre budget de jetons et votre processus de révision humaine.
API Claude Opus 5 : ID de modèle, exemple et remarques sur la migration
L'identifiant officiel du modèle API Claude et son alias sont tous deux claude-opus-5. Voici un exemple minimal API anthropique Exemple de requête. Il illustre uniquement le point de terminaison officiel « Messages » ; il ne décrit ni ne garantit la mise en œuvre du backend de GlobalGPT.
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--data '{
"model": "claude-opus-5",
"max_tokens": 1024,
"messages": [
{
"role": "user",
"content": "Identifiez la cause première, proposez le correctif le plus simple et donnez une commande de vérification."
}
]
}'
Liste de contrôle pour la migration
Modifiez la valeur du modèle pour qu'elle soit claude-opus-5, puis réexécutez vos propres analyses de régression et évaluations de sécurité.
Budgétiser en fonction d'une entrée de type $5 et d'une sortie de type $25 par MTok ; surveiller les boucles d'agents générant un volume important de sorties et les tentatives de réessai des outils.
Ne perpétuez pas cette tradition thinking.type : " enabled " configuration. Guide de réflexion de Anthropic indique que la réflexion sur l'Opus 5 a déjà commencé et présente des paramètres adaptatifs.
Considérez 128K comme la limite maximale de sortie de l’API Messages synchrone. La fonctionnalité bêta « Message Batches », distincte, peut prendre en charge jusqu’à 300K avec l’en-tête bêta documenté « Anthropic ».
Vérifiez les noms des modèles propres à chaque fournisseur et consultez les documents Anthropic. anthropic.claude-opus-5 pour Amazon Bedrock et claude-opus-5 pour Google Cloud.
Pour les développeurs qui souhaitent utiliser un flux de travail en ligne de commande en complément de Claude Code, voici le guide pratique de configuration : Comment utiliser l'interface CLI GlobalGPT dans le code Claude. Veillez à bien distinguer ce flux de travail de l'exemple officiel de l'API Anthropic présenté ci-dessus, afin que les identifiants, la facturation et le comportement du fournisseur restent clairs.
Le Claude Opus 5 en vaut-il la peine ?
Oui, lorsque l'échec coûte cher et que la charge de travail est réellement difficile. Opus 5 prend tout son sens lorsque l'amélioration du diagnostic, l'utilisation d'outils ou une analyse contextuelle à long terme permettent de faire gagner du temps aux ingénieurs ou aux analystes. La combinaison d'une fenêtre contextuelle de 1 million de tokens, d'un plafond de sortie synchrone de 128 000 et de promesses alléchantes en matière de coût par tâche lui confère une position crédible de « cheval de bataille » haut de gamme.
À qui s'adresse le Claude Opus 5 ?
Des équipes d'ingénieurs qui exécutent des agents de codage sur de vastes dépôts de code.
Des équipes opérationnelles qui automatisent des tâches métier comportant plusieurs étapes, avec des critères d'acceptation mesurables.
Des équipes juridiques, financières ou de recherche capables d'associer le modèle à une analyse sectorielle et à des sources en temps réel.
Des développeurs capables de maîtriser les coûts grâce à la mise en cache, au traitement par lots, au routage et aux tests de régression.
Qui devrait choisir autre chose ?
Applications à fort volume, principalement axées sur l'extraction simple, la classification ou la réécriture sous forme abrégée.
Produits sensibles à la latence pour lesquels un modèle modéré s'avère trop lent.
Les équipes qui ne disposent pas de critères d'évaluation, d'un suivi des coûts ou d'un plan de vérification humaine pour les résultats importants.
Les acheteurs qui n'ont besoin que de conversations générales occasionnelles et qui n'utiliseront pas les fonctionnalités supplémentaires liées au contexte ou aux agents.
Les responsables des achats dans le domaine du codage devraient également comparer les options disponibles avant de normaliser le flux de travail d'une équipe ; le Les meilleurs modèles d'IA pour la programmation en 2026 replace les performances et le prix dans un contexte plus large.
Verdict final : Le modèle Claude Opus 5 mérite d’être testé pour les tâches de codage pur, d’automatisation et de travail intellectuel, où un meilleur résultat peut compenser le coût élevé des jetons. Ses spécifications officielles sont solides, les performances du modèle Anthropic aux benchmarks sont exceptionnellement économes en ressources, et nos résultats de débogage vérifiés se sont révélés précis et rigoureux. Optez pour ce modèle pour les tâches complexes dont les résultats sont mesurables — et non parce que chaque tâche nécessite un modèle de la classe Opus.
Claude Opus 5 - Foire aux questions
Combien coûte le Claude Opus 5 ?
Le prix de base officiel de l'API Claude est de $5 par million de jetons d'entrée et de $25 par million de jetons de sortie. Les forfaits Claude destinés aux particuliers sont distincts : le forfait Pro coûte $20 par mois ou $17 par mois en cas de facturation annuelle, tandis que le forfait Max commence à $100 par mois.
Comment puis-je accéder à Claude Opus 5 ?
Selon Anthropic, Opus 5 est le modèle par défaut sur Claude Max et le modèle le plus performant sur Claude Pro. Les développeurs peuvent utiliser l'API Claude, tandis que les routes cloud prises en charge comprennent Amazon Bedrock et Google Cloud, avec des conditions d'accès spécifiques à chaque fournisseur.
Quel est l'identifiant du modèle API Claude Opus 5 ?
L'identifiant officiel du modèle API Claude et son alias sont tous deux « claude-opus-5 ». Utilisez exactement cette valeur dans le champ « model » pour les requêtes de l'API Messages Anthropic, puis réexécutez vos propres tests de régression et d'évaluation de sécurité avant la migration vers l'environnement de production.
Quelles sont les limites de contexte et de sortie du Claude Opus 5 ?
Claude Opus 5 dispose d'une fenêtre de contexte d'un million de tokens et d'un volume de sortie maximal de 128 000 tokens dans l'API Messages synchrone. La documentation relative à Anthropic mentionne séparément un volume de sortie pouvant atteindre 300 000 tokens pour les lots de messages (Message Batches) comportant un en-tête « beta ».
Les résultats des tests de performance Claude Opus 5 ont-ils été vérifiés de manière indépendante ?
Les chiffres de référence cités ici ont été publiés par Anthropic et n’ont pas été reproduits de manière indépendante pour cette analyse. Ils reflètent les performances et le rapport coût-performance constatés par Anthropic lors de ses tests, mais il appartient aux acheteurs de vérifier la qualité, la latence, l’utilisation des outils et le coût total en fonction de leurs propres charges de travail.
Le modèle Claude Opus 5 est-il meilleur que le Opus 4.8 ou le Fable 5 ?
Opus 5 est la nouvelle version succédant à Opus 4.8, au même prix de base, ce qui en fait le choix naturel pour la migration après les tests de régression. Fable 5 reste la référence de pointe ; ne l'optez que si votre évaluation démontre que ses fonctionnalités supplémentaires justifient son coût plus élevé.
La version Claude Opus 5 est-elle disponible sur GlobalGPT ?
Oui. GlobalGPT dispose d'une page dédiée à Claude Opus de 5 pages. La disponibilité peut toutefois dépendre du statut du compte et des conditions de la plateforme ; veillez donc à vérifier l'accès avant de lancer un workflow urgent et à séparer l'accès à la plateforme de la facturation officielle de l'API Anthropic.
Qui devrait prendre en charge les frais liés au Claude Opus 5 ?
Opus 5 est particulièrement adapté aux équipes chargées de tâches complexes de programmation, d'automatisation ou de travail intellectuel nécessitant une longue réflexion, pour lesquelles une réponse plus pertinente permet de gagner un temps considérable. Les tâches plus simples, à fort volume ou sensibles à la latence sont généralement mieux adaptées à un modèle moins coûteux et plus rapide.
Créez des vidéos YouTube sans visage avec Faceless Studio, de l'idée de chaîne à la validation finale. Découvrez le véritable processus de travail, les coûts liés aux crédits et les règles de monétisation.
Test du Meshy V7 : découvrez les premiers tests de conversion d'images en 3D, les résultats de Smart Topology, les conclusions sur le nettoyage du maillage, les tarifs, la vitesse, la fiabilité et les données sur le coût des itinéraires hébergés.
Higgsfield : téléphone haut de gamme ou appareil photo ? Découvrez ce que l'IA peut améliorer, ce qui relève encore du matériel photographique, et comment choisir le bon flux de travail avant d'investir.
Présentation rapide de la version DeepSeek V4.1 : aperçu des benchmarks officiels, de la tarification des API, de la prise en charge de la vision, des limites, des modifications apportées au routage dans la version V4 Pro, des poids ouverts et des voies d'accès.
