Mide un asistente antes de cambiarlo

Unos 24 minutos de lectura, con 11 ejemplos en 11 secciones.

Edición 2026.11.3 Ejemplos verificados el 21 de nov de 2026 54 de 54 ejemplos pasan Qué ha cambiado

Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros

Traducido del libro en inglés, edición 2026.11.3. Lee el original

Al terminar este capítulo, podrás medir un asistente de documentación con un conjunto fijo de preguntas, leer el resultado junto con su intervalo y decir cuándo veinte preguntas son muy pocas para distinguir entre dos prompts.

El asistente de este libro responde preguntas sobre sablefile, una herramienta de línea de comandos que mantiene actualizados los archivos generados de un proyecto con respecto a las plantillas de las que proceden. Los usuarios preguntan cómo ejecutar un comando o qué hace una configuración, y el asistente responde a partir de la documentación de la herramienta, citando la sección en la que se basa cada afirmación. Supongamos que alguien del equipo quiere un prompt distinto. Lo prueba con tres preguntas, las respuestas parecen mejores y lo publica. Tres preguntas no bastan para saber si el cambio ayudó. Tampoco nadie puede decir cómo respondía el asistente antes del cambio, porque nada de eso quedó por escrito.

Así que lo primero que hay que construir es una medición: un conjunto de preguntas con las respuestas que deberían recibir, una forma de ejecutar el asistente sobre ellas de la misma manera cada vez, y un número que venga acompañado de su incertidumbre. Los cambios llegan después. Este capítulo construye la medición en su forma más sencilla y termina mostrando dónde deja de servir.

La herramienta y su documentación

Una evaluación solo es tan estable como aquello que mide. La documentación de sablefile llega en tres versiones, 1.0, 1.1 y 2.0, y en algunos puntos no coincide. Una respuesta correcta para una versión puede ser incorrecta para otra, así que cada pregunta debe indicar primero su versión antes de resolver cualquier otro aspecto.

Empieza por la documentación. Carga las tres versiones, cuenta las secciones de cada una y cuenta los identificadores de sección que las tres comparten.

list-the-docs.py Python 3.12.15 · numpy 2.5.5 Superado
"""Loads the three doc versions and prints each one's section count, and how many section IDs all three share.The shared IDs are the sections whose concept keeps one ID across versions (plan section 2.2)."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.docs import load_sections, versionssections = load_sections()  # every version, sorted by version and section IDall_versions = versions()  # the version labels present, sortedfor version in all_versions:    print(f"sections in version {version}: {sum(1 for s in sections if s.version == version)}")ids = {version: {s.section_id for s in sections if s.version == version} for version in all_versions}shared = set.intersection(*ids.values())  # IDs present in every versionprint(f"section IDs in all {len(all_versions)} versions: {len(shared)}")print(f"section IDs in 2.0 but in neither 1.0 nor 1.1: {len(ids['2.0'] - ids['1.0'] - ids['1.1'])}")
Salidapython list-the-docs.py
sections in version 1.0: 35
sections in version 1.1: 36
sections in version 2.0: 40
section IDs in all 3 versions: 35
section IDs in 2.0 but in neither 1.0 nor 1.1: 4

La salida abre con los recuentos de secciones: 35 en 1.0, 36 en 1.1 y 40 en 2.0.

La mayoría de las secciones conservan sus identificadores entre versiones, ya que 35 identificadores aparecen en las tres. La última línea es la más importante para lo que sigue. 4 identificadores existen solo en 2.0, así que un asistente que responda con las páginas antiguas no tiene nada que citar para ellos.

Las versiones también difieren en lo que hace la herramienta, y la diferencia que importa aquí está en sync, el comando que escribe los archivos generados. Las docs de la versión 1.1 dicen que sync sin opciones escribe los archivos y registra cada uno en sablefile.lock, el archivo de bloqueo en la raíz del proyecto. Las docs de la 2.0 dicen que sync sin opción muestra un plan y no escribe nada, que --apply escribe los archivos, y que el archivo de bloqueo está en .sablefile/lock.json. Una pregunta sobre sync tiene una respuesta correcta para la 1.1 y otra para la 2.0. Un asistente que lee la página de la versión equivocada suena seguro de sí mismo y se equivoca.

Este libro mide las respuestas. El ranking de recuperación, el trazado, el coste, la latencia, los ataques y los conjuntos de tareas de los agentes pertenecen a otros libros, que se nombran donde surgen.

Regla práctica: Escribe la versión en cada pregunta, y deja que las propias docs de esa versión sean la única fuente de su respuesta. Cuando dos versiones usan la misma redacción y dan respuestas distintas, conviértelas en dos elementos, uno para cada versión. Nunca dejes que la página de la versión más nueva sustituya a una anterior.

Los veinte ejemplos

Un conjunto de prueba es una lista de preguntas, cada una con la respuesta que debería obtener. Veinte elementos es deliberadamente poco. Puedes leer cada uno, comprobar su respuesta esperada contra la documentación y explicar por qué está ahí. Un conjunto que nadie lee no puede decirte qué mide.

Los elementos se dividen en cuatro tipos. Los elementos respondibles tienen su respuesta en la página. Los elementos sin respuesta preguntan por algo que la documentación no cubre, y la respuesta correcta es la negativa. Los elementos dependientes de la versión tienen una respuesta que cambia de una versión a otra, y varios de ellos tienen un gemelo: la misma pregunta planteada para otra versión. Los elementos ambiguos podrían significar dos cosas, y su respuesta de referencia cubre ambas lecturas.

Cada elemento se muestra en orden de ID, con su versión, tipo, gemelo y si fue sembrado o no.

twenty-questions.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 Superado
"""Prints the twenty chapter items in id order: version, kind, planted flag and question, then the counts by kind.The counts are the set's make-up that the chapter describes (plan section 3.4)."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom collections import Counterfrom lib.answers import chapter_itemsitems = chapter_items()  # sorted by idfor item in items:    twin = item.twin_of if item.twin_of else "none"    planted = f"planted ({item.planted_why})" if item.planted else "not planted"    print(f"{item.id} | version {item.version} | {item.kind} | {planted} | twin {twin} | {item.question}")kinds = Counter(item.kind for item in items)for kind in ("answerable", "unanswerable", "version-dependent", "ambiguous"):    print(f"items of kind {kind}: {kinds[kind]}")print(f"planted items: {sum(1 for item in items if item.planted)}")print(f"items in the dev split: {sum(1 for item in items if item.split == 'dev')}")
Salidapython twenty-questions.py
q-0001 | version 1.1 | version-dependent | not planted | twin q-0002 | In sablefile 1.1, if I run sync with no flags, are the target files written straight away?
q-0002 | version 2.0 | version-dependent | not planted | twin q-0001 | In sablefile 2.0, if I run sync with no flags, are the target files written?
q-0003 | version 1.0 | version-dependent | planted (version-swap) | twin q-0004 | In sablefile 1.0, is ${project} the right way to insert the project name into a template?
q-0004 | version 2.0 | version-dependent | not planted | twin q-0003 | In sablefile 2.0, is ${project} the right way to insert the project name into a template?
q-0005 | version 2.0 | answerable | planted (near-miss-term) | twin none | Does sablefile 2.0 still read sablefile.lock in my project root?
q-0006 | version 2.0 | answerable | not planted | twin none | Is there a way to make check exit with status 0 even when a file has drifted in 2.0?
q-0007 | version 1.1 | answerable | not planted | twin none | In 1.1, will an ignore entry of docs/**/*.tmp catch a file two folders down, like docs/x/y/a.tmp?
q-0008 | version 2.0 | answerable | not planted | twin none | In 2.0, is there a way to re-include something that an earlier ignore line had excluded?
q-0009 | version 1.0 | answerable | not planted | twin none | What does one line of the 1.0 lock file hold?
q-0010 | version 2.0 | answerable | not planted | twin none | Will syncing the same content twice in 2.0 produce a different lock file each time?
q-0011 | version 1.1 | answerable | not planted | twin none | How many times does 1.1 retry a remote template fetch that keeps failing, and can a flag change that?
q-0012 | version 2.0 | answerable | not planted | twin none | I want sync to retry a slow remote template only twice in 2.0. What do I pass?
q-0013 | version 1.0 | answerable | not planted | twin none | In 1.0, which table in sablefile.toml holds the values a placeholder can name?
q-0014 | version 1.1 | answerable | not planted | twin none | What does sablefile init put into a new sablefile.toml in 1.1?
q-0015 | version 1.0 | unanswerable | planted (false-premise) | twin none | In sablefile 1.0, what does the --dry-run flag on sync print?
q-0016 | version 2.0 | unanswerable | not planted | twin none | Does sablefile 2.0 run on Windows?
q-0017 | version 2.0 | unanswerable | not planted | twin none | How fast is sablefile check on a project with several thousand generated files?
q-0018 | version 1.1 | unanswerable | not planted | twin none | Can sablefile 1.1 fetch a remote template from a private URL that needs a login token?
q-0019 | version 2.0 | ambiguous | planted (ambiguous-target) | twin none | If I edit the file and then run check, will it fail?
q-0020 | version 2.0 | ambiguous | not planted | twin none | Does sync change the lock file?
items of kind answerable: 10
items of kind unanswerable: 4
items of kind version-dependent: 4
items of kind ambiguous: 2
planted items: 4
items in the dev split: 20

