Nivel inicial11 min de lectura · Revisado el

Claude Code: qué es y cómo usarlo paso a paso

Cómo usar Claude Code: una receta con cuatro pasos (entiende, plan, test y revisa), un aprendiz de cocina muy rápido y un plato probado con una marca verde. Cómo usar Claude Coderubentejera.com 1. Entiende2. Plan3. Test4. RevisaTú das la recetay pruebas el plato
Claude Code cocina deprisa; la receta, el orden de los pasos y probar el plato siguen siendo cosa tuya.

Claude Code es la herramienta de programación con IA de Anthropic que trabaja en tu terminal: lee tu código, edita ficheros y ejecuta comandos. Para usarlo, instálalo con un comando, ábrelo con claude en la carpeta de tu proyecto y pídele el trabajo en lenguaje normal. Lo que decide si el resultado sirve es el orden: primero que entienda el código, después un plan, luego cambios pequeños con un test que los compruebe y, al final, tu revisión antes del commit.

La razón de ese orden es sencilla: Claude Code acelera lo que ya hay en tu proyecto. Si hay tests y cambios pequeños, acelera cambios comprobados; si no los hay, acelera la deuda. Es la idea de la IA Limpia, el enfoque de esta web: IA que corre, código que dura. La documentación oficial, también en español, explica cada opción; este tutorial se centra en el flujo, paso a paso, sobre un proyecto pequeño.

Comandos, atajos y modos comprobados en la documentación oficial de Claude Code, versión 2.1.325 (la última, publicada el 13 de noviembre de 2026), consultada el 14 de noviembre de 2026.

Un aprendiz de cocina muy rápido

Imagina que entra en tu cocina un aprendiz que pica, sofríe y emplata a una velocidad que tú no alcanzas. Sabe cocinar, pero no conoce tu cocina: no sabe dónde guardas la sal, qué cliente es alérgico al marisco ni cómo te gusta el punto del arroz. Si le dices «haz una paella» y te vas, algo saldrá, pero no sabrás si es tu paella hasta que la pruebes.

Lo que hace un buen jefe de cocina es otra cosa: le da la receta, le pide que le cuente qué va a hacer antes de encender el fuego, le deja hacer un paso cada vez y prueba el plato antes de que salga a la sala.

Claude Code es ese aprendiz. La receta es el fichero de instrucciones del proyecto; contar antes de encender el fuego es el modo plan; probar el plato son los tests y tu revisión del cambio. El símil se queda corto en una cosa: un aprendiz recuerda lo que le corregiste ayer. Cada sesión nueva de Claude Code empieza sin la conversación anterior (salvo que la retomes); solo conserva lo que quede escrito, como el CLAUDE.md y su memoria automática, unas notas que guarda él mismo.

Qué es Claude Code y dónde funciona

Claude Code es una herramienta de programación con IA de Anthropic que lee tu código, edita ficheros, ejecuta comandos y trabaja con tus herramientas de desarrollo, como git. No es un autocompletado: es un agente, un programa que repite un ciclo de mirar, decidir y actuar hasta terminar la tarea. Cómo funciona ese ciclo por dentro está en qué es un agente de IA para programar y cómo funciona.

Funciona en varios sitios, todos con el mismo motor:

  • La terminal, la versión más completa. Es la que usa este tutorial.
  • Los editores: una extensión para VS Code (también para Cursor) y un plugin para los IDE de JetBrains, como IntelliJ IDEA o PyCharm. El de JetBrains necesita tener instalada la versión de terminal.
  • Una aplicación de escritorio, que se instala aparte y exige una suscripción de pago, y la web, en claude.ai/code, sin instalar nada.

Para usarlo hace falta una cuenta de pago de Claude, con suscripción o con pago por uso, o acceso a través de un proveedor de nube compatible, como Amazon Bedrock. Lo que supone cada opción está en «Límites y coste», al final.

Cómo instalar Claude Code

En macOS, Linux o WSL (el Linux dentro de Windows), abre una terminal y ejecuta:

curl -fsSL https://claude.ai/install.sh | bash

En Windows, desde PowerShell:

irm https://claude.ai/install.ps1 | iex

