Dale herramientas y un bucle a un modelo
Unos 19 minutos de lectura, con 4 ejemplos en 8 secciones.
Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros
Traducido del libro en inglés, edición 2026.11.2. Lee el original
En esta página
Al final de este capítulo podrás ejecutar un modelo en un bucle que le da tres herramientas: una lee un archivo, otra ejecuta las pruebas y la última termina con un archivo modificado. El bucle se detiene cuando el modelo termina, cuando se le acaban los pasos o cuando deja de hacer llamadas. Lo ejecutarás primero con un modelo guionizado que resuelve la tarea y después con un modelo abierto grabado que no la resuelve, y verás en qué punto se equivoca ese modelo.
El agente de este capítulo mantiene unitcraft, una pequeña biblioteca de Python que lee, convierte y formatea magnitudes físicas escritas como texto, como 3.5 kg. El agente toma una incidencia que presentó un mantenedor y propone un cambio en el código de la biblioteca. Puede ejecutar las pruebas visibles sobre su propia copia, pero nunca ve la comprobación oculta que decide si un cambio se considera terminado. Esa separación es deliberada. Un agente que puede leer su propio evaluador aprenderá el evaluador, y las mediciones del libro en el capítulo 10 no significarían nada.
La carta de Andrew Ng en The Batch, número 379, fechada el 13 de noviembre de 2026, describe un harness de agente como el código que envuelve a un LLM y le proporciona contexto, herramientas y salvaguardas. Este libro usa la palabra con el mismo significado. El modelo toma las decisiones. El harness proporciona el bucle, las herramientas y los límites de lo que esas herramientas pueden hacer, y buena parte de este libro trata de esa segunda parte.
La primera tarea, T-01, es una corrección de un solo archivo: el cambio va en unitcraft/format.py. El conjunto de pruebas visible falla en tests/test_format.py, y la incidencia dice: "format_quantity elimina los ceros finales: 3.5 kg se imprime como 3.5 kg, y el valor por defecto son dos decimales". Por tanto, la salida esperada para 3.5 kg es 3.50 kg. Una persona abriría unitcraft/format.py, lo leería, haría el cambio y volvería a ejecutar las pruebas. El agente tiene que hacer las mismas cosas en orden, sin una persona entre los pasos, y el harness tiene que asegurarse de que ese orden se mantenga incluso cuando el modelo se equivoque.
Este capítulo cubre una sola tarea de principio a fin. Explica con qué empieza el agente, el bucle que lo ejecuta, las herramientas que invoca y la primera regla que lo detiene. Después ejecuta el bucle dos veces, una con un modelo guionizado y otra con uno grabado, y cuenta lo que ocurrió.
Qué hace el agente en una tarea
El agente empieza con dos mensajes: un prompt de sistema que nombra sus herramientas y sus argumentos, y el texto del problema. Nada más sobre la tarea llega al modelo. El agente nunca toca el caso en sí. El harness crea una copia de trabajo de la biblioteca para cada ejecución, y cada escritura que hace el agente cae solo en esa copia. Cuando termina la ejecución, la copia se evalúa y luego se descarta, así que una ejecución no puede dejar cambios para la siguiente.
Una corrección se considera terminada cuando se cumplen dos cosas. La comprobación oculta pasa sobre la copia, y la ejecución termina con una llamada a finish. Para T-01, la comprobación oculta es H-01, un archivo de pytest escrito a partir del texto del problema. Afirma una sola cosa: que format_quantity rellena 3.5, 0 y 12 kg a dos decimales, como 3.50 kg, 0.00 kg y 12.00 kg. El harness copia ese archivo en una copia nueva de la biblioteca después de la ejecución, así que el agente nunca lo lee. El capítulo 10 aplica la misma regla a todo el conjunto de tareas. Aplicar un cambio al caso de la biblioteca es una decisión aparte, y el capítulo 6 es donde una barrera de aprobación la toma.
La regla también cierra un atajo que un modelo podría tomar. Podría editar las pruebas visibles hasta que pasen. Para T-01, el archivo de la tarea indica que la carpeta tests debe permanecer sin cambios, así que el evaluador compara esa carpeta con el caso byte a byte, y una prueba editada hace que la ejecución no cuente como terminada, aunque la comprobación oculta pase. Un modelo que está adivinando una corrección puede recurrir a ese atajo sin ninguna intención de hacer trampa, y la regla es lo que impide que cuente.
Cargar T-01 desde el archivo de la tarea y listar los archivos del caso requiere un ejemplo corto.
1"""The issue the agent starts from, task T-01, and the case's files in sorted order. The model reads only the2issue and the system prompt, so these are what its first request holds about the task."""3from lib.case import CASE, case_files, load_tasks45task = load_tasks(only=["T-01"])[0]6print("task:", task.id)7print("issue:", task.issue)8files = case_files(CASE)9print("case files:", len(files))10for name in files:11 print(" ", name)
python read-the-issue.pytask: T-01
issue: `format_quantity` drops the trailing zeros: 3.5 kg prints as `3.5 kg`, and the default is two places. CI is red on `tests/test_format.py`.
case files: 25
.github/workflows/test.yml
README.md
pyproject.toml
tests/test_arith.py
tests/test_cli.py
tests/test_convert.py
tests/test_format.py
tests/test_parse.py
tests/test_rounding.py
tests/test_table.py
tests/test_temperature.py
unitcraft/__init__.py
unitcraft/__main__.py
unitcraft/arith.py
unitcraft/cli.py
unitcraft/convert.py
unitcraft/errors.py
unitcraft/format.py
unitcraft/parse.py
unitcraft/prefixes.py
unitcraft/quantity.py
unitcraft/rounding.py
unitcraft/table.py
unitcraft/temperature.py
unitcraft/units.py
La salida imprime el problema y luego los archivos del caso en orden alfabético. El problema es el único texto específico de la tarea en la primera solicitud del modelo, así que cada paso posterior depende de lo que contenía esa primera solicitud. El caso tiene 25 archivos, y el agente puede leer cualquiera de ellos desde su copia.
Regla práctica: Evalúa una ejecución solo contra su propia copia y la comprobación de su tarea. Nunca la evalúes contra el caso en sí, porque un cambio que llegara al caso contaría para una ejecución que no lo había ganado.
Un bucle en unas setenta líneas
Un modelo produce texto, y el arnés convierte parte de ese texto en acciones. En cada paso envía al modelo los mensajes hasta ese momento, junto con los esquemas de las herramientas. La respuesta vuelve como texto. El arnés lee la llamada a la herramienta que contiene, ejecuta la herramienta sobre la copia de trabajo, añade el resultado a los mensajes y vuelve a empezar. El modelo nunca ejecuta nada por sí mismo. La documentación de Anthropic sobre el uso de herramientas expresa el contrato en estos términos: el modelo emite una solicitud estructurada, la aplicación ejecuta la operación y el resultado vuelve a la conversación (Cómo funciona el uso de herramientas).
El bucle es _loop en examples/lib/loop.py, de unas setenta líneas. El archivo también contiene reglas para capítulos posteriores: las paradas opcionales en Stops están desactivadas por defecto, y una respuesta cortada al llegar al límite de tokens se rechaza sea cual sea la configuración. Ninguna de las ejecuciones de este capítulo llega a ninguna de las dos. Un paso es una llamada al modelo. Una llamada a una herramienta es una solicitud dentro de un paso, y una respuesta puede contener más de una. El bucle actúa sobre la primera solicitud y responde a cada una de las demás con un error que indica que no se ejecutó. Cada solicitud recibe un ID de un contador, y ese ID se incluye en el mensaje de resultado que la responde. El mensaje del asistente que contiene la respuesta no lleva ID, y la traza tampoco lo guarda. La traza, en lib/trace.py, contiene una línea por paso: el número del paso, la herramienta que llamó y lo que devolvió. Cada respuesta también permanece en los mensajes, por eso el modelo ve sus pasos anteriores en la siguiente llamada, y por eso la solicitud crece con cada paso.
La respuesta del modelo es texto plano, y su llamada a una herramienta tiene una forma fija: JSON dentro de etiquetas <tool_call>. La plantilla de chat del archivo del modelo pide esa forma, un objeto JSON con el nombre de la función y los argumentos dentro de las etiquetas (el archivo del modelo en su revisión fijada). Las respuestas registradas usan esta forma, y el arnés solo lee lo que hay dentro de las etiquetas:
<tool_call>
{"name": "read_file", "arguments": {"path": "<case-relative path>"}}
</tool_call>
El texto fuera de las etiquetas se ignora, así que una respuesta puede incluir prosa antes de la llamada. Un bloque que no se puede analizar no se ejecuta. El arnés lo registra como llamada mal formada y devuelve el motivo al modelo como resultado de error, para que pueda intentarlo de nuevo.
A lo largo de la ejecución, los mensajes crecen en un orden fijo: el prompt del sistema, el problema y después cada respuesta seguida del resultado de su llamada. Nada se resume y nada se descarta. Eso hace legible la transcripción, y hace que el coste de cada paso crezca con el anterior. El capítulo 5 trata qué hacer cuando ese crecimiento alcanza la ventana del modelo. Las ejecuciones de este capítulo son cortas y todavía no lo necesitan.
ReAct intercala razonamiento escrito con acciones, y Yao y sus colegas informaron de que el razonamiento ayuda a un modelo a mantener y revisar un plan, y a manejar excepciones (Yao et al., ReAct). Este bucle mantiene las acciones y no pide al modelo razonamiento entre ellas. Su prompt del sistema dice «Responde solo con una llamada a una herramienta», y el analizador pasa por alto cualquier prosa que el modelo escriba de todos modos.
Regla práctica: Conserva en los mensajes cada solicitud y su resultado, y da a cada resultado el ID de la solicitud que responde. Un bucle que descarta un resultado deja al modelo sin respuesta a su solicitud, y los mensajes son donde se nota ese hueco.
Dos herramientas y una herramienta de parada
El agente tiene que leer, probar y cambiar, así que el capítulo le da una herramienta para cada tarea. La herramienta de cambio es también la herramienta de parada, porque en este diseño un cambio termina la ejecución.
| Herramienta | Argumentos | Qué se devuelve | ¿Termina la ejecución? |
|---|---|---|---|
read_file |
path, una ruta dentro de la copia temporal del caso para esta ejecución |
el texto del archivo, o un error | no |
run_tests |
ninguno | los recuentos y los nombres de las pruebas que fallan, de la suite visible sobre la copia | no |
finish |
path y text, el archivo nuevo completo |
los recuentos y las pruebas que fallan después de escribir el cambio | sí |
read_file devuelve el archivo completo, y una ruta fuera de la copia se rechaza. run_tests ejecuta la suite visible en la copia y devuelve sus recuentos y los nombres de las pruebas que fallan, no la salida completa. Una suite que supera el límite de tiempo se detiene, junto con su grupo de procesos. finish toma el texto nuevo de un archivo, lo escribe en la copia, ejecuta la suite visible y termina la ejecución. Si la escritura se rechaza, el error vuelve como resultado de la herramienta y la ejecución continúa, de modo que el modelo tiene otra oportunidad.
En este capítulo las herramientas se ejecutan dentro del propio proceso del arnés, sobre la copia. El capítulo 7 ejecuta en un entorno aislado las pruebas, el único comando que inician estas herramientas.
Una herramienta que lee archivos tiene que decidir qué rutas leerá. Al llamar a read_file con dos rutas fuera del caso se ve lo que recibe el modelo cuando pide una.
1"""The read tool refuses a path outside the case, and the refusal comes back as text the model can read. Only reads2are tried, and a refused path never reaches the disk."""3from lib.case import CASE4from lib.tools import CH1, Workspace56ABSOLUTE = "/etc/secret.txt"7ws = Workspace(CASE)8for path in ("../secret.txt", ABSOLUTE):9 result = CH1.call(ws, "read_file", {"path": path})10 # An absolute path differs on every machine, so the output shows a placeholder for it.11 print("refused:", result.text.replace(ABSOLUTE, "<absolute path>"))
python tool-refusal.pyrefused: error: path outside the case: ../secret.txt
refused: error: path outside the case: <absolute path>
Ambas rutas se rechazan, y cada rechazo es un resultado de herramienta. El modelo lo lee en el paso siguiente como cualquier otro resultado, así que puede corregir su ruta e intentarlo de nuevo. Ninguna de las lecturas rechazadas toca el disco.
Regla práctica: Da a cada herramienta una sola tarea, y deja que solo la herramienta de parada termine una ejecución. Una lectura o escritura rechazada debe volver al modelo como un error que pueda usar, y nunca debe detener el ciclo.
Deténte cuando termine la tarea o cuando se agote el presupuesto
Un bucle sin salida se ejecuta hasta que alguien lo detiene, y cada paso cuesta tokens. Por eso cada ejecución termina de una de tres formas, y la ejecución registra cuál en ended. El modelo llama a finish, y la ejecución termina con su cambio. O la ejecución alcanza el presupuesto de pasos, que es de ocho pasos para el conjunto de herramientas de este capítulo, y termina como step_cap. O el modelo responde dos veces seguidas sin ninguna llamada a herramienta. La primera de esas respuestas recibe un reintento, con un mensaje que pide una sola llamada a herramienta. La segunda termina la ejecución como no_tool_call.
Una llamada a una herramienta que no existe vuelve como resultado de error, y la ejecución sigue. El bucle no se detiene por una llamada incorrecta. Cuenta la llamada, devuelve el error y espera el siguiente paso. El presupuesto es lo que impide que un modelo que sigue haciendo llamadas incorrectas se ejecute para siempre. El presupuesto cuenta llamadas al modelo, no segundos, de modo que la misma ejecución termina en el mismo paso en cualquier máquina. Además, el presupuesto es un límite distinto del tamaño del contexto: una ejecución puede alcanzar el presupuesto de pasos con espacio libre en la ventana, o quedarse sin ventana antes. La ventana no es un límite que este capítulo haga cumplir.
El capítulo 2 añade el resto de las reglas de parada. Cubren una ejecución que repite la misma llamada, una ejecución que hace ediciones sin mover los conteos de pruebas, y una ejecución que debería hacerle una pregunta a la persona en lugar de continuar. El bucle de este capítulo no tiene ninguna de esas, así que un modelo que entre en bucle seguirá hasta el paso ocho.
Regla práctica: Fija el presupuesto de pasos antes de que comience la ejecución y trátalo como un límite estricto. Una ejecución que alcanza el presupuesto no terminó, sin importar cómo se vea su último paso, y debe informarse como inconclusa.
Ejecuta el bucle con un modelo guionizado
Con el bucle, sus herramientas y su presupuesto ya preparados, la primera ejecución usa un modelo cuyas respuestas tú escribes. Un modelo guionizado devuelve las respuestas que le das, en orden, y nada más. Eso lo convierte en una prueba limpia del bucle: cualquier fallo de la ejecución es del bucle y no del modelo, y la ejecución muestra lo que el bucle hace con respuestas correctas, no lo que un modelo elegiría. Cuatro respuestas guionizadas para T-01 leen la implementación, leen su prueba, ejecutan la suite visible y terminan con un archivo corregido.
1"""Four scripted replies solve T-01 through the step loop: read the file, read its test, run the visible suite,2then finish with the fixed file. The model is scripted, so the output shows the loop's steps and not a model's choices."""3from lib.case import load_tasks4from lib.chapter1 import SOLUTION, call, report5from lib.models import ScriptedModel6from lib.tools import CH178task = load_tasks(only=["T-01"])[0]9model = ScriptedModel([10 call("read_file", path="unitcraft/format.py"),11 call("read_file", path="tests/test_format.py"),12 call("run_tests"),13 call("finish", path="unitcraft/format.py", text=SOLUTION.read_text(encoding="utf-8")),14])15run, done = report(model, task, CH1) # CH1: three tools, their system prompt and a budget of eight steps; report prints the trace and scores the run16assert done, "the scripted run should solve T-01"
python scripted-loop.pystep 1: read_file: 23 lines
step 2: read_file: 27 lines
step 3: run_tests: 8 failed, 22 passed
step 4: finish: 7 failed, 23 passed
steps: 4
tool calls: 4
ended: finish
La ejecución resuelve T-01 en cuatro pasos, que es todo lo que una ejecución guionizada puede demostrar: el bucle lleva respuestas correctas hasta una comprobación que pasa. El archivo corregido es la solución del propio libro, guardada junto con los datos del caso, y el ejemplo afirma que la ejecución se considera terminada.
Lee la salida en orden. Cada línea nombra una llamada y lo que devolvió, de modo que las líneas juntas muestran lo que el modelo tenía delante en cada paso. Los recuentos cambian entre el paso 3 y el paso 4: la corrección lleva la suite visible de 8 pruebas fallidas a 7, y la prueba que describe el issue ahora pasa. Las siete que quedan son otras pruebas de la misma suite visible que siguen fallando. La comprobación que cuenta para T-01 es H-01, y pasa. La ejecución toma 4 pasos y hace 4 llamadas a herramientas, una por paso, y termina como finish.
Regla práctica: Ejecuta el bucle con un modelo guionizado antes de ejecutarlo con cualquier modelo. Si la ejecución guionizada falla, el fallo está en el arnés, y una ejecución con modelo solo lo ocultaría. Si la ejecución guionizada pasa y la ejecución con modelo falla, el fallo está en el modelo o en el prompt.
Ejecútalo con el modelo grabado
La ejecución grabada proviene de Qwen3-4B-Instruct-2507, un modelo abierto cuantizado a Q4_K_M y ejecutado en una CPU con temperatura 0 y una semilla fija. Sus respuestas se guardaron como el texto sin procesar que produjo, en una grabación cuyo manifiesto indica el modelo, su revisión, el hash del prompt y los recuentos de tokens. Replay comprueba que cada solicitud coincide con la que contiene la grabación, donde una solicitud son los mensajes y los esquemas de herramientas enviados en ese paso, y luego devuelve la respuesta grabada.
1"""The recorded run of T-01, replayed step by step: each request must match the one recorded, and the replies are2the recorded text, mistakes included. The run stops at the step cap without a finish, so the task is not done."""3from lib.case import load_tasks4from lib.chapter1 import Recorder, report5from lib.models import ReplayModel6from lib.tools import CH178from collections import Counter910task = load_tasks(only=["T-01"])[0]11model = Recorder(ReplayModel("chapter-1-t01", "T-01"))12run, done = report(model, task, CH1)13assert not done, "the recorded run should not solve T-01"14reasons = [reason for reply in model.replies for reason in reply.malformed]15print("malformed calls:", len(reasons))16for reason, count in sorted(Counter(reasons).items()):17 print(f" {count} x {reason}")18assert all('"text": """' in reply.text for reply in model.replies[2:]), "from step 3 the call's text opens with triple quotes"19print("prompt tokens:", run.prompt_tokens)20print("completion tokens:", run.completion_tokens)
python recorded-run.pystep 1: read_file: 23 lines
step 2: run_tests: 8 failed, 22 passed
step 3: malformed: error: malformed call
step 4: malformed: error: malformed call
step 5: malformed: error: malformed call
step 6: malformed: error: malformed call
step 7: malformed: error: malformed call
step 8: malformed: error: malformed call
steps: 8
tool calls: 8
ended: step_cap
malformed calls: 6
6 x not JSON (Expecting ',' delimiter)
prompt tokens: 13009
completion tokens: 2128
El modelo grabado nunca termina. Sus dos primeros pasos son llamadas válidas: una read_file, y después una run_tests. A partir del tercer paso, cada respuesta es una llamada a finish que contiene un archivo completo nuevo, y cada una de esas llamadas falla al analizarse. Eso ocurre 6 veces, todas por la misma razón, y la ejecución termina como step_cap tras 8 pasos y 8 llamadas a herramientas. El arnés devuelve cada fallo como un resultado de error, y el modelo responde con una llamada a finish de la misma forma.
La forma de cada llamada fallida es la siguiente. Se omite el archivo, y el texto de la llamada se muestra con ...:
<tool_call>
{"name": "finish", "arguments": {"path": "unitcraft/format.py", "text": """ ...the whole file...\""}}
</tool_call>
El valor empieza con tres comillas. JSON lee las dos primeras como una cadena vacía, así que el analizador se detiene en la tercera, donde espera una coma. El valor también termina con una comilla simple, después de una comilla escapada.
La interpretación del problema que hace el modelo es errónea desde el paso 2, y el fallo de formato la oculta. En el paso 2 el modelo escribe que format_quantity "elimina los ceros finales de la parte fraccionaria, lo cual es correcto" (palabras del modelo, del paso 2 de replies.jsonl de la grabación). El archivo del paso 3 conserva el error: sigue quitando ceros de la fracción con frac.rstrip("0"). Ninguna llamada a finish se analiza en esta ejecución, así que ese archivo nunca llega a la comprobación oculta. Una prueba fuera de los ejemplos del libro ejecutó el archivo del paso 3, copiado de su bloque de código, en una copia del caso contra H-01, usando la versión fijada de pytest 9.2.0:
FAILED test_t01.py::test_pads_to_two_places - AssertionError: assert '3.5 kg'...
La solución propia del libro pasa la misma comprobación. Así pues, el cambio que propuso el modelo era incorrecto, y solo el fallo de formato impidió que se comprobara.
El ejemplo afirma que la ejecución no se consideró terminada, y que a partir del tercer paso cada respuesta lleva su archivo entre triples comillas dentro de la llamada. La herramienta de parada es la única que lleva un archivo completo, así que ahí está el fallo de formato. El capítulo 3 vuelve a esa herramienta y cambia la forma de enviar un cambio, lo que elimina el archivo entre triples comillas, aunque las ediciones pequeñas traen sus propios problemas de comillas. No responde al error de interpretación del paso 2: un cambio enviado en la forma correcta puede seguir siendo incorrecto.
Regla práctica: Reproduce una grabación de la misma manera en cada ejecución, y nunca la edites para que una ejecución pase. Una grabación fallida muestra lo que el modelo hizo realmente. La corrección pertenece al arnés, al prompt o a la elección del modelo, y el resultado de esa corrección es una grabación nueva.
Qué sale mal y qué se cuenta
La ejecución grabada de la ejecución reproducida falla de dos maneras. El bucle detecta la primera y no la corrige: cada llamada mal formada regresó como un resultado de error que el modelo podía leer, y el presupuesto de pasos terminó la ejecución. La segunda es el cambio incorrecto. El bucle nunca lo ve, porque ninguna llamada a finish se interpreta y, por tanto, ningún cambio se ejecuta. En esta grabación el modelo nunca llamó a una herramienta equivocada, y tampoco se detuvo antes de tiempo con una respuesta sin llamada. El fallo de formato se repitió hasta agotar el presupuesto, y eso ocultó la mala interpretación.
Cuatro conteos describen cada ejecución de este libro. Los pasos cuentan las llamadas al modelo, y las llamadas a herramientas cuentan los requests, incluidas las mal formadas. Los dos conteos de tokens son los tokens de entrada, sumados en todos los requests de la ejecución, y los tokens de salida que el modelo produjo. Los tokens se cuentan con el tokenizador propio del modelo fijado cuando se hace la grabación, y el conteo se guarda en el manifiesto de la grabación. La reproducción lee el conteo almacenado y no vuelve a tokenizar. Para la ejecución grabada, los tokens de entrada son 13009 y los tokens de salida son 2128. El total de entrada es alto porque en cada paso se envía de nuevo toda la transcripción.
Regla práctica: Cuenta los pasos y las llamadas a herramientas de la misma manera en cada ejecución, para que dos ejecuciones se puedan comparar. Cuando una ejecución termine en su presupuesto, lee sus líneas de error antes de cambiar el prompt o el modelo. Las líneas de error muestran si el modelo repite un mismo error, y eso indica qué parte del arnés conviene revisar.
Decisiones en este capítulo
- Las herramientas se ejecutan en el mismo proceso que el arnés, sobre una copia temporal. Eso basta para mostrar el ciclo, pero no es una defensa. Mientras un entorno aislado no contenga las herramientas, la copia solo sirve como lugar donde caen las escrituras.
- La herramienta de parada recibe el texto nuevo completo de un archivo. Es el cambio más simple que puede llevar una herramienta de parada, y es también el cambio que el modelo grabado no envía en una forma que el analizador pueda leer. Una herramienta de parada distinta necesitaría una nueva grabación.
- El presupuesto de pasos es ocho. El número es pequeño porque la tarea de este capítulo necesita unos cuatro pasos, y un presupuesto que se ajusta a la tarea hace que una ejecución que divaga resalte.
- La ejecución grabada se muestra tal como ocurrió. El fallo de formato y el error de interpretación permanecen en el libro, porque una grabación editada para pasar mostraría un modelo que no existe. Las respuestas sin procesar de la grabación se conservan junto a los recuentos, de modo que cualquiera pueda comprobar lo que el analizador hizo con cada una.
Regla práctica: Antes de cambiar cualquiera de estas decisiones, calcula qué efecto tiene el cambio sobre las cifras que imprime este capítulo. Un nuevo presupuesto de pasos cambia los recuentos de pasos, una nueva herramienta de parada implica una nueva grabación, y un entorno aislado cambia lo que las herramientas pueden alcanzar. Haz el cambio en los términos de su propio capítulo y vuelve a ejecutar los ejemplos con guion y los grabados antes de confiar en el resultado.
Este capítulo, en esta edición
Edición 2026.11.2Ejemplos verificados el 20 de nov de 2026Superan la prueba 4 de 4 ejemplos ejemplos de este capítulo
Traducido del libro en inglés, edición 2026.11.2.