Las últimas líneas muestran la composición del conjunto por tipo, y los elementos respondibles son el grupo más numeroso. 4 elementos están sembrados. Un elemento sembrado se escribió para detectar un error concreto, y el conjunto lo etiqueta, de modo que un fallo en ese elemento puede interpretarse según su trampa.

Cada trampa es sencilla. q-0003 pregunta si ${project} es el marcador de posición correcto en 1.0, donde la sintaxis es {{project}}. Su gemelo, q-0004, pregunta lo mismo sobre 2.0, donde ${project} es el correcto. q-0005 pregunta si 2.0 sigue leyendo sablefile.lock en la raíz del proyecto, que usa el nombre de archivo de 1.x en una versión donde ese nombre solo importa para la migración. q-0015 pregunta qué hace la marca --dry-run en 1.0, y la documentación de 1.0 no nombra ninguna marca así. q-0019 pregunta si un archivo falla una comprobación después de editarlo, sin decir qué archivo, así que tiene dos lecturas posibles.

Regla práctica: Escribe cada elemento con su versión, su tipo y su respuesta esperada antes de ejecutar el asistente, y etiqueta cualquier elemento escrito para detectar un error concreto. Mantén el conjunto lo bastante pequeño como para leerlo de una sentada, y nunca cambies una respuesta esperada para que encaje con lo que dijo el asistente.

Recuperar y luego responder

El asistente no lee toda la documentación para cada pregunta. Para cada pregunta toma las tres secciones con más probabilidad de contener la respuesta, del índice de la versión que la pregunta menciona, y responde solo con esas tres. Una respuesta incorrecta puede tener, por tanto, dos orígenes: que nunca se recuperó la sección correcta, o que el modelo interpretó mal la sección que recibió. Una medición que no distinga entre ambos casos no puede indicar qué hay que corregir.

El índice se construye con BM25, que puntúa cada sección según las palabras que comparte con la pregunta. La puntuación se calcula con bm25s en 0.3.16. Tomemos una pregunta: si una entrada de ignorar como docs/**/*.tmp atrapa un archivo dos carpetas más abajo en 1.1. La salida muestra las palabras que el índice conserva de la pregunta y las tres secciones principales, ordenadas por puntuación y luego por ID de sección.

retrieve-top-sections.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 Superado
"""Shows BM25 retrieval for one question (q-0007, version 1.1): the words kept, then the top three sections.The sections come from the version's own index, ranked by score and then by section ID, so a tie has one order.The tokeniser drops one-letter words, so the `3` of `3.5mm` is lost and only `5mm` is matched."""import lib  # first: fixes the thread counts and seeds before anything else loadsimport bm25sfrom lib.docs import load_sectionsfrom lib.retrieval import Retrieverfrom lib.testset import load_itemsitem = next(item for item in load_items() if item.id == "q-0007")print(f"question {item.id} (version {item.version}): {item.question}")# The words the index actually matches on: the same tokeniser, stopwords and token pattern as lib.retrieval.kept = bm25s.tokenize([item.question], stopwords="en", return_ids=False, show_progress=False)[0]print(f"words kept for matching: {' '.join(kept)}")dropped = bm25s.tokenize(["a 3.5mm jack"], stopwords="en", return_ids=False, show_progress=False)[0]print(f"words kept from the text 'a 3.5mm jack': {' '.join(dropped)}")hits = Retriever(load_sections(item.version)).retrieve(item.question, 3)  # top 3 of the version's indexfor rank, hit in enumerate(hits, start=1):    print(f"rank {rank}: {hit.section_id} | score {hit.score:.3f}")
Salidapython retrieve-top-sections.py
question q-0007 (version 1.1): In 1.1, will an ignore entry of docs/**/*.tmp catch a file two folders down, like docs/x/y/a.tmp?
words kept for matching: ignore entry docs tmp catch file two folders down like docs tmp
words kept from the text 'a 3.5mm jack': 5mm jack
rank 1: ignore-recursive | score 9.156
rank 2: sync-create-dirs | score 3.386
rank 3: ignore-syntax | score 3.348