La instalación nativa de arriba se actualiza sola, en segundo plano. También se puede instalar con Homebrew (brew install --cask claude-code, que sigue el canal estable, normalmente una semana por detrás) o con WinGet (winget install Anthropic.ClaudeCode), pero con esos dos hay que actualizar a mano. En Windows sin WSL, la documentación recomienda instalar también Git for Windows.

Cuando termine, abre una terminal nueva y comprueba que responde:

claude --version

Si escribe un número de versión seguido de (Claude Code), está instalado. Si dice que no encuentra claude, la carpeta de instalación no está en el PATH; la página de problemas de instalación explica cómo arreglarlo.

Primeros pasos y comandos básicos de Claude Code

Entra en la carpeta de tu proyecto y abre una sesión:

cd api-reservas
claude

La primera vez te pide iniciar sesión en el navegador. Después aparece una línea donde escribir, con la versión, el modelo y la carpeta de trabajo encima. Lo que escribas ahí es una petición, en lenguaje normal; lo que empieza por / es un comando de Claude Code. Los primeros que conviene conocer:

Comando o atajo Qué hace
/help Muestra la ayuda y los comandos disponibles. Escribir solo / también los lista
/init Crea un CLAUDE.md inicial a partir de tu código
Shift+Tab Cambia el modo de permisos de la sesión
/plan Entra en modo plan; /plan descripción empieza ya con esa tarea
Esc Detiene a Claude en mitad de lo que hace, sin perder lo hecho
/rewind (o Esc dos veces con la línea vacía) Vuelve el código, la conversación o los dos a un punto anterior
/diff Muestra los cambios de la carpeta de trabajo, incluidos los de Claude
/clear Empieza una conversación nueva, con el contexto vacío
/exit (o Ctrl+D dos veces) Sale de Claude Code

Desde la terminal, claude -c retoma la última conversación de esa carpeta, y claude -r te deja elegir una anterior.

Los modos de permisos

El modo de permisos decide qué puede hacer Claude sin preguntarte. Con Shift+Tab se pasa de uno a otro, y la barra de estado muestra en cuál estás:

  • Manual (default en la configuración): solo lee sin preguntar. Cada edición y cada comando que no sea de lectura te pide permiso.
  • Aceptar ediciones (acceptEdits): edita ficheros de la carpeta de trabajo y ejecuta sin preguntar comandos básicos de ficheros, como mkdir, mv o rm, siempre dentro de esa carpeta. El resto de comandos sigue pidiendo permiso.
  • Plan (plan): investiga y propone cambios, pero no edita tu código hasta que apruebas el plan.
  • Auto (auto): no te pregunta. Las lecturas y las ediciones dentro de la carpeta de trabajo pasan directamente, y otro modelo revisa el resto, como los comandos de terminal, antes de que se ejecute, para frenar lo peligroso: por ejemplo, un git push --force sobre el trabajo de otros. Es el modo con el que empiezan las sesiones en la terminal y en VS Code (desde la versión 2.1.283, en todos los planes), si tu modelo y tu organización lo permiten; si no, empiezan en Manual.

La documentación avisa de que el modo auto reduce las preguntas, pero no garantiza la seguridad. Hay otros dos modos para casos concretos: dontAsk, para scripts y CI, y bypassPermissions, que deja hacer todo y solo es para contenedores o máquinas virtuales aisladas.

Para aprender, conviene empezar en Manual o en modo plan (es criterio de esta web, no de la documentación): ves cada acción antes de que ocurra y entiendes qué hace el agente. Una sesión se abre directamente en un modo con la opción --permission-mode:

claude --permission-mode manual

Un flujo de trabajo paso a paso con Claude Code

El proyecto de ejemplo es inventado: la API de reservas de salas de una oficina. De momento tiene una función, reservar, que añade una reserva a la lista y rechaza las que terminan antes de empezar:

// Reglas de las reservas de salas. Las horas van en enteros: 9 son las 9:00.
export function reservar(reservas, nueva) {
  if (nueva.fin <= nueva.inicio) {
    throw new Error('La reserva tiene que terminar después de empezar');
  }
  return [...reservas, nueva];
}

Y dos tests, con el ejecutor que trae Node.js (node --test, lanzado con npm test): «añade una reserva a una sala libre» y «rechaza una reserva que termina antes de empezar». La tarea: rechazar una reserva si la sala ya está ocupada a esa hora.

