Reseña del Claude Opus 5: ¿Merece la pena el nuevo modelo de Anthropic?
Olivia Carter
Última actualización: 29 de julio de 2026
Reseña del Claude Opus 5: ¿Merece la pena el nuevo modelo de Anthropic?
Verificado el 28 de julio de 2026.
Opinión rápida: Esta reseña del Claude Opus 5 presenta un modelo de gama alta muy atractivo para agentes de programación, flujos de trabajo empresariales complejos y compradores que buscan un rendimiento cercano a la vanguardia sin tener que pagar siempre por el Fable 5. El modelo Anthropic cobra $5 por cada millón de tokens de entrada y $25 por cada millón de tokens de salida, al tiempo que admite una ventana de contexto de un millón de tokens y hasta 128 000 tokens de salida en la API sincrónica de mensajes. No es la mejor opción automática para chats sencillos, resúmenes breves o solicitudes de gran volumen y bajo valor.
El argumento más sólido es de carácter práctico, más que teatral: Opus 5 combina un amplio margen de razonamiento con unos costes más asequibles que los del nivel de vanguardia del Anthropic. En nuestra única prueba de depuración, detectó el error exacto de coincidencia de prefijos, propuso el parche más pequeño, añadió una prueba de regresión específica y proporcionó un comando de verificación que superó la prueba localmente. Se trata de una prueba útil para esta tarea, pero no es una garantía de que el modelo vaya a tener éxito en todos los trabajos de programación.
Lo mejor para: agentes de programación, análisis de contexto amplio, automatización empresarial y equipos cuyos costosos fallos justifican un modelo de prima. No lo hagas cuando: La rapidez y el coste unitario son más importantes que el último tramo del razonamiento.
El Claude Opus 5 es el modelo premium de uso diario de Anthropic, diseñado para la codificación agentiva compleja y el trabajo empresarial. Anthropic lo anunció el 24 de julio de 2026, describiéndolo como un modelo bien pensado, proactivo y más eficiente que otros. Sustituyó al Claude Opus 4.8, se convirtió en el modelo predeterminado del Claude Max y pasó a ser el modelo más potente disponible en el Claude Pro.
Anthropic anunció el Claude Opus 5 el 24 de julio de 2026 y afirmó que estaba disponible ese mismo día.
La propuesta de este producto es inusual para un lanzamiento de Opus: no se presenta únicamente como un modelo de máxima inteligencia. Anthropic pretende que se utilice a diario, con un nivel de esfuerzo ajustable y un perfil de latencia moderado. Esto hace que resulte más fácil justificarlo para agentes de larga duración y tareas de producción complejas, mientras que las cargas de trabajo más sencillas pueden seguir derivándose a un modelo más rápido y económico.
El acceso depende de la vía de acceso. Los usuarios particulares pueden acceder a Opus 5 a través de los planes Claude que cumplan los requisitos; los desarrolladores pueden acceder a él a través de la API de Claude y de las plataformas en la nube compatibles. GlobalGPT también cuenta con una página de producto específica. Los lectores que deseen comparar los niveles de suscripción de Anthropic pueden utilizar el Comparación de los planes Free, Pro y Max de Claude antes de elegir una forma de pago.
Claude Opus 5: Precio, API y especificaciones clave
El funcionario Precio de la API Claude es $5 por cada millón de tokens de entrada y $25 por cada millón de tokens emitidos. Se trata de tarifas básicas de la API, no del precio de una suscripción de consumo Claude ni de un plan de plataforma de terceros. El almacenamiento en caché de respuestas y el procesamiento por lotes tienen tarifas distintas, por lo que conviene comparar el patrón completo de solicitudes en lugar de limitarse a multiplicar el precio de entrada indicado.
Campo
Claude Opus 5
Qué significa
ID de API Claude
claude-opus-5
Utiliza este valor exacto del modelo en las solicitudes oficiales de la API Claude.
Precio de entrada base
$5 / MTok
Tasa estándar de tokens de entrada antes de aplicar los descuentos por almacenamiento en caché o por lotes.
Precio de salida de referencia
$25 / MTok
Los agentes que generan un gran volumen de datos pueden resultar caros en poco tiempo.
Ventana de contexto
1 millón de tokens
Adecuado para grandes repositorios y colecciones de documentos, en función de la calidad de las solicitudes y de la estrategia de recuperación.
Potencia máxima
128K fichas
Se aplica a la API de mensajes síncronos; los lotes de mensajes cuentan con una versión beta independiente con un límite de hasta 300 000.
Umbral de fiabilidad del conocimiento
Mayo de 2026
Es una técnica relativamente reciente según los estándares actuales, pero no sustituye a la recuperación en directo.
Latencia comparativa
Moderado
No es el modelo más rápido de Anthropic; la latencia sigue variando en función del esfuerzo, las herramientas y la carga de trabajo.
La plataforma Claude identifica «claude-opus-5» como el ID y el alias actuales de la API de Opus 5.La plataforma Claude muestra que Opus 5 tiene un valor de $5/$25 por cada millón de tokens de entrada/salida, con una ventana de contexto de 1 millón de tokens, una salida máxima de 128 000 tokens y fechas límite en mayo de 2026.La plataforma Claude indica una ventana de contexto de 1M, una salida máxima de 128k y fechas límite en mayo de 2026.
Para el acceso de los consumidores, Anthropic en comparación con Claude Pro a $20 mes a mes o $17 al mes cuando $200 se factura anualmente; Claude Max comienza en $100 al mes. Según Anthropic, Opus 5 es el modelo más potente en Pro y el predeterminado en Max, pero las cuotas de los planes y las características del producto son independientes del uso medido de la API.
Si necesitas un desglose más detallado de los costes, el Planes de IA de Claude y guía de precios de la API distingue entre las suscripciones de los usuarios, la facturación de la API y los límites de uso. Esa distinción es importante: “incluido en un plan” no significa que las llamadas a la API sean ilimitadas, y una tarifa de API no indica cuánto acceso al chat para usuarios tienes.
Claude Opus 5: Resultados de las pruebas de rendimiento
Límite importante: Las cifras que aparecen a continuación son pruebas de rendimiento publicadas por Anthropic, y no son mediciones independientes realizadas para esta reseña. Resultan útiles para comprender el posicionamiento previsto de Anthropic en cuanto a rendimiento y coste, pero no garantizan el mismo resultado con tus indicaciones, herramientas, repositorio o presupuesto de latencia.
Evaluación
La reivindicación publicada de Anthropic
Cómo leerlo
Frontier-Bench v0.1
Opus 5 supera con creces el rendimiento de Opus 4.8 a un coste por tarea inferior.
Una señal general del rendimiento de los agentes, no una mejora universal del doble.
CursorBench 3.2
A pleno rendimiento, Opus 5 se sitúa a 0,51 TP40T de la puntuación máxima de Fable 5, con la mitad del coste por tarea.
Excelentes resultados económicos para los agentes de codificación en el escenario de esfuerzo probado de Anthropic.
Zapier AutomationBench
Aproximadamente 1,5 veces la tasa de aprobación del siguiente mejor resultado, con el mismo coste por tarea.
Es prometedor para la automatización integral de los procesos empresariales; el diseño de los flujos de trabajo sigue siendo importante.
OSWorld 2.0
Supera el mejor resultado de Fable 5 a poco más de un tercio del coste.
En esta prueba de rendimiento, se observa una eficiencia en el uso del ordenador muy satisfactoria.
Según Anthropic, Opus 5 se sitúa a tan solo 0,51 TP40T de la puntuación máxima obtenida por Fable 5 en CursorBench 3.2, con la mitad del coste por tarea.Anthropic destaca una ventaja de 1,5 veces en la tasa de superación de pruebas en Zapier AutomationBench y una ventaja en cuanto a costes en OSWorld 2.0.
El esfuerzo forma parte del resultado. Anthropic indica que Opus 5 utiliza por defecto un nivel de esfuerzo alto en la API Claude y en el código Claude, mientras que sus comparativas también emplean ajustes altos, «xhigh» o máximos. Un mayor esfuerzo puede mejorar el éxito en tareas difíciles, al tiempo que aumenta el número de tokens, la latencia o ambos. Por lo tanto, el coste por tarea en las pruebas de rendimiento es más informativo que el precio por token por sí solo, pero ninguna de estas métricas sustituye a una prueba piloto con tu propia carga de trabajo.
Cómo hemos probado el Claude Opus 5
Llevamos a cabo una tarea compacta de depuración de causas raíz en un entorno de prueba CommonJS compuesto por tres archivos. La consigna exigía que el modelo identificara la causa raíz antes de realizar modificaciones, propusiera el parche más pequeño posible, añadiera una prueba de regresión específica, evitara cambios no relacionados y proporcionara el comando de verificación exacto.
A continuación, comprobamos el parche por nuestra cuenta, en lugar de dar por correcta la respuesta solo porque sonaba convincente. El comando local era node --test test/account-summary.test.cjs. Antes de la corrección, la suite daba un resultado satisfactorio y un fallo. Tras aplicar el parche de igualdad exacta, dio dos resultados satisfactorios y ningún fallo.
Este método nos aporta información útil sobre un flujo de trabajo de depuración: el diagnóstico, la disciplina en la aplicación de parches, la calidad de las pruebas de regresión y la verificabilidad. No mide el liderazgo general en materia de programación, la fiabilidad de los agentes a largo plazo, la velocidad ni el rendimiento en distintos lenguajes.
Claude Opus 5: Análisis práctico
Depuración de la causa raíz: correcta, mínima y verificable
En nuestra prueba, el Claude Opus 5 aisló correctamente el defecto en normalizedQuery.startsWith(account.id.toLowerCase()). Con la consulta ACCT-10, la comprobación del prefijo dio resultado cuenta-1 en primer lugar, pues Array.prototype.find devolvió la cuenta equivocada antes de llegar al ID exacto.
La corrección propuesta cambió la coincidencia de prefijos a igualdad exacta y añadió un caso de regresión para el texto rellenado, con mayúsculas y minúsculas mezcladas ACCT-10 entrada. No reescribió código que no tuviera relación con el tema. Esa moderación es importante en los repositorios reales, donde una “limpieza” excesivamente amplia puede generar más trabajo de revisión que el propio error original.
La parte más destacada fue el ciclo completo: identificar la causa raíz, explicar por qué la prueba existente no la detectó, realizar el cambio más pequeño posible, añadir la prueba de regresión adecuada e indicar el comando para verificarlo. El resultado es coherente con el posicionamiento de Opus 5 como agente de programación, pero sigue siendo un único fixture. Para obtener una introducción más amplia al flujo de trabajo, consulta cómo utilizar Claude AI para codificar.
Preguntas completas de los ejercicios T1 a T4, respuestas y código que se puede copiar
T1: Depuración de la causa raíz
Aprobado: se ha detectado el error de coincidencia de prefijos, se ha propuesto el parche más pequeño y se ha añadido una prueba de regresión específica.
Se identificó la coincidencia de prefijos como el defecto; se explicó por qué la prueba anterior no lo había detectado; se propuso una prueba de regresión basada en la igualdad exacta más uno.
Ver la pregunta y la respuesta completas de la prueba T1
Texto completo de la indicación
Estás depurando un fixture CommonJS deliberadamente pequeño. Trabaja únicamente a partir de los tres archivos que se indican a continuación y de la reproducción descrita.
Requisitos:
1. Indica la causa raíz antes de proponer cualquier modificación.
2. Propón el parche más pequeño que corrija el error.
3. Añade una prueba de regresión específica que falle antes de la corrección y pase después de ella.
4. Indica el comando de verificación exacto que hay que ejecutar desde la raíz del fixture.
5. No reescribas código que no esté relacionado. No renombres archivos, no añadas dependencias ni modifiques la API pública.
6. Incluye exactamente estas secciones en este orden: `CAUSA FUNDAMENTAL`, `PARCHE`, `VERIFICACIÓN`, `LIMITACIONES`.
7. En `PARCHE`, proporciona un diff unificado en un bloque `diff` delimitado. En `VERIFICACIÓN`, proporciona un comando en un bloque `text` delimitado.
Reproducción: `summarizeAccount(accounts, 'ACCT-10')` debería devolver `{ id: 'acct-10', name: 'Nimbus', seats: 24 }`, pero devuelve la cuenta `acct-1`.
Archivo: `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 };
```
Archivo: `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 };
```
Archivo: `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 cuentas = [
{ id: 'acct-1', nombre: 'Atlas', plazas: 5 },
{ id: 'acct-10', nombre: 'Nimbus', plazas: 24 },
];
test('resume un ID de cuenta exacto', () => {
assert.deepEqual(summarizeAccount(accounts, 'acct-1'), {
id: 'acct-1',
name: 'Atlas',
seats: 5,
});
});
```
Claude Opus 5
CAUSA FUNDAMENTAL
findAccount busca coincidencias por prefijo, no por igualdad:
Array.prototype.find devuelve el primer elemento que cumple el predicado. Para ‘ACCT-10‘, la consulta normalizada es ‘acct-10’, y el ID de la primera cuenta, ‘acct-1’, es un prefijo de esta, por lo que startsWith es verdadero y «acct-1» interrumpe la búsqueda antes de que se compruebe «acct-10». La normalización mediante `trim().toLowerCase()` es correcta: los espacios en blanco y las mayúsculas y minúsculas no son el problema. La función `summarizeAccount` es una función de paso y no tiene la culpa. La prueba actual no puede detectar esto: ‘acct-1’ es un prefijo de sí mismo y es el primer elemento, por lo que, para esa entrada, la coincidencia de prefijo y la coincidencia exacta son indistinguibles.
PARCHE
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('resume un ID de cuenta exacto', () => {
seats: 5,
});
});
+
+test('coincide con el ID completo en lugar de con un prefijo, con relleno y mayúsculas y minúsculas mezcladas', () => {
+ assert.deepEqual(summarizeAccount(accounts, ' ACCT-10 '), {
+ id: 'acct-10',
+ name: 'Nimbus',
+ seats: 24,
+ });
+});
Antes de la corrección, la nueva prueba falla con el objeto «acct-1 / Atlas / 5»; tras la corrección, la prueba se supera.
VERIFICACIÓN
texto
1node --test test/account-summary.test.cjs
node --test test/account-summary.test.cjs
LIMITACIONES
• Alcance: se ha modificado un operador. No hay cambios de nombre ni nuevas dependencias, y las firmas y los tipos de los valores devueltos de `findAccount` y `summarizeAccount` no han variado. • Comportamiento preexistente que no se ha modificado (queda fuera del alcance de este error): • Un `requestedId` que no sea una cadena (nulo o un número) sigue provocando un error al llamar a `.trim()`. • Los ID de cuenta no se recortan, por lo que un valor almacenado como ‘acct-10’ seguirá sin coincidir; solo se normaliza la consulta. • La función «toLowerCase()» se utiliza tal cual; no se aplica ninguna normalización Unicode ni ningún tipo de adaptación a la configuración regional. • Los identificadores duplicados siguen resolviéndose con la primera coincidencia, y la búsqueda sigue siendo de complejidad O(n). • Cobertura de la prueba: la única prueba de regresión se centra exclusivamente en la reproducción del error notificado. La ruta no encontrada (nula) y la entrada mal formada siguen sin someterse a prueba.
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: Análisis del estado de la cuenta
Parcial: se han calculado las métricas principales y se han priorizado las acciones, pero la respuesta registrada no incluye el marcador «Recheck» solicitado.
Se ha calculado un MRR en riesgo de $34 800 (94,31%); se ha escalado el caso E-505 y se han priorizado las acciones de seguimiento; la respuesta se ha cerrado sin el marcador de «revisión» solicitado.
Ver la pregunta y la respuesta completas de la T2
Texto completo de la indicación
Analiza el archivo `account-health.csv` proporcionado como un conjunto de datos cerrado. No utilices datos externos ni inventes los valores que falten.
Reglas de riesgo (evalúa cada una de forma independiente):
- `inactividad`: `días_desde_el_inicio_de_sesión >= 30`
- `pago`: `pagos_fallidos >= 2`
- `baja_utilización`: `licencias_utilizadas / licencias_adquiridas = 80» mientras la cuenta está en riesgo.
- `salud_débil_sin_riesgo`: `puntuación_de_salud = 9` y `tickets_abiertos >= 3`.
Requisitos:
1. Calcula los indicadores de riesgo y los indicadores de contradicción activados para cada cuenta.
2. Presenta los totales del conjunto de datos correspondientes a cuentas, MRR, cuentas en riesgo, MRR en riesgo, cuentas que requieren escalado, filas de contradicción, licencias adquiridas y licencias utilizadas.
3. Elabora una tabla de acciones con exactamente cinco columnas: `Cuenta | Indicadores de riesgo | Contradicciones | Prioridad | Acción recomendada`.
4. Coloca los valores calculados directamente bajo el encabezado «Datos medidos» y las decisiones discrecionales bajo el encabezado «Inferencia».
5. En «Revisión», muestra los cálculos aritméticos suficientes para poder volver a comprobar de forma independiente cada total y cada umbral, incluido el caso de igualdad con 0,50.
6. No corrijas ni reinterpretes las reglas de forma implícita. Si una señal parece contraria a la intuición, regístrala como una contradicción en lugar de cambiar su clasificación.
`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, 3600, 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
Datos contrastados
Fuente: account-health.csv, 6 filas, consideradas cerradas. No se han imputado valores.
Evaluación de reglas por cuenta
Cuenta días ≥ 30 fallos ≥ 2 util <0,50 Recuento de riesgos Estado A-101 Aster ✅ 45 ❌ 0 ❌ 0,82 1 en situación de riesgo Baliza B-202 ❌ 4 ✅ 2 ❌ 0,90 1 en situación de riesgo C-303 Ceniza ❌ 12 ❌ 0 ✅ 0,40 1 en situación de riesgo D-404 Dalia ❌ 5 ❌ 0 ❌ 0,80 0 sin riesgo E-505 Ember ✅ 65 ✅ 3 ✅ 0,35 3 en situación de riesgo + escalar F-606 Fjord ❌ 29 ❌ 1 ❌ 0,50 0 sin riesgo Indicadores de contradicción por cuenta Cuenta salud_sólida_con_riesgo salud_débil_sin_riesgo promotor_con_entradas A-101 Aster ✅ (92 ≥ 80, en situación de riesgo) ❌ ❌ (NPS 9 ✓, entradas 1 ✗) Baliza B-202 ❌ (70 < 80) ❌ (70 ≥ 50) ❌ (NPS 7) C-303 Ceniza ❌ (65 < 80) ❌ (65 ≥ 50) ✅ (NPS 10, entradas 4) D-404 Dalia ❌ ✅ (42 < 50, sin riesgo) ❌ (NPS 6) E-505 Ember ❌ (35 < 80) ❌ (35 < 50, pero se encuentra en grupo de riesgo) ❌ (NPS 3) F-606 Fjord ❌ (85 ≥ 80, pero sin riesgo) ❌ (85 ≥ 50) ✅ (NPS 9, entradas 3) Totales del conjunto de datos Métrico Valor Cuentas 6 MRR total $36,900 Cuentas en situación de riesgo 4 (A-101, B-202, C-303, E-505) MRR en situación de riesgo $34 800 (94,31% del total) Elevar el nivel de las cuentas 1 (E-505) Líneas de contradicción 4 (A-101, C-303, D-404, F-606) Indicadores de contradicción 4 (1 «salud_buena_con_riesgo», 1 «salud_débil_sin_riesgo», 2 «promotor_con_carga_de_entradas») Asientos comprados 349 Asientos utilizados 184 Inferencia El orden de prioridad y las medidas recomendadas que figuran a continuación son decisiones discrecionales, no resultados de una aplicación mecánica de reglas. Mi sistema de ponderación da prioridad primero al estado de la cuenta, luego a los ingresos recurrentes mensuales (MRR) en riesgo y, por último, a las señales de contradicción. Cuenta Factores desencadenantes de riesgo Contradicciones Prioridad Medida recomendada E-505 Ember inactividad, pago, baja utilización - P0 Las tres reglas se activan en la cuenta más grande ($15 000 MRR). Tratar como baja activa: recuperar el método de pago y, a continuación, realizar una revisión ejecutiva de las 130 licencias no utilizadas. A-101 Aster inactividad salud_sólida_con_riesgo P1 $: 12 000 MRR con 45 días de inactividad, a pesar de una puntuación de 92 y un uso saludable de 82%. Comprueba si la interrupción en el inicio de sesión se debe a una pérdida real de interés o a un error de seguimiento (SSO, uso exclusivo de API) antes de tomar medidas en función de la puntuación. C-303 Ceniza baja_utilización promotor_con_entradas P1 Promotor (nps 10) con 4 tickets abiertos y una utilización del 40%. La carga de tickets es el posible obstáculo para la adopción; despeja la cola y, a continuación, impulsa la activación de los asientos. Baliza B-202 pago - P2 Caso claro con una única causa: 2 pagos fallidos, con un historial de inicio de sesión de 4 días y una utilización de 90%. Solo es necesario realizar un seguimiento de la facturación; no se requiere intervención del servicio de atención al cliente. F-606 Fjord - promotor_con_entradas P3 Se encuentra justo dentro de todos los límites (29 días, 1 pago fallido, un índice de utilización de exactamente 0,50). Según las normas, no está en situación de riesgo, pero un día más sin actividad o un pago fallido más cambiarían la situación. Vigila la situación y resuelve las tres incidencias. D-404 Dalia - salud_débil_sin_riesgo P3 Puntuación de 42 sin que se haya activado ninguna regla y con una utilización de 80% en un MRR de $900. O bien
Datos medidos
Fuente: account-health.csv, 6 filas, consideradas cerradas. No se han imputado valores.
Evaluación de reglas por cuenta
Cuenta
días ≥ 30
fallos ≥ 2
util < 0,50
Recuento de riesgos
Estado
A-101 Aster
✅ 45
❌ 0
❌ 0,82
1
en riesgo
B-202 Beacon
❌ 4
✅ 2
❌ 0,90
1
en riesgo
C-303 Cinder
❌ 12
❌ 0
✅ 0,40
1
en riesgo
D-404 Dahlia
❌ 5
❌ 0
❌ 0,80
0
sin riesgo
E-505 Ember
✅ 65
✅ 3
✅ 0,35
3
en riesgo + escalar
F-606 Fjord
❌ 29
❌ 1
❌ 0,50
0
sin riesgo
Indicadores de contradicción por cuenta
Cuenta
salud_sólida_con_riesgo
salud_débil_sin_riesgo
promotor_con_carga_de_tickets
A-101 Aster
✅ (92 ≥ 80, en riesgo)
❌
❌ (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, no en riesgo)
❌ (nps 6)
E-505 Ember
❌ (35 < 80)
❌ (35 < 50, pero en riesgo)
❌ (NPS 3)
F-606 Fjord
❌ (85 ≥ 80, pero no en riesgo)
❌ (85 ≥ 50)
✅ (NPS 9, tickets 3)
Totales del conjunto de datos
Métrica
Valor
Cuentas
6
MRR total
$36 900
Cuentas en riesgo
4 (A-101, B-202, C-303, E-505)
MRR en riesgo
$34 800 (94,31% del total)
Cuentas que requieren escalado
1 (E-505)
Filas con contradicciones
4 (A-101, C-303, D-404, F-606)
Indicadores de contradicción
4 (1 «salud_sólida_con_riesgo», 1 «salud_débil_sin_riesgo», 2 «promotor_con_carga_de_entradas»)
Asientos comprados
349
Asientos utilizados
184
Conclusión
El orden de prioridad y las acciones recomendadas que se indican a continuación son decisiones discrecionales, no resultados de reglas. Mi sistema de ponderación de clasificación da prioridad primero al estado de escalada, luego al MRR en riesgo y, por último, a las señales de contradicción.
Cuenta
Desencadenantes de riesgo
Contradicciones
Prioridad
Acción recomendada
E-505 Ember
inactividad, pago, baja_utilización
—
P0
Las tres reglas se activan en la cuenta más grande ($15 000 MRR). Tratar como pérdida activa: recuperar el método de pago y, a continuación, realizar una revisión ejecutiva de las 130 plazas no utilizadas.
A-101 Aster
inactividad
salud_sólida_con_riesgo
P1
$12 000 MRR con 45 días de inactividad a pesar de una puntuación de 92 y una utilización saludable de 82%. Verificar si el intervalo sin inicio de sesión se debe a una pérdida real de interés o a un error de seguimiento (SSO, uso exclusivo de API) antes de actuar en función de la puntuación.
C-303 Cinder
baja_utilización
promotor_con_carga_de_tickets
P1
Promotor (NPS 10) con 4 tickets abiertos y una utilización de 40%. La carga de tickets es el posible obstáculo para la adopción; resuelve la cola y, a continuación, impulsa la activación de la licencia.
B-202 Beacon
pago
—
P2
Caso claro de causa única: 2 pagos fallidos con un historial de inicio de sesión de 4 días y una utilización de 90%. Solo es necesario un seguimiento de facturación; no se requiere intervención del servicio de atención al cliente.
F-606 Fjord
—
promotor_con_carga_de_tickets
P3
Se encuentra justo dentro de todos los límites (29 días, 1 pago fallido, exactamente 0,50 de utilización). No está en riesgo según las reglas, pero un día más de inactividad o un pago fallido más cambiaría la situación. Supervisar y resolver los 3 tickets.
D-404 Dahlia
—
weak_health_without_risk
P3
Puntuación de 42 sin que se haya activado ninguna regla y con una utilización de 80% sobre un MRR de $900. O bien
T3: Generación de interfaces de usuario adaptativas
Parcial: generó una implementación completa e independiente, así como una comprobación automática, al tiempo que admitía explícitamente que había inspeccionado la página en lugar de renderizarla en tiempo de ejecución.
Elaboró una respuesta completa de 21 907 caracteres; abordó los aspectos relacionados con el escritorio, los dispositivos móviles, el desbordamiento y la accesibilidad; indicó explícitamente que el diseño se había inspeccionado, y no que se hubiera renderizado en tiempo de ejecución.
Ver la pregunta y la respuesta completas de la prueba T3
Texto completo de la indicación
Crea una interfaz elegante de comparación de productos en forma de un único archivo HTML ejecutable utilizando únicamente los datos de los productos que se indican a continuación.
Requisitos:
1. Devuelve exactamente un bloque de código `html` delimitado, seguido de una sección `SELF-CHECK`. No dividas el HTML, el CSS ni el JavaScript en archivos separados.
2. Utiliza únicamente HTML semántico, CSS incrustado y JavaScript "vanilla" incrustado: sin marcos de trabajo externos, paquetes, fuentes, imágenes, solicitudes de red ni pasos de compilación.
3. Proporciona tres pestañas accesibles mediante el teclado ("Overview", "Pricing", "Limits") con la semántica correcta de `tablist`, `tab` y `tabpanel`. Las teclas Flecha izquierda/Flecha derecha deben desplazar y activar las pestañas; las teclas Inicio/Fin deben saltar a la primera/última pestaña y activarlas. El foco debe permanecer visible.
4. La pestaña seleccionada debe reflejarse mediante `aria-selected`, `tabindex` y el panel visible; los paneles inactivos deben ocultarse.
5. Objetivo para ordenador de sobremesa: 1440 píxeles de ancho. Objetivo para móvil: 390 píxeles de ancho sin desbordamiento horizontal de la página, sin controles recortados, objetivos de toque de al menos 44 píxeles de altura y tarjetas de comparación apiladas en una columna.
6. Incluye un encabezado conciso, una recomendación clara, tres tarjetas de producto y una tabla de comparación compacta. Mantén un contraste legible y evita los movimientos decorativos.
7. Utiliza exactamente estos datos de los productos y no añadas afirmaciones:
- Atlas: `$19/mes`, `20 proyectos`, `10 GB`, `Asistencia por correo electrónico`, ideal para trabajar en solitario.
- Beacon: `$49/mes`, `Proyectos ilimitados`, `100 GB`, `Asistencia prioritaria`, la mejor opción general para equipos en crecimiento.
- Cove: `$99/mes`, `Proyectos ilimitados`, `1 TB`, `Asistencia dedicada`, ideal para operaciones reguladas.
8. Asigna a Beacon una etiqueta visible que indique "La mejor opción en general" sin que las demás tarjetas parezcan desactivadas.
9. En "SELF-CHECK", informa explícitamente de tus comprobaciones sobre pestañas semánticas, comportamiento del teclado, diseño de 1440 px, diseño de 390 px, desbordamiento horizontal y dependencias externas. No afirmes que has renderizado realmente una ventana de visualización a menos que lo hayas hecho; distingue entre la inspección del código y la verificación en tiempo de ejecución.
Configuración del producto (también almacenada como `fixtures/T3-responsive-ui/product-data.json`):
```json
{
"products": [
{"name":"Atlas","price":"$19/mes","projects":"20 proyectos","storage":"10 GB","support":"Asistencia por correo electrónico","bestFor":"trabajo individual"},
{"name":"Beacon","price":"$49/mes","projects":"Proyectos ilimitados","storage":"100 GB","support":"Asistencia prioritaria","bestFor":"equipos en crecimiento","badge":"Mejor en general"},
{"name":"Cove","price":"$99/mes","projects":"Proyectos ilimitados","almacenamiento":"1 TB","asistencia":"Asistencia dedicada","idealPara":"operaciones reguladas"}
]
}
```
Todas las afirmaciones que figuran a continuación se basan únicamente en la inspección del código. No he abierto ningún navegador, ni he renderizado ninguna ventana gráfica, ni he ejecutado ningún lector de pantalla, ni he activado los controladores de teclado, por lo que nada de lo aquí expuesto ha sido verificado en tiempo de ejecución. Cuando una afirmación depende del comportamiento del motor de maquetación, así lo indico. Pestañas semánticas: revisadas y coherentes Un elemento div[role="tablist"] con aria-label="Vistas comparativas de planes" contiene tres botones [type="button"][role="tab"]. Cada pestaña tiene un identificador único y un atributo `aria-controls` que apunta a una sección [role="tabpanel"]; cada panel lleva el atributo `aria-labelledby` que apunta a su pestaña correspondiente. He rastreado los tres pares manualmente: `tab-overview`/`panel-overview`, `tab-pricing`/`panel-pricing`, `tab-limits`/`panel-limits`. No hay identificadores duplicados ni referencias sueltas. Los paneles utilizan tabindex="0", por lo que se puede acceder al cuerpo del panel tras pulsar la pestaña. Comportamiento del teclado: inspeccionado, no ejecutado Un único oyente de keydown en la lista de pestañas gestiona las teclas de flecha derecha, flecha izquierda, Inicio y Fin, llama a event.preventDefault() solo para esas cuatro teclas y, en los demás casos, sale anticipadamente. Las teclas de flecha se desplazan hacia ambos extremos. Dado que la función `activate()` actualiza los atributos `aria-selected`, `tabindex` y `hidden` y, al mismo tiempo, desplaza el foco, las teclas de flecha y `Inicio`/`Fin` permiten desplazarse y activar el elemento en un solo paso, lo que se ajusta al patrón de activación automática que exige el requisito. El desplazamiento con Tab/Shift+Tab se basa en un "tabindex" variable: exactamente una pestaña tiene tabindex="0", el resto -1, lo cual se mantiene mediante activate(). La visibilidad del foco proviene de una regla global :focus-visible con un contorno de 3 píxeles y un desplazamiento de 2 píxeles; no he sobrescrito ni eliminado ningún contorno predeterminado. No he comprobado el funcionamiento de las teclas en un navegador real. Reflexión en estado seleccionado — inspeccionada La función `activate()` establece las tres señales en el mismo bucle, por lo que `aria-selected="true"`, `tabindex="0"` y la ausencia del atributo `hidden` no pueden desalinearse. Los paneles inactivos reciben el atributo «hidden», y [hidden] { display: none !important; } evita que las reglas de visualización lo anulen —esa protección es importante porque los paneles contienen elementos hijos con «display: grid». activate(currentIndex(), false) se ejecuta al cargarse la página para normalizar el estado a partir del marcado sin robar el foco. Si JavaScript no se ejecuta, el código de marcado se carga con «Overview» seleccionado y los otros dos paneles ocultos, de modo que la página se reduce a un único panel legible. Diseño de 1440 píxeles: revisado, pero no renderizado .wrap tiene un ancho máximo de 1120px con un margen de 0 auto, por lo que a 1440px el contenido se centra con espacios laterales de unos 160px en lugar de estirarse. Las tarjetas utilizan `grid-template-columns: repeat(3, minmax(0, 1fr))` con un espacio de 20px, lo que da lugar a tres columnas iguales; `align-items: start` evita que las tarjetas se estiren hasta alcanzar una altura compartida, mientras que `.card { height: 100% }` queda neutralizado por ello. El uso de `minmax(0, 1fr)` es deliberado: `1fr` por sí solo puede negarse a reducirse por debajo del ancho del contenido y hacer que la cuadrícula se ensanche. No he medido el resultado real en píxeles. Diseño de 390 píxeles: revisado, pero no renderizado El bloque con "max-width: 720px" cambia la cuadrícula de las tarjetas a "minmax(0, 1fr)", es decir, una sola columna, por lo que las tarjetas se apilan. El relleno se reduce a 16px por cada lado, lo que deja unos 358px de ancho para el contenido. Elementos de selección al pulsar: cada [role="tab"] tiene «min-height: 44px», y el relleno horizontal se reduce a 12px en lugar de que se reduzca la altura, por lo que la altura mínima de 44px se mantiene en anchos reducidos. La lista de pestañas pasa a tener flex-wrap: nowrap con overflow-x: auto y flex: 1 0 auto para los elementos hijos, de modo que las tres pestañas caben o se desplazan dentro de la propia lista de pestañas, en lugar de recortarse o ajustarse a mitad del control. está presente. No se ha verificado en una ventana gráfica real de 390px. Desbordamiento horizontal: revisado; un desplazamiento intencionado y contenido body { overflow-x: hidden } es la medida de seguridad, pero también he intentado no depender de ella. * { box-sizing: border-box } mantiene el relleno dentro de los anchos declarados. Las tablas comparativas utilizan white-space: nowrap en las celdas, por lo que la tabla "Overview" de seis columnas superará los 358 px en dispositivos móviles; esto se controla mediante .table-scroll { max-width: 100%; overflow-x: auto }, que hace que se desplace la región de la tabla en lugar de la página. Ese contenedor tiene `tabindex="0"` y `role="region"` con una etiqueta para que los usuarios que utilizan el teclado puedan acceder a él y desplazarse por él. Los elementos hijos con Flex y Grid que, de otro modo, podrían negarse a reducirse, se gestionan con `minmax(0, 1fr)` en la cuadrícula y `flex-wrap: wrap` en `.card-head` y `.recommendation`. El único riesgo restante que no puedo descartar sin realizar una visualización es una cadena larga e ininterrumpida en una celda de la tabla, pero todos los valores de los datos de prueba son cortos. Dependencias externas: comprobadas, ninguna 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. Contraste y movimiento — comprobados El texto principal #16191f sobre #f6f7f9 y el secundario #4a515c sobre fondo blanco superan con creces la relación de 4,5:1; la insignia es blanca sobre #10457e, y la pestaña activa es #10457e sobre fondo blanco. He calculado estos valores estimando la relación a partir de los valores hexadecimales, no con una herramienta de contraste. No hay transiciones, animaciones ni transformaciones en ninguna parte; el bloque «prefers-reduced-motion» es una medida de seguridad inactiva, más que una solución para el movimiento existente. Fidelidad de los accesorios — inspeccionada Cada uno de los tres planes aparece en los tres paneles, además de en la tabla de cada uno de ellos. He cotejado todos los precios, el número de proyectos, las cifras de almacenamiento y los niveles de asistencia con el archivo JSON: Atlas. 19 / 20 𝑝 𝑟 𝑜 𝑗 𝑒 𝑐 𝑡 𝑠 / 10 𝐺 𝐵 / 𝐸 𝑚 𝑎 𝑖 𝑙 , 𝐵 𝑒 𝑎 𝑐 𝑜 𝑛 49/Ilimitado/100 GB/Prioritario, Cove $99/Ilimitado/1 TB/Dedicado. Beacon lleva la insignia "Mejor en general" y un borde decorativo de 2 píxeles; Atlas y Cove mantienen el texto con opacidad total, bordes normales y un tratamiento tipográfico idéntico, por lo que se interpretan como disponibles en lugar de desactivados. Las opciones «Mejor para» se representan como etiquetas breves («Mejor para trabajar en solitario»), con texto añadido alrededor del valor del producto, sin nuevas afirmaciones sobre el mismo. Lagunas conocidas No hay ningún tipo de verificación en tiempo de ejecución. El contenido de los paneles se duplica en los tres paneles como código estático, en lugar de generarse a partir del JSON, por lo que el fixture es la fuente de verdad por transcripción, no por enlace: cualquier cambio futuro en los datos implicará editar varios lugares.
```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: Autocomprobación
Aprobado: detectó el error de NaN en un array vacío durante su propia auditoría, lo revisó una vez y confirmó todos los casos proporcionados.
Se detectó el resultado «NaN» al tratar un array vacío en su propia auditoría; se revisó una vez para que devolviera «N/A» (0/0 superados); se confirmaron los cuatro casos proporcionados tras la revisión.
Ver la pregunta y la respuesta completas del T4
Texto completo de la indicación
Realiza esta tarea con restricciones numeradas y, a continuación, revísala y corrígelo una sola vez si es necesario.
Restricciones de la tarea:
1. Escribe una función de JavaScript sin formato llamada `summarizeChecks(checks)`; `checks` es un array de valores booleanos.
2. Para entradas no vacías, devuelve exactamente `% (/ aprobados)`, donde `rate` tiene un decimal y es el porcentaje de valores que son `true`. Ejemplo: `[true, true, false, true]` devuelve `75,0% (3/4 aprobados)`.
3. No modifiques la entrada.
4. No utilices `for`, `while`, `forEach`, `eval`, ninguna biblioteca externa ni una segunda función.
5. El cuerpo de la función puede contener como máximo tres sentencias. Una declaración con un inicializador cuenta como una sentencia.
6. Asigna la función a `globalThis.summarizeChecks` tras su declaración, de modo que un entorno de pruebas independiente pueda llamarla.
Formato de respuesta requerido:
- `PRIMERA RESPUESTA`: proporciona la solución inicial en un bloque `js` delimitado antes de realizar la auditoría.
- `AUDITORÍA`: comprueba la primera respuesta según las restricciones 1–6 y este caso límite oculto: una entrada vacía debe devolver exactamente `N/A (0/0 aprobado)`. Indica si se ha superado o fallado cada punto.
- Si algún elemento de la auditoría falla, revísalo una vez. No lo revises más de una vez.
- `RESPUESTA FINAL`: proporciona la solución final en un bloque `js` delimitado. Mantén todas las restricciones originales al tiempo que se cumple el caso límite de entrada vacía.
Utiliza estos casos de comprobación independiente en la auditoría:
```text
[] -> N/A (0/0 superado)
[true] -> 100,0% (1/1 superado)
[false] -> 0,0% (0/1 superado)
[true, true, false, true] -> 75,0% (3/4 superado)
```
# Restricción Resultado 1 Función simple denominada summarizeChecks(checks) PASS — declaración simple, un parámetro, sin envoltura de clase ni de flecha. 2 Formato % (/ aprobados), porcentaje con un decimal PASS para entradas no vacías: toFixed(1) fija el número de decimales y el espaciado literal se ajusta exactamente a la especificación. 3 Sin mutación en la entrada PASS — Tanto .length como .filter son de solo lectura; filter devuelve una nueva matriz. 4 No se permite el uso de «for», «while», «forEach», «eval», «library» ni la función «second» PASS — .filter es la única iteración; «Boolean» es una variable incorporada que se utiliza como referencia de predicado, no una función que yo haya definido. 5 Como máximo tres frases en el cuerpo del texto PASS — exactamente tres: dos declaraciones inicializadas más la instrucción «return». 6 Asignado a `globalThis.summarizeChecks` tras la declaración PASS — la asignación viene después de la declaración en el nivel superior. Casos de comprobación independiente: Entrada Previsto Real Resultado [] N/A (0/0 aprobados) NaN% (0/0 aprobados) FALLO [true] 100,01 TP40T (aprobado 1/1) 100,01 TP40T (aprobado 1/1) PASS [false] 0,01 TP40T (0/1 aprobado) 0,01 TP40T (0/1 aprobado) PASS [verdadero, verdadero, falso, verdadero] 75,01 TP40T (aprobado en un 3/4) 75,01 TP40T (aprobado en un 3/4) PASS Un error. Se ha pasado una entrada vacía / el total es 0 / 0, lo que da como resultado NaN; NaN.toFixed(1) devuelve la cadena "NaN" en lugar de lanzar una excepción, por lo que la función devuelve silenciosamente NaN% (se ha pasado 0/0). Se revisa una vez. La corrección se mantiene dentro del bloque «return» existente como una expresión condicional, por lo que el número de sentencias no varía. El signo «%» se desplaza al interior de la rama no vacía, ya que la salida vacía esperada es N/A (0/0 superada) sin signo de porcentaje.
Confirmación tras la revisión en los cuatro casos: [] → N/A (0/0 superados), [verdadero] → 100,0% (1/1 superado), [falso] → 0,0% (0/1 superado), [verdadero, verdadero, falso, verdadero] → 75,0% (3/4 aprobados). El cuerpo sigue constando de tres sentencias, la entrada no se ha modificado y no se ha introducido ninguna construcción prohibida.
PRIMERA RESPUESTA
```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;
```
AUDITORÍA
#
Restricción
Resultado
1
Función simple denominada summarizeChecks(checks)
APROBADO — declaración simple, un parámetro, sin envoltura de clase ni flecha.
2
Formato % (/ passed), tasa con un decimal
APROBADO para entradas no vacías: toFixed(1) fija el decimal, y el espaciado literal se ajusta exactamente a la especificación.
3
Sin modificación de la entrada
APROBADO — tanto .length como .filter son de solo lectura; filter devuelve una nueva matriz.
4
Sin for, while, forEach, eval, biblioteca ni segunda función
APROBADO — .filter es la única iteración; Boolean es un tipo integrado utilizado como referencia de predicado, no una función definida por mí.
5
Como máximo tres sentencias en el cuerpo
APROBADO — exactamente tres: dos declaraciones inicializadas más la instrucción return.
6
Asignado a globalThis.summarizeChecks tras la declaración
APROBADO — la asignación sigue a la declaración en el nivel superior.
Casos de comprobación independientes:
Entrada
Esperado
Real
Resultado
[]
N/A (0/0 superadas)
NaN% (0/0 superadas)
FALLO
[true]
100,0% (1/1 superadas)
100,0% (1/1 superadas)
APROBADO
[false]
0,0% (0/1 superadas)
0,0% (0/1 superadas)
APROBADO
[verdadero, verdadero, falso, verdadero]
75,0% (3/4 superadas)
75,0% (3/4 superadas)
APROBADO
Un fallo. En la entrada vacía, el número de pruebas superadas / total es 0 / 0, lo que es NaN; NaN.toFixed(1) devuelve la cadena "NaN" en lugar de lanzar una excepción, por lo que la función emite silenciosamente NaN% (0/0 superadas).
Revisión única. La corrección se mantiene dentro del retorno existente como una expresión condicional, por lo que el recuento de sentencias no cambia. El signo % se desplaza al interior de la rama no vacía, ya que la salida vacía esperada es N/A (0/0 superadas) sin signo de porcentaje.
RESPUESTA FINAL
```js
function summarizeChecks(checks) {
const total = checks.length;
const passed = checks.filter(Boolean).length;
return `${total === 0 ? 'N/A' : `${((aprobados / total) * 100).toFixed(1)}%`} (${aprobados}/${total} aprobados)`;
}
globalThis.summarizeChecks = summarizeChecks;
```
Confirmación tras la revisión en los cuatro casos: [] → N/A (0/0 superadas), [true] → 100,0% (1/1 superadas), [false] → 0,0% (0/1 aprobados), [true, true, false, true] → 75,0% (3/4 aprobados). El cuerpo sigue constando de tres sentencias, la entrada no ha sufrido cambios y no se ha introducido ninguna construcción prohibida.
Los equipos que elijan entre distintos proveedores deberían seguir evaluando su propio repositorio, su conjunto de herramientas y la carga que supone la revisión. El panorama más amplio Comparación entre Claude y ChatGPT en cuanto a la codificación ayuda a poner en perspectiva esas compensaciones más allá de este único resultado.
Claude Opus 5 frente a Opus 4.8 frente a Fable 5
La forma más clara de entender el Opus 5 es considerarlo el nuevo caballo de batalla de gama alta. El Opus 4.8 es su predecesor; el Fable 5 sigue siendo la referencia de vanguardia. Según los materiales de presentación del Anthropic, el Opus 5 mantiene el mismo coste base que el Opus 4.8, al tiempo que se acerca al Fable 5 en determinadas evaluaciones con un coste por tarea considerablemente inferior.
Modelo
Cargo
Relación calidad-precio
Mejor ajuste
Claude Opus 5
Modelo premium para el día a día; sucesor del Opus 4.8
$5/$25 por MTok de entrada/salida; sólidos resultados de coste por tarea publicados por Anthropic
Programación compleja, automatización y trabajo empresarial en el que la fiabilidad es fundamental
Claude Opus 4.8
Generación anterior de Opus
El mismo coste base que el Opus 5, según la comparación de lanzamiento de Anthropic
Flujos de trabajo fijados existentes que aún deben someterse a la validación de la migración
Claude Fable 5
Nivel de inteligencia de vanguardia
Punto de referencia máximo; según Anthropic, Opus 5 se acerca a CursorBench a la mitad del coste por tarea
Las tareas más difíciles cuando la capacidad máxima es más importante que la economía
Elige Opus 5 en lugar de Opus 4.8 cuando puedas realizar pruebas de regresión de la migración y desees el modelo más reciente sin aumentar la tarifa base de la API. Elige Fable 5 cuando tu propia evaluación demuestre que sus capacidades adicionales modifican el resultado lo suficiente como para justificar el sobrecoste. Para obtener un desglose actualizado a nivel de familia que también incluya Sonnet 5, utilice el Comparación entre Claude Opus 5, Fable 5 y Sonnet 5.
Reacciones de los desarrolladores y del sector
Las publicaciones en redes sociales ofrecen pistas útiles sobre el uso inicial, pero no son puntos de referencia neutrales. La cuenta oficial de Claude describió el Opus 5 como un dispositivo bien pensado y proactivo, similar a la tecnología de vanguardia del Fable 5, pero a la mitad de precio. Ese es el propio posicionamiento de lanzamiento del Anthropic, no una confirmación independiente.
Claude presentó Opus 5 en X como un modelo bien pensado y proactivo, situado a un nivel similar al de la inteligencia de Fable 5, pero a la mitad de precio.
JetBrains informó de que sus propias evaluaciones revelaron un 45%: mayor tasa de aprobados en Python en comparación con Opus 4.8, junto con un conocimiento más profundo del código fuente. Se trata de una observación concreta y relevante por parte de una empresa dedicada a las herramientas de desarrollo, pero el resultado forma parte de la evaluación de JetBrains y no debe generalizarse a todas las pruebas de rendimiento o repositorios de Python.
JetBrains afirma que su evaluación reveló una tasa de superación de las pruebas de Python un 45% superior a la de Opus 4.8, así como una comprensión más profunda del código fuente.
Harvey ha informado de mejoras significativas con respecto a Opus 4.8 en cuanto a calidad y eficiencia de los tokens en los flujos de trabajo jurídicos, incluidos el gobierno corporativo y el arbitraje. Esto resulta relevante para los compradores de tecnología jurídica, pero sigue siendo una valoración de Harvey sobre los flujos de trabajo de sus áreas de práctica, y no una prueba de precisión jurídica universal.
Harvey destaca las mejoras de Opus 5 en la calidad del trabajo jurídico y la eficiencia de los tokens, incluyendo el gobierno corporativo y el arbitraje.
En conjunto, estas publicaciones sugieren que los primeros usuarios están observando mejoras en la comprensión del código fuente y en el trabajo relacionado con los conocimientos específicos del ámbito. El siguiente paso responsable sigue siendo llevar a cabo una prueba piloto representativa con tus propias pruebas de aceptación, tu presupuesto de tokens y un proceso de revisión humana.
Claude Opus 5 API: ID del modelo, ejemplo y notas sobre la migración
Tanto el identificador oficial del modelo de la API Claude como su alias son claude-opus-5. A continuación se muestra un ejemplo mínimo API Antrópica Ejemplo de solicitud. Muestra únicamente el punto final oficial de «Messages»; no describe ni garantiza la implementación del 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": "Encuentra la causa raíz, propone el parche más pequeño y da una orden de verificación."
}
]
}'
Lista de comprobación para la migración
Cambia el valor del modelo a claude-opus-5, y a continuación vuelve a realizar tus propias evaluaciones de regresión y seguridad.
Presupuestar en función de la entrada $5 y la salida $25 por MTok; supervisar los bucles de agentes con gran volumen de salida y los reintentos de las herramientas.
No sigas con las viejas costumbres thinking.type: "enabled" configuración. Guía de reflexión de Anthropic afirma que ya se está trabajando en el Opus 5 y documenta los ajustes adaptativos.
Considera 128K como el límite máximo de salida de la API de mensajes síncronos. La versión beta independiente de «Message Batches» admite hasta 300K con el encabezado beta documentado de Anthropic.
Consulta los nombres de los modelos específicos de cada proveedor y el acceso a los documentos Anthropic. anthropic.claude-opus-5 para Amazon Bedrock y claude-opus-5 para Google Cloud.
Para los desarrolladores que deseen utilizar un flujo de trabajo de línea de comandos junto con Claude Code, la guía práctica de configuración es Cómo utilizar la CLI de GlobalGPT en el código de Claude. Mantén ese flujo de trabajo separado del ejemplo oficial de la API Anthropic que aparece más arriba, para que las credenciales, la facturación y el comportamiento del proveedor queden claros.
¿Merece la pena el Claude Opus 5?
Sí, cuando el fracaso sale caro y la carga de trabajo es realmente difícil. Opus 5 resulta especialmente útil cuando un mejor diagnóstico, el uso de herramientas o la capacidad de evaluar contextos más amplios pueden ahorrar tiempo a los ingenieros o analistas. La combinación de una ventana de contexto de 1 millón de tokens, un límite máximo de salida síncrona de 128 K y unas prometedoras estimaciones de coste por tarea le confiere una posición creíble como herramienta de trabajo de primera línea.
¿Quién debería utilizar el Claude Opus 5?
Equipos de ingeniería que ejecutan agentes de codificación en repositorios de gran tamaño.
Equipos de operaciones que automatizan tareas empresariales de varios pasos con criterios de aceptación cuantificables.
Equipos jurídicos, financieros o de investigación que puedan combinar el modelo con revisiones especializadas y fuentes en tiempo real.
Desarrolladores capaces de controlar los costes mediante el almacenamiento en caché, el procesamiento por lotes, el enrutamiento y las pruebas de regresión.
¿Quién debería optar por otra cosa?
Aplicaciones de gran volumen en las que predominan tareas sencillas de extracción, clasificación o reescritura de formularios abreviados.
Productos sensibles a la latencia en los que un modelo moderado resulta demasiado lento.
Equipos que carecen de conjuntos de evaluación, seguimiento de costes o un plan de revisión humana para los resultados importantes.
Los compradores que solo necesiten mantener conversaciones generales de vez en cuando y que no vayan a utilizar el contexto adicional ni las funciones de los agentes.
Los responsables de la adquisición de soluciones de programación también deberían comparar las opciones actuales antes de estandarizar el flujo de trabajo de un equipo; el Los mejores modelos de IA para la programación en 2026 sitúa la capacidad y el precio en un contexto más amplio.
Veredicto final: Merece la pena probar el Claude Opus 5 para tareas de programación rígida, automatización y trabajo intelectual, en las que un mejor resultado puede compensar los costes elevados de los tokens. Sus especificaciones oficiales son sólidas, los resultados de las pruebas de rendimiento del Anthropic son inusualmente eficientes en cuanto a costes, y nuestro resultado de depuración verificado fue preciso y riguroso. Cómpralo para trabajos complejos con resultados medibles, no porque todas las tareas necesiten un modelo de la clase Opus.
Claude Opus 5 Preguntas frecuentes
¿Cuánto cuesta el Claude Opus 5?
El precio base oficial de la API Claude es de $5 por cada millón de tokens de entrada y de $25 por cada millón de tokens de salida. Los planes Claude para particulares son independientes: el plan Pro cuesta $20 al mes o $17 al mes si se factura anualmente, mientras que el plan Max parte de $100 al mes.
¿Cómo puedo acceder a Claude Opus 5?
Según Anthropic, Opus 5 es el modelo predeterminado en Claude Max y el más potente en Claude Pro. Los desarrolladores pueden utilizar la API de Claude, mientras que entre las rutas en la nube compatibles se incluyen Amazon Bedrock y Google Cloud, con requisitos de acceso específicos de cada proveedor.
¿Cuál es el ID del modelo de la API Claude Opus 5?
Tanto el identificador oficial del modelo de la API Claude como su alias son «claude-opus-5». Utiliza ese valor exacto en el campo «model» de las solicitudes de la API de mensajes Anthropic y, a continuación, vuelve a ejecutar tus propias evaluaciones de regresión y seguridad antes de la migración a producción.
¿Cuáles son el contexto y los límites de salida de Claude Opus 5?
Claude Opus 5 tiene una ventana de contexto de 1 millón de tokens y una salida máxima de 128 000 tokens en la API sincrónica de mensajes. Anthropic especifica por separado una salida de hasta 300 000 tokens para lotes de mensajes con un encabezado beta.
¿Se han verificado de forma independiente los resultados de las pruebas de rendimiento de Claude Opus 5?
Las cifras de referencia aquí citadas han sido publicadas por Anthropic y no se han reproducido de forma independiente para esta reseña. Muestran el rendimiento y el coste de Anthropic según las pruebas realizadas, pero los compradores deben comprobar la calidad, la latencia, el uso de las herramientas y el coste total en sus propias cargas de trabajo.
¿Es el Claude Opus 5 mejor que el Opus 4.8 o el Fable 5?
Opus 5 es la versión más reciente que sustituye a Opus 4.8 con el mismo coste base, lo que lo convierte en la opción más lógica para la migración tras las pruebas de regresión. Fable 5 sigue siendo la referencia de vanguardia; elígelo solo cuando tu evaluación demuestre que sus capacidades adicionales justifican su mayor coste.
¿Está disponible la versión Claude Opus 5 en GlobalGPT?
Sí. GlobalGPT cuenta con una página específica de Claude Opus de 5 páginas. La disponibilidad puede depender del estado de la cuenta y de las condiciones de la plataforma, por lo que conviene confirmar el acceso antes de iniciar un flujo de trabajo urgente y mantener el acceso a la plataforma separado de la facturación oficial de la API de Anthropic.
¿Quién debería pagar el Claude Opus 5?
Opus 5 es la mejor opción para equipos que realizan tareas complejas de programación, automatización o trabajo intelectual de contexto prolongado, en las que una respuesta más precisa puede suponer un ahorro significativo de tiempo para los trabajadores. El trabajo más sencillo, de gran volumen o sensible a la latencia suele ser más adecuado para un modelo más económico y rápido.
Crea vídeos de YouTube sin rostro con Faceless Studio, desde la idea del canal hasta el control de calidad final. Descubre el flujo de trabajo real, los costes de los créditos y las normas de monetización.
Análisis de Meshy V7: consulta las primeras pruebas de conversión de imágenes a 3D, los resultados de Smart Topology, las conclusiones sobre la limpieza de mallas, los precios, la velocidad, la fiabilidad y los datos sobre el coste de las rutas alojadas.
Teléfono de gama alta Higgsfield frente a cámara: descubre qué puede mejorar la IA, qué aspectos siguen dependiendo del hardware de la cámara y cómo elegir el flujo de trabajo adecuado antes de realizar la compra.
Resumen rápido de DeepSeek V4.1 que abarca pruebas de rendimiento oficiales, precios de las API, compatibilidad con visión artificial, límites, cambios en el enrutamiento de la versión V4 Pro, pesos abiertos y rutas de acceso.