Lee las dos líneas de palabras conservadas antes del ranking. El tokenizador descarta todo token de un solo carácter. El a de la pregunta desaparece, y también ambos 1 de 1.1, así que el número de versión nunca llega al índice. Eso no causa daño aquí, porque cada pregunta se busca solo en el índice de su propia versión. La misma regla elimina el 3 de 3.5mm: lo que queda de a 3.5mm jack es 5mm jack, así que una pregunta sobre un conector jack de 3.5 mm solo puede coincidir por 5mm. Ninguna de estas pérdidas genera un error, y la segunda cambia lo que el índice puede encontrar.

El ranking coloca ignore-recursive en primer lugar, la sección sobre entradas de ignorar recursivas, y las dos siguientes son la sección sobre creación de carpetas y la de sintaxis de ignorar. Los empates se resuelven por ID de sección, así que la misma pregunta da las mismas tres secciones en cada ejecución.

Regla práctica: Comprueba la recuperación antes de comprobar la respuesta. Para cada caso, registra las secciones que recibió el asistente junto con su respuesta. Una respuesta incorrecta que no incluye la sección correcta es un problema de recuperación, y una respuesta incorrecta que sí tenía la sección correcta es un problema del prompt o del modelo. Mantén las preguntas redactadas con sencillez, porque un tokenizador que descarta tokens de un carácter perderá una medida o un número de versión.

Reproducir las respuestas

La respuesta de un modelo a la misma pregunta puede cambiar según su entorno de ejecución, su configuración y el hardware sobre el que se ejecuta. Si cada medición vuelve a llamar al modelo, cada una mide algo ligeramente distinto, y un cambio en el número podría ser solo ruido. Por eso el libro registra cada respuesta una sola vez, a partir de un modelo abierto fijado, y reproduce el registro. Una reproducción devuelve siempre el mismo texto.

El registro es una carpeta de respuestas, una por elemento. Se hizo con una versión de 4 bits de Qwen3-4B-Instruct-2507, un modelo abierto fijado a un archivo y una revisión concretos, ejecutado con temperatura cero en una CPU. Contiene una respuesta para cada elemento del conjunto completo, y este capítulo lee veinte de ellas por su ID. Reproduce una de ellas: la respuesta a q-0006, que pregunta si check puede terminar con estado 0 cuando un archivo ha cambiado en 2.0.

replay-one-answer.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 Superado
"""Replays the recorded baseline reply to q-0006 and parses it: the sections it was given, the reply, its citations.Nothing is generated here: the reply is the recorded text, read back as the same string."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.answers import Assistant, chapter_itemsfrom lib.contract import format_problemsfrom lib.prompts import P1_SHA256, P1_SYSTEMassistant = Assistant("assistant-baseline", P1_SYSTEM, P1_SHA256)  # the prompt hash must match the manifestitem = next(item for item in chapter_items() if item.id == "q-0006")print(f"question {item.id} (version {item.version}, {item.kind}): {item.question}")for rank, section in enumerate(assistant.sections(item), start=1):  # the top 3, in rank order    print(f"section in context, rank {rank}: {section.section_id}")reply = assistant.reply(item)print("recorded reply:")print(reply.text)print(f"citations, in order: {' '.join(reply.citations)}")print(f"format problems: {', '.join(format_problems(reply, context_ids=assistant.context_ids(item), expect_decline=False)) or 'none'}")# A reply to an answerable item must answer and cite; this is the one fact the prose relies on here.assert reply.citations and not reply.declined, "q-0006 should be answered, with at least one citation"
Salidapython replay-one-answer.py
question q-0006 (version 2.0, answerable): Is there a way to make check exit with status 0 even when a file has drifted in 2.0?
section in context, rank 1: check-exit-status
section in context, rank 2: no-fail-flag
section in context, rank 3: quickstart-check
recorded reply:
Yes, there is a way to make `check` exit with status 0 even when a file has drifted in 2.0. Use the `--no-fail` flag with `sablefile check`. This flag ensures that the check exits with status 0 even when files have drifted, without changing which files are reported. [sec:no-fail-flag]
citations, in order: no-fail-flag
format problems: none

La salida enumera las tres secciones que recibió el asistente, en orden de rango, y luego imprime la respuesta exactamente como fue registrada. La respuesta dice que sí, y cita no-fail-flag, que estaba entre las tres. Comprueba la cita con esa lista. La respuesta cita una sección que se le dio, así que no salió de su contexto. Un assert exige además que la respuesta sea una contestación con al menos una cita, ya que una negativa en este elemento, que sí se puede responder, sería un error.

Para poner un modelo en vivo en lugar del registro, pasa live=True a Assistant. Eso carga el Qwen3-0.6B fijado en la CPU y responde a cada pregunta según se formula. Es un modelo más pequeño que la versión de 4B con la que se hizo el registro, así que sus respuestas en vivo, y cualquier tasa calculada a partir de ellas, serán distintas de las registradas. Este libro no cita respuestas en vivo. Sus cifras proceden del registro, así que puedes comprobar cada una contra un archivo.

Regla práctica: Reproduce el registro en cada comparación. Vuelve a registrar solo cuando hayan cambiado el modelo, el prompt o las secciones que ve el asistente, y anota en el registro qué cambió. Cada registro nombra su prompt mediante un hash, y el ejemplo comprueba ese hash frente al manifiesto del registro, de modo que un registro no puede hacer las veces de otro hecho con un prompt distinto.

Dos comprobaciones con código

Algunos errores no necesitan un juez. Una cita a una sección que no estaba en el prompt, o una negativa que además da una respuesta, puede detectarse leyendo el texto de la respuesta. Las comprobaciones en código no cuestan nada de ejecutar y dan siempre el mismo resultado, así que el libro ejecuta ambas antes de que cualquier modelo tenga que evaluar una respuesta.

Citas

El asistente debe citar cada afirmación con la forma de cita, un ID de sección entre corchetes, y solo puede citar los IDs que se le dieron. Una cita puede fallar de dos maneras. El ID puede no existir en absoluto, o puede existir en otra versión, que es el error que los ítems de intercambio de versión están diseñados para provocar. La comprobación marca como unknown-section cualquier cita a una sección que no estaba en el prompt, sea cual sea la forma en que falló. También marca una respuesta que no tiene ninguna cita.

La comprobación de citas y de formato se ejecuta sobre las veinte respuestas de referencia, y la salida cuenta cada tipo de fallo.

check-citations.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 Superado
"""Runs the citation and format checks on the baseline replies to the twenty chapter items, and counts each problem.A citation is a problem when its section was not in the item's prompt, which covers a section of another version."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.answers import Assistant, chapter_itemsfrom lib.contract import PROBLEMS, format_problems, parse_reply, section_ids_by_versionfrom lib.prompts import P1_SHA256, P1_SYSTEMfrom lib.stats import pctassistant = Assistant("assistant-baseline", P1_SYSTEM, P1_SHA256)items = chapter_items()counts = {name: 0 for name in PROBLEMS}  # items with each problem, by its fixed nameitems_with_problems = 0answered = 0answered_uncited = 0citations = 0citations_outside = 0  # cited IDs that were not in the item's promptfor item in items:    reply = assistant.reply(item)    problems = format_problems(reply, context_ids=assistant.context_ids(item), expect_decline=item.kind == "unanswerable")    items_with_problems += bool(problems)    for name in problems:        counts[name] += 1    if not reply.declined and reply.text:        answered += 1        answered_uncited += not reply.citations    citations += len(reply.citations)    citations_outside += sum(1 for cid in reply.citations if cid not in assistant.context_ids(item))assert citations_outside == 0, "every citation must point at a section that was in its item's prompt"# A zero rate shows nothing unless the check can fire: a 1.1 section cited for a 2.0 item must be flagged as unknown.planted_item = next(item for item in items if item.version == "2.0")planted = sorted(section_ids_by_version()["1.1"] - assistant.context_ids(planted_item))[0]planted_problems = format_problems(parse_reply(f"Yes. [sec:{planted}]"), context_ids=assistant.context_ids(planted_item), expect_decline=False)assert "unknown-section" in planted_problems, "the check must fire on a planted bad citation"print(f"items: {len(items)}")print(f"items with a format problem: {pct(items_with_problems, len(items))}")for name in sorted(counts):  # sorted by problem name    print(f"items with problem {name}: {counts[name]}")print(f"answered items: {answered}")print(f"answered items with no citation: {pct(answered_uncited, answered)}")print(f"citations: {citations}")print(f"citations to a section not in the prompt: {pct(citations_outside, citations)}")
Salidapython check-citations.py
items: 20
items with a format problem: 0.0% (0 of 20)
items with problem answered-declined-expected: 0
items with problem declined-with-text: 0
items with problem empty: 0
items with problem no-citation: 0
items with problem unknown-section: 0
answered items: 15
answered items with no citation: 0.0% (0 of 15)
citations: 16
citations to a section not in the prompt: 0.0% (0 of 16)