Los comandos de shell y sus salidas de este apartado se han ejecutado con Node.js 24.22.3 y git 2.53.0; las salidas largas están recortadas. Las respuestas de Claude Code no se muestran, porque cambian en cada sesión: en su lugar, cada paso dice qué le pides y qué tienes que revisar tú.

1. Pide que lea y explique antes de tocar nada

Abre la sesión en modo plan, para que no pueda editar todavía:

claude --permission-mode plan

Y pregúntale por el proyecto:

Explica qué hace este proyecto, qué reglas tiene la función reservar
y con qué comando se pasan los tests.

Qué revisar: que la explicación coincida con lo que tú sabes del código. Si dice algo que no es verdad, como un comando de tests que no existe, ya has encontrado algo que debería estar escrito en el CLAUDE.md. Es la forma más barata de comprobar que el agente y tú habláis del mismo código.

2. Plan antes de cambiar, con la lista de casos

Sigue en modo plan y describe la tarea con lo que «terminado» significa para ti:

Quiero que reservar rechace una reserva si la sala ya está ocupada a esa hora.
Una reserva que empieza justo cuando termina otra sí se permite.
Propón el plan: la lista de casos que hay que probar y, de uno en uno,
un test que falle y el cambio mínimo para que pase.
No cambies los tests que ya existen.

Lo de empezar por una lista de casos viene de Kent Beck, que en «Canon TDD» pone como primer paso escribir la lista de escenarios de test que se quieren cubrir. Pedírselo al agente en el plan es aplicación nuestra. Si la tarea es más grande, esa lista puede escribirse antes en un fichero y atarse a los tests: es el spec-driven development. Para esta tarea, la lista podría ser:

  1. Rechaza una reserva que se solapa con otra de la misma sala (de 9 a 11 y de 10 a 12).
  2. Permite una que empieza justo cuando termina otra (de 9 a 11 y de 11 a 12).
  3. Permite una que termina justo cuando empieza otra (de 9 a 11 y de 8 a 9).
  4. Permite reservar otra sala a la misma hora (Azul de 9 a 11 y Verde de 10 a 12).

Claude lee lo que necesita y escribe un plan; no edita nada hasta que lo apruebas. Al presentarlo te deja elegir entre aprobarlo y pasar al modo auto, aprobarlo revisando cada edición a mano («Yes, manually approve edits») o seguir planificando («No, keep planning»). Para aprender, elige revisar cada edición. Si el plan no te convence, elige seguir planificando y dile qué cambiar: corregir un plan cuesta una frase; corregir el código, bastante más.

Qué revisar en el plan:

  • Qué ficheros toca. Para esta tarea, la función y su test, nada más.
  • Que la lista de casos incluya los bordes: las reservas que se tocan sin solaparse y las de otra sala.
  • Si añade dependencias, abstracciones u opciones que nadie ha pedido.

3. Un test que falla primero

Al aprobar el plan, Claude empieza por el primer caso. El test podría ser este:

test('rechaza una reserva que se solapa con otra de la misma sala', () => {
  const reservas = reservar([], { sala: 'Azul', inicio: 9, fin: 11 });
  assert.throws(
    () => reservar(reservas, { sala: 'Azul', inicio: 10, fin: 12 }),
    /ocupada/,
  );
});

Pídele que lo ejecute antes de tocar la función, o ejecútalo tú:

npm test
✔ añade una reserva a una sala libre (2.490558ms)
✔ rechaza una reserva que termina antes de empezar (0.677158ms)
✖ rechaza una reserva que se solapa con otra de la misma sala (1.661705ms)
ℹ tests 3
ℹ pass 2
ℹ fail 1
...
  AssertionError [ERR_ASSERTION]: Missing expected exception.

Qué revisar: que falla, y que falla por la razón esperada. «Missing expected exception» dice justo lo que falta: la función todavía no lanza ningún error para una sala ocupada. Si fallara por un error de sintaxis o porque no encuentra un fichero, el test aún no demuestra nada. Es el primer paso del ciclo de TDD: rojo, verde y refactor.

4. El cambio mínimo, caso a caso

El cambio mínimo para que pase ese test es casi una trampa: rechazar cualquier reserva si ya hay otra.

if (reservas.length > 0) {
  throw new Error(`La sala ${nueva.sala} está ocupada a esa hora`);
}