La referencia dio 16 citas en total, y cada una apunta a una sección que se le dio. La salida calcula las tasas a partir de ello: las citas a una sección fuera del prompt llegan a 0.0% (0 of 16), y los ítems respondidos sin ninguna cita llegan a 0.0% (0 of 15).

Regla práctica: Ejecuta la comprobación de citas en cada respuesta e informa sus tasas aparte de la tasa de respuesta, ya que las dos cuentan errores distintos. Una tasa de cero solo es un resultado si la comprobación habría podido encontrar un problema, así que conserva una respuesta de prueba que cite fuera de su prompt, y ejecuta la comprobación sobre ella, para mostrar que la comprobación sigue saltando.

Rechazos

Cuando la documentación no responde a una pregunta, el asistente debe contestar con la frase de rechazo, "The docs don't say.", y nada más. Cuando la documentación sí responde, no debe usar esa frase. Estos son dos errores distintos, así que cada uno tiene su propia tasa. Un rechazo falso es una pregunta respondible que se rechaza, y una respuesta falsa es una pregunta no respondible a la que se responde. Los ejemplos que dependen de la versión y los ambiguos se dejan fuera de ambas tasas. Un ejemplo que depende de la versión tiene una tasa propia, la corrección por versión, que construye el capítulo 9. Un ejemplo ambiguo se juzga solo por la tasa de aprobados, ya que el texto de una respuesta por sí solo no puede mostrar qué versión o qué lectura se pretendía.

Ambos errores de rechazo se cuentan sobre las respuestas de la línea base.

check-declines.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 Superado
"""Counts the two decline errors over the baseline replies: answerable items declined, and unanswerable items answered.Version-dependent and ambiguous items are left out of both rates: a version-dependent item is scored by its own rate,version-correctness, and an ambiguous item has no rate yet. The last lines name any excluded item the baseline declined."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.answers import Assistant, chapter_itemsfrom lib.prompts import P1_SHA256, P1_SYSTEMfrom lib.stats import pctassistant = Assistant("assistant-baseline", P1_SYSTEM, P1_SHA256)items = chapter_items()answerable = [item for item in items if item.kind == "answerable"]unanswerable = [item for item in items if item.kind == "unanswerable"]false_refusals = [item.id for item in answerable if assistant.reply(item).declined]  # already in id orderfalse_answers = [item.id for item in unanswerable if not assistant.reply(item).declined]print(f"answerable items: {len(answerable)}")print(f"false refusal rate (answerable items declined): {pct(len(false_refusals), len(answerable))}")for item_id in false_refusals:    print(f"false refusal: {item_id}")print(f"unanswerable items: {len(unanswerable)}")print(f"false answer rate (unanswerable items answered): {pct(len(false_answers), len(unanswerable))}")for item_id in false_answers:    print(f"false answer: {item_id}")print(f"items not counted here (version-dependent and ambiguous): {len(items) - len(answerable) - len(unanswerable)}")excluded = [item for item in items if item.kind in ("version-dependent", "ambiguous")]declined_excluded = [item.id for item in excluded if assistant.reply(item).declined]  # the decline is not countedprint(f"declined, not counted here: {', '.join(declined_excluded) or 'none'}")
Salidapython check-declines.py
answerable items: 10
false refusal rate (answerable items declined): 0.0% (0 of 10)
unanswerable items: 4
false answer rate (unanswerable items answered): 0.0% (0 of 4)
items not counted here (version-dependent and ambiguous): 6
declined, not counted here: q-0004

Entre los ejemplos respondibles y no respondibles, la línea base no comete ninguno de los dos errores. La tasa de rechazos falsos es 0.0% (0 of 10) de los 10 ejemplos respondibles. La tasa de respuestas falsas es 0.0% (0 of 4) de los 4 no respondibles, así que todos los ejemplos no respondibles recibieron el rechazo, incluido q-0015.

Las tasas dejan fuera 6 ejemplos, y la última línea nombra el único de ellos que la línea base rechazó: q-0004. El ítem q-0004 pregunta si ${project} es el marcador de posición correcto en la 2.0, donde sí lo es. La línea base respondió con la frase de rechazo, pero la documentación de la 2.0 lo responde, en la sección placeholders, así que el rechazo es una respuesta incorrecta. La tasa anterior no lo cuenta como rechazo falso, porque esa tasa cubre solo los ejemplos respondibles. La corrección por versión sí lo cuenta como fallo.

Regla práctica: Mantén separadas las dos tasas de rechazo, y deja fuera de ambas los ejemplos que dependen de la versión y los ambiguos. Una respuesta cuenta como rechazo correcto solo cuando es la frase de rechazo y nada más, de modo que una respuesta que da la frase y luego una contestación cuenta como el error que es. Lee a mano cada rechazo falso antes de cambiar el prompt, pues alguno puede señalar un vacío real en la documentación. Lee también cada rechazo de un ejemplo que depende de la versión, ya que la tasa no los cuenta.

Un juez

Las citas y las negativas comprueban la forma de una respuesta. No pueden comprobar si la respuesta es correcta, y esa es la pregunta que le importa al equipo. Para eso, el libro usa un juez: un modelo que lee la pregunta, una respuesta de referencia escrita y la respuesta del asistente, y devuelve PASS o FAIL. El juez aquí es Qwen3-4B-Instruct-2507, el mismo modelo que escribió las respuestas. Un juez y un asistente que son un solo modelo pueden compartir puntos ciegos, y entonces el juez no detecta los errores que el asistente comete por la misma razón. Este libro no puede comprobarlo con esta configuración. Lo que hace en su lugar es comparar el mismo modelo, bajo una rúbrica de calibración, con calificaciones humanas públicas, y explicar qué supone trasladar esas tasas a este juez, en el capítulo 6.

Las reglas del juez son breves, y vale la pena leerlas completas. Una respuesta solo es correcta si dice lo que dice la referencia. Otras palabras están bien, y también un detalle adicional que no contradiga la referencia. Una respuesta que afirma algo que la referencia no respalda, o que lo contradice, falla. Si la referencia admite más de una lectura, la respuesta debe responder a todas ellas, y una respuesta parcial falla. Si la referencia es «ninguna», la documentación no responde, y la única respuesta correcta es la negativa. Una respuesta que da una respuesta y además la frase de negativa falla. El juez escribe su veredicto en la primera línea y una breve razón a continuación. El prompt pide una sola oración, y el juez no siempre se detiene ahí.

Aquí está el veredicto del juez sobre q-0005, el caso que estuvo cerca. La respuesta del asistente a este caso dice que 2.0 no lee sablefile.lock, y apunta vagamente a la migración.

judge-one-answer.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 Superado
"""Reads the reference-guided judge's verdict on the baseline reply to q-0005, a planted near-miss item, from its recording.The judge sees the question, the written reference and the reply; the first line of its reply is the verdict."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.answers import Assistant, chapter_itemsfrom lib.contract import parse_verdictfrom lib.prompts import P1_SHA256, P1_SYSTEM, REF_SHA256from lib.replay import ReplayModelassistant = Assistant("assistant-baseline", P1_SYSTEM, P1_SHA256)item = next(item for item in chapter_items() if item.id == "q-0005")print(f"question {item.id} (version {item.version}, {item.kind}, planted: {item.planted_why}): {item.question}")print(f"reference answer: {item.reference_answer}")reply = assistant.reply(item)print(f"assistant reply: {reply.text}")judge = ReplayModel("judge-answers-baseline", REF_SHA256)  # the prompt hash must match the judge's manifestraw = judge.reply(item.id, 0)verdict = parse_verdict(raw)assert verdict is not None, "the judge's first line must be a verdict"print(f"judge verdict: {verdict}")reason = [line.strip() for line in raw.splitlines() if line.strip()][1:]  # the line after the verdictprint(f"judge reason: {reason[0] if reason else 'none'}")
Salidapython judge-one-answer.py
question q-0005 (version 2.0, answerable, planted: near-miss-term): Does sablefile 2.0 still read sablefile.lock in my project root?
reference answer: Only as a fallback. If the new file is missing and an old sablefile.lock is present, a 2.0 command reads the old file but warns you about it. Once the new file exists, 2.0 reads only that one, and sablefile never deletes the old file.
assistant reply: No, sablefile 2.0 does not read `sablefile.lock` in the project root. Version 2.0 moves the lock file to a new place. The first 2.0 command that reads an older lock file handles it as described in lock-migration. [sec:install-upgrade]
judge verdict: FAIL
judge reason: The response incorrectly states that sablefile 2.0 "does not read `sablefile.lock`" and that it "moves the lock file to a new place," which contradicts the reference answer that says sablefile 2.0 reads the old lock file as a fallback and only reads the new file once it exists. The reference explicitly states that it reads the old file as a fallback and warns users, not that it moves or stops reading it.

La respuesta de referencia dice algo distinto: 2.0 lee el archivo antiguo solo como respaldo, cuando no existe un archivo nuevo, y avisa cuando lo hace. El veredicto del juez es FAIL, y su razón dice que la respuesta contradice la referencia. La sección de migración a 2.0 de la documentación dice lo que dice la referencia, así que en este caso el juez acierta. Pero un veredicto correcto no demuestra que el juez sea fiable.

Por eso el juez debe contrastarse con personas. Un juez que coincide con tus propias etiquetas no queda por ello calibrado. El estudio de Shankar y colegas Who Validates the Validators? (2024) incluyó a nueve participantes, y encontró que las personas afinan sus criterios de evaluación mientras califican las salidas, de modo que los criterios que adoptan cambian a medida que leen más salidas. Una rúbrica escrita una sola vez puede separarse de lo que sus evaluadores llegan a entender. El capítulo 5 explica cómo ponerla por escrito, y eso merece la pena por una razón propia: una rúbrica escrita es lo que un segundo lector puede usar para comprobar un veredicto, y lo que permite comparar veredictos posteriores. La comprobación frente a calificaciones humanas está en el capítulo 6.