Con eso, los tres tests pasan. Parece poco, y lo es a propósito: cada caso siguiente de la lista falla con este código y obliga a afinarlo. Cada uno sigue el mismo ciclo, y en cada rojo hay que comprobar que falla por la razón esperada:

Caso Por qué falla en rojo Qué añade el cambio mínimo
2. Empieza cuando termina otra Lanza «La sala Azul está ocupada a esa hora» Solo choca si la nueva empieza antes de que termine la otra: nueva.inicio < r.fin
3. Termina cuando empieza otra Lanza el mismo error …y si la otra empieza antes de que termine la nueva: r.inicio < nueva.fin
4. Otra sala a la misma hora Lanza «La sala Verde está ocupada a esa hora» …y solo si es la misma sala: r.sala === nueva.sala

Al final, la comprobación queda así:

const seSolapa = reservas.some(
  (r) =>
    r.sala === nueva.sala &&
    nueva.inicio < r.fin &&
    r.inicio < nueva.fin,
);
if (seSolapa) {
  throw new Error(`La sala ${nueva.sala} está ocupada a esa hora`);
}

Dos reservas de la misma sala se solapan si cada una empieza antes de que termine la otra. Con < y no <=, la de 11 a 12 no choca con la de 9 a 11. Y cada parte de la condición está ahí porque un test la pidió: si quitas cualquiera de las tres, o cambias un < por <=, falla un test.

Claude ejecuta los tests por su cuenta si sabe el comando. Pídele que te enseñe la salida y no solo que te diga «todo pasa»: la documentación lo recomienda, porque leer la salida es más rápido que volver a ejecutarlo tú.

npm test
✔ añade una reserva a una sala libre (0.743673ms)
✔ rechaza una reserva que termina antes de empezar (0.240664ms)
✔ rechaza una reserva que se solapa con otra de la misma sala (0.277323ms)
✔ permite una reserva que empieza justo cuando termina otra (4.237202ms)
✔ permite una reserva que termina justo cuando empieza otra (0.388994ms)
✔ permite reservar otra sala a la misma hora (0.277193ms)
ℹ tests 6
ℹ pass 6
ℹ fail 0

Con los tests en verde toca el refactor: mejorar nombres o estructura sin cambiar el comportamiento, y volver a pasar los tests. Aquí el cambio es tan pequeño que no hace falta.

Un aviso para cuando un test pase a la primera: todavía no ha demostrado que sirve. Rompe un momento el código a propósito, mira que el test falla y deja el código como estaba. Es la idea de las pruebas de mutación, que hacen eso mismo de forma automática.

5. Revisa el diff tú

Antes del commit, lee el cambio entero. Empieza por ver qué ha cambiado, incluidos los ficheros nuevos, que git diff no enseña porque git aún no los sigue:

git status --short
 M src/reservas.js
 M test/reservas.test.js

Solo los dos ficheros esperados, y ninguno nuevo (aparecerían con ??). Después, cuánto ha cambiado cada uno:

git diff --stat
 src/reservas.js       |  9 +++++++++
 test/reservas.test.js | 26 ++++++++++++++++++++++++++
 2 files changed, 35 insertions(+)

Y una señal rápida sobre los tests que ya existían. La segunda columna son las líneas borradas:

git diff --numstat -- test/
26	0	test/reservas.test.js

Un 0 es buena señal, no una prueba: un test también se puede debilitar añadiendo líneas, por ejemplo una opción para saltarlo. Por eso el diff de los tests se lee entero. Y que --stat no muestre otros ficheros, como el package.json, donde se puede cambiar qué tests se ejecutan.

Qué revisar en el diff: que hace lo del plan y nada más; que los nombres se entienden; que el mensaje de error sirve a quien lo vaya a leer, y que no hay ficheros que no esperabas. Dentro de la sesión, /diff enseña lo mismo. La lista completa de qué mirar está en el artículo Cómo revisar código generado por IA.

6. El commit

Puedes pedírselo a Claude («haz commit de estos cambios con un mensaje descriptivo») o hacerlo tú. Lo importante es que el commit contenga solo lo que has revisado, así que nombra los ficheros en lugar de añadirlo todo:

git add src/reservas.js test/reservas.test.js
git commit -m "Rechaza reservas que se solapan en la misma sala"
[main d409c2a] Rechaza reservas que se solapan en la misma sala
 2 files changed, 35 insertions(+)