Regla práctica: Da al juez una referencia escrita para cada elemento, y lee sus veredictos FAIL con la misma atención que sus veredictos PASS antes de confiar en una tasa construida sobre ellos. No consideres que la coincidencia con tus propias etiquetas sea calibración. Hasta que un juez se haya contrastado con calificaciones humanas, informa su tasa como la tasa del juez, no como una medida de la calidad del asistente.

Una tasa de aciertos y su intervalo

Último cambio en la edición 2026.11.3

Una tasa de aciertos es un recuento dividido entre un denominador, y el denominador decide lo que la tasa significa. La misma tasa sobre un conjunto mucho mayor es una afirmación distinta, y un conjunto de veinte se mueve mucho cuando cambia un solo elemento. Aquí el denominador es cada elemento del conjunto, y una negativa correcta cuenta como acierto.

pass rate = passed items / items

Un intervalo responde a una pregunta distinta de la que responde la tasa de aciertos: cuánto se movería la tasa si el conjunto hubiera sido otros veinte elementos extraídos de la misma manera. El método es un bootstrap percentil. El bootstrap en sí es de Efron: su artículo de 1979 Bootstrap Methods: Another Look at the Jackknife, en los Annals of Statistics, expuso el remuestreo como una manera de estimar cuánto varía un estadístico. El bootstrap percentil es el intervalo más sencillo construido sobre el remuestreo: el 95% central de las tasas remuestreadas. El procedimiento extrae elementos del conjunto con reemplazo, sin atender a su tipo, de modo que una extracción puede contener cualquier mezcla de tipos. Calcula la tasa de aciertos de cada extracción y repite las extracciones muchas veces. El intervalo muestra cuánto podrían decir veinte elementos.

Calcula la tasa y su intervalo para la línea base, y después desglosa la tasa por tipo.

pass-rate-interval.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 Superado
"""The baseline's pass rate over the twenty chapter items, judged by the reference-guided judge, with its 95% interval.Every item is in the denominator, and a correct decline counts as a pass. The interval resamples items."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.answers import chapter_itemsfrom lib.judging import passed, verdictsfrom lib.stats import bootstrap_mean, interval_pct, pctitems = chapter_items()found = verdicts("judge-answers-baseline", [item.id for item in items])  # keyed in sorted id orderscores = passed(found)  # 1.0 for PASS, 0.0 for FAIL, in the same orderprint(f"items: {len(items)}")print(f"pass rate: {pct(int(scores.sum()), len(items))}")lo, hi = bootstrap_mean(scores)  # level 0.95 for one comparison; seed SEED, 2,000 resamplesprint(f"95% interval of the pass rate: {interval_pct(lo, hi)}")kind_of = {item.id: item.kind for item in items}for kind in ("answerable", "unanswerable", "version-dependent", "ambiguous"):    ids = [item_id for item_id in found if kind_of[item_id] == kind]    passes = sum(1 for item_id in ids if found[item_id] == "PASS")    print(f"pass rate, {kind}: {pct(passes, len(ids))}")
Salidapython pass-rate-interval.py
items: 20
pass rate: 85.0% (17 of 20)
95% interval of the pass rate: [70.0%, 100.0%]
pass rate, answerable: 90.0% (9 of 10)
pass rate, unanswerable: 100.0% (4 of 4)
pass rate, version-dependent: 75.0% (3 of 4)
pass rate, ambiguous: 50.0% (1 of 2)

La tasa de aciertos de la línea base es 85.0% (17 of 20). Su intervalo del 95% es [70.0%, 100.0%]. El intervalo queda a la misma distancia a ambos lados de la tasa. Su extremo superior queda en el techo para cualquier tasa. Llega a ese techo porque más del 2.5% de las extracciones no contienen ningún elemento fallido, de modo que la parte alta del 95% central es ese techo. Eso significa que el intervalo no puede descartar un asistente que nunca falla, que es lo que oculta el número único.

Los elementos respondibles aciertan en 90.0% (9 of 10), los elementos no respondibles en 100.0% (4 of 4), los elementos dependientes de la versión en 75.0% (3 of 4) y los elementos ambiguos en 50.0% (1 of 2). Los tres fallos caen en tres tipos distintos. El único fallo en los elementos respondibles es q-0005, leído arriba. El único fallo dependiente de la versión es la negativa sobre q-0004, leída arriba. El único fallo ambiguo es q-0019, que el juez da por fallido con la respuesta de la línea base, como muestra el ejemplo de la sección siguiente.

Solo el tipo respondible tiene más de unos pocos elementos: 10 de ellos. Cada uno de los demás tipos reúne 4 elementos o menos, así que sus líneas son notas sobre unos pocos elementos, no resultados.

El intervalo cubre solo la dispersión que procede de extraer elementos. No dice nada sobre si los veinte elementos representan las preguntas que hacen los usuarios reales, y ningún intervalo puede decir eso. El capítulo 3 explica qué debe contener un conjunto antes de que una puntuación sobre él signifique algo, y por qué este se redactó a partir de la documentación en lugar de muestrearse de los usuarios.

Regla práctica: Informa cada tasa de aciertos con su denominador, su intervalo y su tasa por cada tipo de elemento. Trata un tipo con solo unos pocos elementos como una nota, no como un resultado, e indica en cuántos elementos se basa.

Dos prompts

Último cambio en la edición 2026.11.3

El prompt que propone el equipo es el cambio que hay que medir. P1 es el prompt de referencia. P2 mantiene las mismas reglas básicas y cambia la forma de la respuesta: pide que el modelo cite primero la oración en la que se apoya su respuesta y luego dé la respuesta, con la cita en cada línea. La pregunta es si la cita ayuda. Dos tasas de aprobación sobre ítems distintos miden sobre todo los ítems, así que la comparación tiene que pasar los mismos ítems por ambos prompts. Cada ítem recibe entonces dos veredictos, y la diferencia se calcula ítem por ítem. Eso es una comparación pareada.

Ambos prompts se ejecutan sobre los mismos veinte ítems, y la salida informa de la diferencia con su intervalo.

compare-two-prompts.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 Superado
"""Compares the baseline prompt (P1) with prompt-b (P2) on the twenty chapter items: each pass rate, the paired difference, its interval and n.The word 'better' is used only when the whole interval is above zero, and 'worse' only when it is below zero. A differencewhose interval includes zero is reported as no difference detected."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.answers import chapter_itemsfrom lib.judging import pairedfrom lib.stats import interval_points, pctresult = paired("judge-answers-baseline", "judge-answers-prompt-b", [item.id for item in chapter_items()])first, second = result.first, result.second  # 1.0 or 0.0 per item, in id orderprint(f"P1 (baseline) pass rate: {pct(int(first.sum()), result.n)}")print(f"P2 (prompt-b) pass rate: {pct(int(second.sum()), result.n)}")print(f"items that P2 passes and P1 fails: {int(((second == 1) & (first == 0)).sum())}")print(f"items that P1 passes and P2 fails: {int(((second == 0) & (first == 1)).sum())}")print(f"paired items (n): {result.n}")print(f"difference, P2 minus P1: {100 * result.difference:+.1f} points")print(f"95% interval of the difference: {interval_points(result.diff_lo, result.diff_hi)}")if result.diff_lo > 0:    reading = f"P2 is better at n = {result.n}"elif result.diff_hi < 0:    reading = f"P2 is worse at n = {result.n}"else:    reading = f"no difference detected at n = {result.n}"print(f"reading: {reading}")# The two prompts tie: the same number of items pass under each, so the pass rates and the reading say the same thing.assert int(first.sum()) == int(second.sum()), "the two prompts must tie: the same pass count under each"
Salidapython compare-two-prompts.py
P1 (baseline) pass rate: 85.0% (17 of 20)
P2 (prompt-b) pass rate: 85.0% (17 of 20)
items that P2 passes and P1 fails: 1
items that P1 passes and P2 fails: 1
paired items (n): 20
difference, P2 minus P1: +0.0 points
95% interval of the difference: [-15.0, +15.0] points
reading: no difference detected at n = 20

En este conjunto, los dos prompts empatan. P1 aprueba 85.0% (17 of 20) de los ítems, y P2 aprueba 85.0% (17 of 20).

La vista pareada muestra lo que hay bajo el empate. P2 aprueba 1 ítem que P1 suspende, y P1 aprueba 1 ítem que P2 suspende. Estos son los veredictos del juez, no hechos sobre los prompts. El primero es q-0019, y la aprobación del juez en ese caso infringe su propia regla 3. La diferencia, P2 menos P1, es +0.0 points, y su intervalo es [-15.0, +15.0] points. El intervalo incluye el cero, así que con este tamaño el ejemplo informa de que no se detectó diferencia.

Aquí se leen los veredictos del juez sobre q-0019 bajo ambos prompts, y la regla que incumple la aprobación se muestra junto a ellos.

judge-gets-one-wrong.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 Superado
"""Shows one judge verdict that breaks the judge's own rule: on q-0019, the judge passes P2's reply, which answers only one of thetwo readings in the reference. The rule it breaks is rule 3 of the judge's prompt, printed below from that prompt.The hand verdict is a person's reading, written into this file. It is printed beside the judge's verdict and is the onlynumber here that is not a recorded one; the count of passes with it is taken from the judge's own verdicts."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.answers import Assistant, chapter_itemsfrom lib.judging import verdictsfrom lib.prompts import P1_SHA256, P1_SYSTEM, P2_SHA256, P2_SYSTEM, REF_SYSTEMfrom lib.replay import ReplayModelITEM_ID = "q-0019"HAND = {"q-0019": "FAIL"}  # read by hand against rule 3: the reply answers reading 1 and not reading 2item = next(item for item in chapter_items() if item.id == ITEM_ID)print(f"question {item.id} (version {item.version}, {item.kind}, planted: {item.planted_why}): {item.question}")print(f"reference answer: {item.reference_answer}")print(f"P2 reply: {Assistant('assistant-prompt-b', P2_SYSTEM, P2_SHA256).reply(item).text}")raw = ReplayModel("judge-answers-prompt-b", None).reply(item.id, 0)  # the judge's recorded reply to P2's answerprint(f"judge verdict on P2's reply: {verdicts('judge-answers-prompt-b', [item.id])[item.id]}")reason = [line.strip() for line in raw.splitlines() if line.strip()][1:]  # the line after the verdictprint(f"judge reason: {reason[0] if reason else 'none'}")print(f"judge verdict on P1's reply to the same item: {verdicts('judge-answers-baseline', [item.id])[item.id]}")print(f"hand verdict on P2's reply, under rule 3: {HAND[item.id]}")rule_3 = next(line for line in REF_SYSTEM.splitlines() if line.startswith("3. "))print(f"rule it breaks: {rule_3}")ids = [item.id for item in chapter_items()]judged = verdicts("judge-answers-prompt-b", ids)passes = sum(verdict == "PASS" for verdict in judged.values())by_hand = passes - sum(1 for item_id in HAND if judged[item_id] == "PASS" and HAND[item_id] == "FAIL")print(f"P2 passes, as judged: {passes} of {len(ids)}")print(f"P2 passes, with {ITEM_ID} read by hand: {by_hand} of {len(ids)}")
Salidapython judge-gets-one-wrong.py
question q-0019 (version 2.0, ambiguous, planted: ambiguous-target): If I edit the file and then run check, will it fail?
reference answer: Reading 1: if you edited a generated file (a target), check prints DRIFT and the path for it and exits with status 1, because its hash no longer matches the lock.
Reading 2: if you edited a template, check prints nothing and exits with status 0, since a template change is not drift.
P2 reply: Quote: "Run `sablefile check` after a sync. If no output appears, no generated file has drifted since the last sync. To see what drift looks like, open a generated file, change one line, and run the check again. The check prints `DRIFT` and the path of the file." [sec:quickstart-check]
Answer: Yes, if you edit the file and then run check, it will print `DRIFT` and the path of the file, indicating a drift [sec:quickstart-check].
judge verdict on P2's reply: PASS
judge reason: The response correctly identifies that editing a generated file and running check will result in a DRIFT message and path output, aligning with Reading 1 of the reference. It does not contradict or omit any part of the reference.
judge verdict on P1's reply to the same item: FAIL
hand verdict on P2's reply, under rule 3: FAIL
rule it breaks: 3. If the reference has several readings, the response must answer every reading. A partial answer is incorrect.
P2 passes, as judged: 17 of 20
P2 passes, with q-0019 read by hand: 16 of 20

Lee esta salida como un registro de los veredictos del juez. La referencia de q-0019 admite dos lecturas, y la respuesta de P2 solo responde a la primera. La regla 3 del prompt del juez dice que una respuesta parcial suspende, y el juez suspende la respuesta de P1 al mismo ítem, que también responde solo a la primera lectura. Sobre la respuesta de P2 la aprueba, y su razón dice que la respuesta cubre la referencia y no omite nada. Leído a mano, P2 aprueba 16 of 20 ítems, no 17 of 20. El empate está a un error del juez de dejar de serlo. Por eso las tasas aquí son las tasas del juez, y por eso el capítulo 6 contrasta el juez con valoraciones humanas públicas.

Regla práctica: Compara prompts sobre los mismos ítems, de forma pareada, e informa de la diferencia con su intervalo. Di que un prompt es mejor solo cuando todo el intervalo está por encima de cero, y peor solo cuando está por debajo de cero. Cuando el intervalo incluye el cero, di que no se detectó diferencia con este tamaño, lo que no es lo mismo que decir que los prompts son iguales.

Lo que veinte preguntas no pueden mostrar

Este último ejemplo toma las mismas dos instrucciones y pregunta qué pueden mostrar los veinte ítems sobre ellas. Veinte ítems resultan decir muy poco sobre estas dos instrucciones.

twenty-cannot-tell.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 Superado
"""Shows that twenty items cannot tell the two prompts apart: the interval of the paired difference includes zero.The assert is the chapter's claim, checked against the numbers; the example prints no verdict word."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.answers import chapter_itemsfrom lib.judging import pairedfrom lib.stats import interval_pointsresult = paired("judge-answers-baseline", "judge-answers-prompt-b", [item.id for item in chapter_items()])print(f"paired items (n): {result.n}")differing = int((result.first != result.second).sum())print(f"items where the two verdicts differ: {differing}")print(f"difference, P2 minus P1: {100 * result.difference:+.1f} points")print(f"95% interval of the difference: {interval_points(result.diff_lo, result.diff_hi)}")print(f"interval width: {100 * (result.diff_hi - result.diff_lo):.1f} points")# Zero inside the interval is the claim: no difference that twenty items can show.assert result.diff_lo <= 0.0 <= result.diff_hi, "the interval of the difference must include zero"# Two items carry the whole comparison: the pass rates differ only where these two verdicts differ.assert differing == 2, "exactly two items must have differing verdicts"
Salidapython twenty-cannot-tell.py
paired items (n): 20
items where the two verdicts differ: 2
difference, P2 minus P1: +0.0 points
95% interval of the difference: [-15.0, +15.0] points
interval width: 30.0 points