Antes de la siguiente tarea, si no tiene nada que ver con esta, escribe /clear. Cada petición envía la conversación entera, y la nueva tarea no necesita arrastrar la anterior.

Configurar Claude Code para que trabaje bien

CLAUDE.md: la receta del proyecto

CLAUDE.md es un fichero Markdown en la raíz del proyecto que Claude Code lee al empezar cada sesión. /init genera una primera versión a partir de tu código; a partir de ahí, la documentación dice que el trabajo consiste sobre todo en quitar líneas, y recomienda no pasar de 200 líneas.

Lo que tiene que estar es lo que Claude no puede deducir leyendo el código. Para la API de reservas, algo así:

# Comandos
- Tests: npm test

# Reglas
- Las horas van en enteros (9 son las 9:00); una reserva que empieza
  cuando termina otra no se solapa.
- No cambies los tests que ya existen para que pase un cambio:
  si un test parece mal, dilo y espera.

Qué poner, qué dejar fuera y cómo se combina con AGENTS.md, el formato que leen otros agentes, está en AGENTS.md y CLAUDE.md: qué son y qué poner.

Permisos: lo que no se negocia

Una línea en CLAUDE.md se cumple casi siempre, no siempre. La documentación lo dice claro: lo que tiene que pasar siempre, o no pasar nunca, va en una regla de permisos o en un hook, que Claude Code aplica decida lo que decida el modelo. Las reglas se ven y se cambian con /permissions, o en .claude/settings.json:

{
  "permissions": {
    "ask": ["Bash(git push *)"],
    "deny": ["Read(./.env)", "Read(./.env.local)"]
  }
}

Con esto, Claude Code pide confirmación antes de cada git push y no deja leer los ficheros de secretos. Las reglas deny se aplican en todos los modos, también en auto. Tienen sus límites: comparan la llamada a la herramienta, no la intención, así que un script que abra el fichero por su cuenta no lo detiene la regla.

Skills, subagentes, hooks y MCP

Cuando lo básico funcione, hay cuatro piezas más. No hacen falta el primer día, y todas sirven para lo mismo que el resto del artículo: que lo importante no dependa de que el modelo se acuerde.

  • Skills: procedimientos guardados en una carpeta por skill dentro de .claude/skills/, con su SKILL.md; por ejemplo, «cómo se publica una versión». En cada sesión Claude solo ve su nombre y su descripción, y el procedimiento entero se carga cuando se usa. /skills lista las que hay. Cómo crear una, con un ejemplo probado, está en Claude Code skills.
  • Subagentes: otras instancias de Claude con su propio contexto, para trabajo en paralelo o para una revisión de alguien que no ha visto cómo se escribió el código. Claude Code los usa por su cuenta cuando ve motivo, y puedes definir los tuyos en .claude/agents/. Por ejemplo, en la terminal, /code-review revisa el diff con un subagente que no ha visto la conversación. Cómo crear uno, con un revisor probado que no puede tocar el código, está en Claude Code subagentes.
  • Hooks: comandos tuyos que Claude Code ejecuta en momentos fijos, como antes de cada comando o cuando Claude quiere dar la tarea por terminada, y que pueden bloquear la acción. Sirven para lo que no admite excepciones. Qué son y cómo crear uno, con un hook que protege los tests, está en hooks de Claude Code; otro, que bloquea un commit con secretos, en AGENTS.md y CLAUDE.md.
  • MCP: un protocolo abierto para conectar el agente con otros sistemas, como el gestor de incidencias o una base de datos. El artículo Qué es MCP explica qué es y cuándo compensa. Si la herramienta tiene una línea de comandos, como gh para GitHub, la documentación indica que suele ser el camino más sencillo.

Errores frecuentes al empezar con Claude Code