Solo 2 ítems reciben veredictos distintos de las dos instrucciones, así que la diferencia solo puede moverse en pasos gruesos, un ítem a la vez. El intervalo de la diferencia tiene un ancho de 30.0 points. Una aserción en el código exige que el intervalo incluya el cero, de modo que la afirmación falla de forma visible si los números dejan de sostenerla. Un intervalo tan ancho solo puede detectar un cambio grande, y un cambio menor que aún importa a los usuarios puede quedar oculto dentro de él.

En producción, el mismo error aparece de tres formas: confiar en un número que no puede sostener la afirmación que se hace con él. Un equipo elige la instrucción con el número más alto sobre los veinte ítems que escribió primero, y el informe omite el intervalo, de modo que nadie ve cuán poco sostiene el número. Se confía en un juez porque sus veredictos parecen sensatos, y nadie lee sus razones de FAIL contra la referencia. Un conjunto de respuestas grabadas, conservado después de que hayan cambiado las secciones que ve el asistente, mide el sistema antiguo mientras sus números siguen pareciendo bien. Notas el primero cuando un informe muestra un intervalo junto a cada tasa. Notas el segundo cuando alguien lee las razones de FAIL del juez contra las referencias en cada ejecución. El tercero solo se hace visible si la grabación además calcula el hash de los documentos que recibió. Los manifiestos de este libro calculan el hash de la instrucción y del conjunto de prueba, de modo que un cambio de instrucción se rechaza al reproducir, pero un cambio en las secciones pasa desapercibido.

Dos capítulos posteriores dan los pasos siguientes. capítulo 3 construye el conjunto más grande que este capítulo no tiene, y el capítulo 8 calcula cuántos ítems necesita una diferencia para poder mostrarse.

El capítulo tomó estas decisiones:

  • Cada pregunta indica su versión, y su respuesta proviene solo de los documentos de esa versión.
  • El conjunto de este capítulo son veinte ítems, leídos completos, con los ítems sembrados etiquetados.
  • Cada grabación se hace una vez por modelo, instrucción y documentos, y se reproduce en cada comparación.
  • Las citas y las negativas se verifican en el código antes de que cualquier juez lea una respuesta.
  • El juez califica contra una referencia escrita, y su tasa cuenta como la tasa del juez hasta que la calibración la verifique.
  • Una tasa de aciertos viene con su denominador, su intervalo y su tasa para cada tipo de ítem.
  • Las instrucciones se comparan sobre los mismos ítems, y solo un intervalo totalmente a un lado del cero hace que una de ellas sea mejor o peor.

Regla práctica: Informa el intervalo junto a cada comparación. Veinte ítems pueden encontrar respuestas incorrectas; no pueden ordenar dos instrucciones.

Este capítulo, en esta edición

Edición 2026.11.3Ejemplos verificados el 21 de nov de 2026Superan la prueba 11 de 11 ejemplos ejemplos de este capítulo

Traducido del libro en inglés, edición 2026.11.3.

Cita esta sección

Formato

Cada formato cita el libro en inglés, que esta traducción sigue.

Cada formato nombra esta edición. Su enlace abre la edición actual, donde el encabezado de cada sección indica cuándo cambió su texto por última vez. Las fechas de acceso y de recuperación son el día en que lo abres.

En esta página

Capítulo 1 de 11: Mide un asistente antes de cambiarlo

  1. La herramienta y su documentación
  2. Los veinte ejemplos
  3. Recuperar y luego responder
  4. Reproducir las respuestas
  5. Dos comprobaciones con código
  6. Citas
  7. Rechazos
  8. Un juez
  9. Una tasa de aciertos y su intervalo
  10. Dos prompts
  11. Lo que veinte preguntas no pueden mostrar

Volver arribaTodos los capítulos