Esta lista es criterio de esta web, a partir de las prácticas de ingeniería en las que se apoya; donde la documentación oficial dice lo mismo, se indica.

  • Aceptar sin leer. Tras muchas confirmaciones se aprueba sin mirar, y la documentación avisa justo de eso en el modo Manual: a partir de la décima. El modo da igual: lo que importa es leer el diff antes del commit. Aceptar todo sin leerlo tiene nombre, vibe coding, y sirve para un prototipo de usar y tirar, no para código que tiene que durar.
  • Dejar que cambie los tests para que pasen. Si un test falla y el agente lo «arregla» cambiando lo que el test espera, el verde ya no significa nada. Pídelo en la petición y en el CLAUDE.md, y compruébalo leyendo el diff de los tests, no solo la cuenta de líneas. Si es una regla sin excepciones en tu equipo, que la compruebe un hook o la CI.
  • No darle una forma de comprobar su trabajo. Sin tests ni otro comando que diga «pasa» o «falla», Claude para cuando el trabajo parece terminado. La documentación lo dice así, y por eso recomienda que la línea más útil de un CLAUDE.md sea el comando que ejecuta los tests.
  • Pedir mucho de una vez. «Rehaz el módulo de reservas» da un diff que nadie revisa bien. Una tarea, un plan, un cambio pequeño y su test: si el cambio no se revisa en unos minutos, era demasiado grande.
  • Arrastrar el contexto. Mezclar en una sesión varias tareas sin relación hace que cada petición cargue con todas, y eso cuesta más y despista. La documentación recomienda /clear entre tareas y, si has corregido lo mismo dos veces y sigue mal, /clear y una petición nueva que incluya lo aprendido, en lugar de una tercera corrección.

¿Claude Code es gratis? Precio y planes

No en el plan gratuito. En la página oficial de precios, consultada el 15 de noviembre de 2026, la lista del plan Free no incluye Claude Code y la del plan Pro sí, en una línea propia. Pro cuesta 20 dólares al mes (17 al mes con pago anual), y Claude Code también entra en los planes Max, Ultra, Team y Enterprise. Los precios cambian a menudo: comprueba la página antes de decidir.

También se puede conectar a un modelo abierto en tu máquina a través de Ollama, sin cuenta de Anthropic, pero un agente pide mucho contexto y un portátil se queda corto: lo que pasó al probarlo está en Claude Code con un modelo local.

Límites y coste

  • El coste depende de tu plan. Con una suscripción, el uso entra en los límites del plan; con la Console o un proveedor de nube, se paga por los tokens consumidos (las unidades de texto que procesa el modelo). Los precios y lo que incluye cada plan están en la página oficial de precios, que cambia a menudo. Dentro de una sesión, /usage muestra el consumo, y en los planes de suscripción también qué parte se va en cada skill, subagente o servidor MCP.
  • Los modos de permisos no son una frontera de seguridad. El modo auto es el juicio de otro modelo y puede equivocarse; las reglas deny miran cada llamada a una herramienta y un script puede saltárselas. Para lo serio, la documentación remite al sandbox (/sandbox), que limita los comandos a nivel del sistema operativo en macOS, Linux y WSL2.
  • /rewind no lo deshace todo. Solo sigue los ficheros que Claude ha editado con sus propias herramientas: uno que solo ha cambiado un comando de terminal, o que has cambiado tú fuera de la sesión, se queda como está. Funciona junto a git, no en su lugar.
  • Esto cambia deprisa. Los comandos, modos y versiones de este artículo son los de la documentación de la versión 2.1.325. Si algo no coincide con lo que ves, manda la documentación oficial. El flujo (entender, planificar, probar y revisar) no caduca ni depende de la herramienta: es el mismo con cualquier agente de programación, y es el que recoge el método IA Limpia.

Tu siguiente paso

Elige una tarea pequeña de tu proyecto, de las que revisarías en cinco minutos, y hazla con este orden:

  1. Abre la sesión en modo plan y pide que explique el código que vas a tocar.
  2. Describe la tarea con lo que significa «terminado», pide la lista de casos y revisa el plan antes de aprobarlo.
  3. Exige, para cada caso, un test que falle por la razón esperada antes del cambio, y la salida de los tests después.
  4. Lee el diff entero antes del commit y escribe /clear antes de la siguiente tarea.

Si es la primera vez, ejecuta /init y recorta el CLAUDE.md que genere hasta dejar solo lo que el agente no puede deducir: AGENTS.md y CLAUDE.md explica cómo.

El contenido sobre IA envejece rápido. Última revisión: 14 de noviembre de 2026.

Fuentes

Consultadas el 14 de noviembre de 2026. Documentación oficial de Claude Code, versión 2.1.325 (la última, publicada el 13 de noviembre de 2026). Hay una versión en español de la documentación; los enlaces son a la inglesa, que es la que se ha leído.