Claude Code: programa con IA desde cero
Instala Claude Code, domina su CLI en Windows y crea proyectos reales con Claude IA, con criterio y sin depender del código a ciegas
Fran Orellana
Muestra gratuita · Primer capítulo
Programar con inteligencia artificial no consiste en escribir una petición y aceptar todo lo que aparezca en pantalla. Consiste en trabajar con una herramienta capaz de analizar archivos, proponer cambios, escribir código y ayudarte a investigar errores, mientras tú decides qué problema resolver, qué límites debe respetar el proyecto y cuándo una solución está suficientemente bien.
Claude Code está diseñado para ese flujo de trabajo. Es una herramienta de desarrollo que funciona desde la terminal y puede interactuar con el contenido de un proyecto: leer archivos, crear otros, modificar código, ejecutar comandos y ayudarte a revisar los resultados. Su utilidad no depende únicamente de la calidad del modelo. También depende de cómo describas el objetivo, de los permisos que concedas y de la revisión que hagas antes de considerar terminado un cambio.
Este capítulo presenta una forma de usar Claude Code con criterio profesional, incluso si todavía tienes poca experiencia programando.
Claude es el modelo de inteligencia artificial desarrollado por Anthropic. Un modelo recibe instrucciones y contexto, interpreta el problema y genera una respuesta. Puede explicar conceptos, proponer código, resumir documentación, analizar errores o sugerir una arquitectura.
Claude.ai es la interfaz conversacional para interactuar con Claude desde un navegador o desde las aplicaciones disponibles. Resulta útil para aprender, investigar, diseñar una solución, revisar un fragmento de código o preparar un plan antes de modificar un proyecto.
Claude Code es una herramienta orientada al trabajo dentro de un entorno de desarrollo. Se utiliza desde la terminal y puede tener acceso controlado a los archivos del repositorio y a determinados comandos. Por eso puede realizar tareas más cercanas al ciclo real de programación: inspeccionar la estructura del proyecto, editar archivos, ejecutar pruebas y analizar los errores producidos.
La diferencia principal está en el contexto y en el tipo de acción:
Esta distinción evita una confusión frecuente: Claude Code no sustituye al entorno de ejecución ni convierte automáticamente una idea en software fiable. Puede acelerar muchas partes del proceso, pero no elimina la necesidad de especificar, revisar y probar.
El desarrollo asistido por inteligencia artificial utiliza un modelo para apoyar tareas que antes realizaba una persona de forma manual. Entre ellas están:
La IA trabaja especialmente bien cuando la tarea está acotada y puedes comprobar el resultado. Por ejemplo, pedir una función que convierta una fecha, generar una prueba para un caso concreto o añadir validación a un formulario suele ser más controlable que pedir «crea una aplicación completa» sin más contexto.
La calidad de la respuesta depende de varios factores:
Una respuesta convincente puede contener errores. El código puede parecer razonable y, aun así, fallar con una entrada inesperada, exponer información sensible o romper otra parte del proyecto. La fluidez del texto no es una prueba de corrección.
Cuando abres Claude Code en la carpeta de un proyecto, la herramienta necesita comprender qué hay allí. Antes de pedir cambios, conviene establecer un contexto mínimo:
No es necesario escribir toda esta información en cada mensaje. Puedes iniciar la sesión con una instrucción breve y después completar los detalles. Por ejemplo:
> Trabaja en este proyecto como asistente de desarrollo. Antes de modificar archivos, inspecciona la estructura y explícame qué has encontrado. La aplicación está escrita en Python. No añadas dependencias sin justificarlo. Mantén los cambios pequeños y ejecuta las pruebas relacionadas después de cada modificación.
Esta petición no le dice qué funcionalidad construir, pero establece un modo de trabajo. Le indica que debe inspeccionar antes de actuar, limitar el alcance y verificar sus cambios.
Una buena interacción con Claude Code suele comenzar con preguntas, no con modificaciones. Puedes pedirle que:
Pedir un plan primero reduce los cambios impulsivos. También te permite corregir una interpretación equivocada antes de que afecte a varios archivos.
Un flujo profesional puede resumirse en cuatro fases. No son pasos aislados; forman un ciclo que se repite para cada funcionalidad o corrección.
Una instrucción útil responde a varias preguntas:
Compara estas dos peticiones:
> Haz una aplicación para gestionar tareas.
La segunda es más precisa porque define una primera versión comprobable. No pretende resolver todos los detalles de una aplicación de gestión. Delimita el alcance y establece una prueba observable.
> Añade una función en src/tasks.py que reciba una lista de tareas y devuelva solo las que estén pendientes. Cada tarea tendrá las claves title y completed. Si falta alguna clave, debe producirse un error claro. Añade pruebas para una lista vacía, una tarea completada y una tarea pendiente. No uses dependencias externas.
La especificación tampoco tiene que ser perfecta. Su función inicial es hacer explícitas las decisiones que, de otro modo, quedarían ocultas.
Antes de ejecutar nada, revisa el plan y los archivos que Claude Code propone modificar. Pregunta:
La revisión no exige conocer cada detalle del lenguaje para ser útil. Puedes detectar problemas de alcance, requisitos olvidados o decisiones arriesgadas aunque todavía estés aprendiendo sintaxis.
Pide explicaciones concretas, no una confirmación genérica. En lugar de «¿está bien este código?», utiliza preguntas como:
> Explica qué archivos has cambiado y qué responsabilidad tiene cada modificación. Señala también dos casos de entrada que podrían hacer fallar esta solución y propone pruebas para ellos.
Cuando una herramienta puede editar archivos o ejecutar comandos, la revisión debe incluir también la acción que va a realizar, no solo el texto del código.
Un cambio no está validado porque el modelo lo haya generado. Hay que ejecutarlo en un entorno controlado. Esto puede incluir:
Supón que quieres construir una pequeña utilidad para contar palabras en un archivo de texto. Una primera implementación podría ser la siguiente:
PYTHON
from pathlib import Path
def count_words(file_path: str) -> int:
"""Return the number of whitespace-separated words in a text file."""
path = Path(file_path)
if not path.is_file():
raise FileNotFoundError(f"File not found: {file_path}")
return len(path.read_text(encoding="utf-8").split())
if __name__ == "__main__":
import sys
if len(sys.argv) != 2:
raise SystemExit("Usage: python word_count.py <file>")
print(count_words(sys.argv[1]))El programa recibe la ruta de un archivo, comprueba que existe, lo lee con codificación UTF-8 y cuenta los elementos separados por espacios en blanco. La comprobación del número de argumentos evita que el programa falle con un error poco claro cuando se ejecuta sin la ruta necesaria.
Puedes guardarlo como word_count.py y ejecutarlo desde la terminal con un archivo de prueba:
BASH
printf 'Claude Code ayuda a programar\n' > sample.txt python word_count.py sample.txt
El resultado esperado es 5. Después conviene probar también un archivo vacío y una ruta inexistente:
BASH
: > empty.txt python word_count.py empty.txt python word_count.py missing.txt
El primer comando debe mostrar 0. El segundo debe terminar con un error que indique que el archivo no existe. Estas comprobaciones son sencillas, pero muestran una regla importante: prueba tanto el camino normal como los casos que obligan al programa a tomar decisiones.
La primera versión rara vez es la última. Cuando hayas ejecutado el cambio, comparte con Claude Code el resultado real, incluido el mensaje de error completo si algo ha fallado. No lo resumas como «no funciona». El mensaje, el comando utilizado y el archivo implicado proporcionan contexto para investigar.
Una buena petición de depuración puede ser:
> La prueba test_missing_file falla. Este es el comando que ejecuté y este es el error completo: [pega aquí la salida]. Analiza primero la causa. No modifiques archivos todavía. Después propone el cambio mínimo y una prueba que confirme la corrección.
Este orden evita que el modelo aplique una reparación amplia sin haber identificado el problema. Tras el cambio, vuelve a ejecutar las pruebas y comprueba que no se ha corregido un caso rompiendo otro.
FLUJO DE TRABAJO PARA UNA FUNCIONALIDAD PEQUEÑA
1. Pide a Claude Code que inspeccione la estructura del proyecto.
2. Describe una funcionalidad concreta con sus criterios de aceptación.
3. Solicita un plan sin cambios.
4. Revisa los archivos afectados y las decisiones propuestas.
5. Autoriza una implementación pequeña.
6. Ejecuta las pruebas.
7. Examina el diff y prueba manualmente los casos importantes.
8. Pide una explicación de cualquier parte que no entiendas.
«No perder el control» no significa rechazar la automatización ni escribir personalmente cada línea. Significa conservar la capacidad de responder a estas preguntas:
El control se apoya en prácticas concretas. Usa un sistema de control de versiones, trabaja con cambios pequeños y revisa las diferencias antes de confirmarlas. No concedas permisos más amplios de los necesarios. Evita ejecutar comandos destructivos sin comprender su efecto y no pegues secretos, claves privadas, contraseñas o tokens en una conversación.
Si el proyecto contiene información sensible, revisa qué archivos puede leer la herramienta y qué datos pueden aparecer en los registros. La comodidad de compartir todo el repositorio no justifica exponer credenciales o datos personales.
REVISA SIEMPRE LAS OPERACIONES CON EFECTOS EXTERNOS
Un comando que modifica archivos puede deshacerse con control de versiones en muchos casos. Un comando que borra datos, cambia una base de datos, instala software, publica una aplicación o envía información a un servicio externo puede tener consecuencias que no se recuperan con facilidad. Antes de autorizarlo, pide una explicación de lo que hará y verifica el objetivo, la ruta y el entorno.
Una instrucción eficaz combina contexto, tarea y criterios de aceptación. Puedes usar esta estructura:
> Contexto: describe el proyecto y el estado actual.
> Tarea: indica un único objetivo concreto.
> Restricciones: especifica tecnologías, límites y archivos que deben respetarse.
> Validación: explica qué pruebas o resultados deben confirmarse.
> Forma de trabajo: pide plan, cambios, pruebas y resumen final.
Por ejemplo:
> Este proyecto es una herramienta de línea de comandos en Python que convierte archivos CSV a JSON. Añade una opción --pretty para producir JSON indentado. Mantén la compatibilidad con las opciones existentes y no añadas dependencias externas. Primero inspecciona el parser de argumentos y propón un plan. Después implementa el cambio, añade pruebas para el modo normal y el modo indentado, ejecútalas y resume los archivos modificados.
La instrucción delimita una tarea concreta y define cómo debe verificarse. Si Claude Code detecta una decisión ambigua, debe preguntarte antes de resolverla por su cuenta.
También puedes pedirle que actúe con distintos roles durante la revisión:
Estos roles no garantizan una revisión completa, pero ayudan a enfocar la conversación.
Claude Code puede escribir código, pero su valor educativo aparece cuando le pides que te ayude a entender las decisiones. Si aceptas soluciones sin comprenderlas, acumularás una dependencia difícil de mantener. Si preguntas por los supuestos y las alternativas, cada tarea puede ampliar tus conocimientos.
Cuando aparezca código desconocido, formula preguntas específicas:
> Explica esta función suponiendo que conozco variables, condicionales y funciones, pero todavía no domino el manejo de archivos en Python. Indica qué errores puede producir y por qué se usa encoding="utf-8".
También puedes pedir una comparación:
> Propón dos formas de resolver este problema. Compara complejidad, legibilidad, dependencias y facilidad de prueba. Recomienda una solo después de explicar las diferencias.
La respuesta no sustituye a la documentación del lenguaje ni a una prueba real. Sirve para preparar preguntas, acelerar la investigación y aclarar conceptos. Comprueba siempre las afirmaciones importantes en la documentación oficial y en el comportamiento del programa.
No delegues en el modelo decisiones que todavía no puedes evaluar. Si no sabes qué datos maneja una aplicación, no le pidas que diseñe sin supervisión la autenticación. Si no entiendes las consecuencias de una migración de base de datos, no autorices una operación destructiva solo porque la instrucción parece clara. Si una aplicación procesa pagos, información médica o datos personales, la revisión debe ser especialmente rigurosa y puede requerir conocimientos o asesoramiento especializado.
Claude Code puede ayudarte a avanzar desde una idea hasta un proyecto ejecutable. La diferencia entre una demostración y un software confiable está en el método: objetivos concretos, permisos limitados, cambios trazables, pruebas y revisión humana. La IA acelera el trabajo; no decide qué resultado es aceptable.
A partir de este principio, aprenderás a instalar Claude Code, preparar un proyecto, interactuar con la terminal y construir funcionalidades paso a paso. En cada caso, la meta no será obtener código a cualquier precio, sino desarrollar un flujo en el que puedas explicar, comprobar y mantener lo que construyes.
Cuando se habla de programar con Claude, es fácil mezclar varios productos y formas de uso. Claude puede aparecer en una conversación web, en una aplicación de escritorio, en una terminal o integrado en un flujo de trabajo con archivos y herramientas. Todos utilizan modelos de la familia Claude, pero no ofrecen el mismo nivel de acceso ni están pensados para las mismas tareas.
La diferencia principal es esta:
El nombre de las funciones, los sistemas operativos compatibles y las integraciones pueden cambiar. Por eso conviene comprobar siempre la documentación oficial y la configuración disponible en tu cuenta. Lo importante para trabajar con criterio es entender el papel de cada herramienta y elegir la adecuada para cada momento.
Claude IA es la forma más general de utilizar Claude. Normalmente se accede desde la aplicación web, una aplicación compatible o una integración que proporcione una interfaz de conversación. Es útil para tareas como:
En esta modalidad, Claude trabaja principalmente con el contexto que le proporcionas en la conversación. Si pegas una función, puede revisarla. Si adjuntas un documento, puede analizarlo. Si describes una aplicación, puede ayudarte a dividirla en tareas. Sin embargo, eso no significa que conozca automáticamente todo tu proyecto ni que pueda modificar tus archivos locales.
Por ejemplo, puedes pedirle:
> Estoy creando una aplicación para registrar gastos personales. Ayúdame a definir los requisitos mínimos para una primera versión. No escribas código todavía. Separa las funciones imprescindibles de las mejoras futuras y señala las decisiones que debo tomar antes de empezar.
La instrucción tiene una característica importante: limita el tipo de respuesta. En vez de pedir directamente que construya la aplicación, le pides que aclare el problema. Esa fase reduce el riesgo de empezar con una solución confusa o sobredimensionada.
Claude IA también puede actuar como tutor. En ese caso, no conviene pedir únicamente «dame la respuesta». Es más útil indicar qué sabes, qué no entiendes y qué tipo de ayuda quieres:
> Explícame esta función de Python como si conociera variables, condicionales y funciones, pero todavía no entendiera las excepciones. Después, propón dos ejercicios pequeños para practicar.
La calidad de la respuesta dependerá del contexto. Claude no puede inferir con precisión tus restricciones, tus datos, la versión de una biblioteca o la finalidad de una función si no se los indicas. Una respuesta convincente puede ser incorrecta, incompleta o incompatible con tu entorno. La conversación ayuda a pensar y a producir material de trabajo, pero no sustituye la comprobación.
Claude Code está diseñado específicamente para trabajar con código desde la terminal. Su diferencia esencial respecto a un chat convencional es el acceso al entorno de desarrollo. Según los permisos y la configuración, puede inspeccionar archivos, recorrer directorios, modificar código, ejecutar comandos y ayudarte a interpretar los resultados.
Esto permite trabajar con el proyecto completo en lugar de analizar fragmentos aislados. Claude Code puede, por ejemplo:
La expresión «puede hacerlo» no significa que debas permitirle hacerlo sin supervisión. Claude Code opera dentro de un entorno con archivos, dependencias, credenciales potenciales y comandos que pueden tener consecuencias. Antes de aceptar una acción, debes saber qué va a modificar, qué comando va a ejecutar y sobre qué directorio actuará.
Una interacción responsable con Claude Code puede seguir este orden:
Una petición inicial adecuada podría ser:
> Revisa este repositorio sin modificar ningún archivo. Identifica el punto de entrada de la aplicación, el sistema de pruebas y la forma de configurar las variables de entorno. Después, resume la arquitectura en cinco apartados y señala cualquier riesgo que debamos tener en cuenta antes de añadir una nueva función.
El detalle «sin modificar ningún archivo» es una restricción explícita. También puedes indicar que no ejecute comandos destructivos, que no cambie dependencias o que no acceda a determinados directorios. Las restricciones no son una garantía absoluta: debes revisar las acciones que propone y las autorizaciones que solicita.
Claude Code tampoco sustituye al control de versiones. Trabaja con Git y conserva una práctica básica: crea una rama o un punto de recuperación antes de un cambio importante, revisa el diff y evita mezclar cambios no relacionados. Si una modificación rompe el proyecto, debes poder identificarla y revertirla.
Claude Desktop es una aplicación de escritorio para utilizar Claude desde el ordenador sin depender exclusivamente del navegador. Su valor no está en convertir automáticamente una conversación en un entorno de programación completo, sino en ofrecer una interfaz integrada para interactuar con Claude y, según las funciones disponibles, trabajar con archivos, herramientas o conexiones configuradas.
La aplicación de escritorio puede resultar cómoda en situaciones como estas:
No debes confundir la aplicación de escritorio con Claude Code. Abrir Claude desde el escritorio no implica necesariamente que pueda leer todo tu disco, ejecutar comandos o modificar un proyecto. El acceso depende de las funciones activadas, los permisos concedidos y las integraciones configuradas.
La distinción práctica es sencilla:
En un flujo profesional, Desktop y Code pueden complementarse. Puedes utilizar la aplicación para definir una funcionalidad, ordenar requisitos o revisar documentación, y después trasladar una especificación concreta a Claude Code para implementarla en el repositorio. Lo importante es no asumir que ambos tienen el mismo contexto. Una conversación en Desktop no contiene automáticamente el estado completo de tu proyecto en Claude Code, y una sesión de Claude Code no conoce por defecto todas tus conversaciones anteriores.
Claude Cowork está orientado a trabajar con Claude como un colaborador que puede organizar y ejecutar tareas compuestas dentro de un espacio de trabajo. En lugar de limitarse a responder una pregunta, puede ayudarte a avanzar por una secuencia de acciones sobre archivos, información o herramientas disponibles en ese entorno.
Una tarea de este tipo podría consistir en:
Su utilidad depende de la tarea y de las integraciones disponibles. No debes entenderlo como una versión «más inteligente» de Claude Code ni como un sustituto universal del entorno de desarrollo. Claude Cowork está pensado para coordinar trabajo con contexto y herramientas; Claude Code está especializado en operar sobre proyectos de software desde la terminal.
La diferencia puede verse en estos dos encargos:
> Revisa el código de este repositorio, localiza los controladores relacionados con la autenticación, añade pruebas para el caso de contraseña incorrecta y ejecuta la suite correspondiente.
Este encargo encaja con Claude Code porque menciona un repositorio, archivos de código, pruebas y comandos de ejecución.
> Revisa los documentos de requisitos de esta carpeta, extrae las funciones previstas para la primera versión y crea un informe con las decisiones pendientes.
Este segundo encargo encaja mejor con un espacio de trabajo como Cowork, siempre que tenga acceso autorizado a esa carpeta y a las herramientas necesarias.
En ambos casos debes aplicar la misma regla: delegar la ejecución de pasos no equivale a delegar la responsabilidad sobre el resultado. Comprueba qué archivos se han leído y modificado, valida los datos obtenidos y revisa el resultado final antes de utilizarlo o compartirlo.
PERMISOS Y DATOS SENSIBLES
No concedas acceso indiscriminado a todo tu equipo. Separa, cuando sea posible, el proyecto de desarrollo de tus documentos personales, claves privadas, archivos de configuración y credenciales. Nunca pegues secretos en una conversación ni los incluyas en un repositorio para que el modelo los «entienda». Usa variables de entorno, gestores de secretos y permisos mínimos.
Puedes tomar la decisión a partir de cuatro preguntas:
Esta elección no es permanente. Puedes pasar de una herramienta a otra a medida que avance el trabajo. Un flujo razonable para una aplicación pequeña sería:
La frontera entre estas herramientas puede cambiar con nuevas versiones. El método, en cambio, sigue siendo válido: especificar antes de actuar, revisar lo que se propone, ejecutar de forma controlada y comprobar el resultado. Claude puede acelerar cada fase, pero la decisión sobre qué construir, qué aceptar y cuándo está listo continúa siendo tuya.
Claude Code puede leer archivos, analizar un proyecto, proponer cambios y ejecutar determinadas acciones desde la terminal. Claude IA también puede explicar conceptos, generar código, redactar pruebas y ayudarte a investigar errores. Estas capacidades aceleran el trabajo, pero no trasladan la responsabilidad del resultado al modelo.
La distinción es sencilla:
Claude puede sugerir una forma razonable de resolver un problema. No puede decidir por ti qué significa exactamente «razonable» en tu contexto, qué datos deben protegerse, qué riesgos son aceptables ni qué comportamiento espera realmente una persona usuaria.
Programar con IA sin perder el control consiste en mantener esas decisiones fuera de la caja negra. El modelo puede escribir una función, pero tú debes saber para qué sirve, qué entradas acepta, qué devuelve y qué puede salir mal.
Cuando una petición es ambigua, Claude debe completar los huecos con supuestos. Algunos serán acertados; otros no. El problema no suele estar en que el modelo no sepa escribir código, sino en que ha recibido una descripción insuficiente del problema.
Compara estas dos instrucciones:
> Crea una aplicación para gestionar tareas.
La petición no define el tipo de usuario, las operaciones necesarias, el formato de los datos, el sistema de almacenamiento ni el criterio para considerar terminado el trabajo. Claude tendrá que inventar una parte importante del diseño.
Una especificación más útil sería:
> Crea una aplicación web pequeña para gestionar tareas personales. Cada tarea tendrá título, descripción opcional, estado y fecha de vencimiento. El usuario podrá crear, consultar, editar y eliminar tareas. La aplicación debe impedir títulos vacíos, mostrar un mensaje de error comprensible y conservar los datos al reiniciarse. Antes de modificar archivos, inspecciona la estructura del proyecto y propón un plan. No añadas autenticación ni dependencias nuevas sin justificarlo.
La segunda petición no garantiza que el resultado sea correcto, pero reduce la cantidad de decisiones ocultas. También indica a Claude cómo debe trabajar: primero inspeccionar, después planificar y solo entonces modificar.
Una especificación eficaz suele incluir:
No es necesario redactar un documento extenso para cada cambio. En una tarea pequeña puede bastar con tres o cuatro frases precisas. Lo importante es que la intención no dependa de suposiciones que nunca se han expresado.
En un flujo de desarrollo, Claude Code puede ayudarte con tareas como estas:
Estas acciones son útiles porque reducen el trabajo mecánico y aceleran la exploración de alternativas. Sin embargo, cada una tiene límites.
Claude no conoce automáticamente todos los requisitos de tu negocio. Puede interpretar mal una regla, usar una biblioteca incompatible, omitir un caso límite o recomendar una solución que funciona en un ejemplo sencillo pero falla con datos reales. También puede afirmar que una prueba ha pasado cuando no se ha ejecutado, interpretar de forma incorrecta la salida de una herramienta o introducir un cambio fuera del objetivo inicial.
Por eso conviene distinguir entre proponer, ejecutar y verificar:
Que Claude escriba una prueba no demuestra que el programa sea correcto. Que ejecute una prueba tampoco demuestra que se hayan cubierto todos los comportamientos importantes. Y que una aplicación se inicie no significa que esté preparada para recibir datos no confiables o para usarse en producción.
Tu responsabilidad se concentra en las decisiones que afectan al propósito y al riesgo del sistema. Antes de aceptar un cambio, debes poder responder, al menos, a estas preguntas:
También decides qué información puede recibir el modelo. No debes pegar contraseñas, claves privadas, tokens, datos personales innecesarios ni información confidencial solo para obtener una respuesta más cómoda. Antes de compartir un archivo, elimina secretos y comprueba si contiene datos que no son necesarios para resolver el problema.
La decisión más importante es aceptar o rechazar el resultado. El código generado no adquiere autoridad por estar bien formateado, por utilizar nombres convincentes o por haber sido producido por un modelo avanzado. Debe superar tus criterios técnicos y funcionales.
AVISO IMPORTANTE
No ejecutes sin revisar comandos que borren archivos, modifiquen permisos, instalen dependencias desconocidas, cambien la configuración del sistema o trabajen con datos reales. Lee el comando, entiende sus efectos y conserva una forma de volver atrás, por ejemplo mediante control de versiones o una copia segura.
Un flujo controlado puede resumirse en cuatro fases: especificar, revisar, ejecutar y mejorar. No son pasos aislados. Se repiten en cada tarea, desde corregir un error de validación hasta construir un proyecto completo.
Describe el resultado esperado antes de pedir una implementación. Indica el contexto que Claude necesita y separa los requisitos de las preferencias.
Por ejemplo:
> En este proyecto usamos Python y pytest. Necesito validar un formulario de registro. El correo debe tener un formato válido, la contraseña debe contener al menos doce caracteres y el nombre no puede estar vacío. La validación debe devolver errores asociados a cada campo, sin lanzar excepciones para entradas del usuario. Revisa primero la implementación actual y propón los casos de prueba que faltan.
Esta petición aporta el lenguaje, el marco de pruebas, las reglas y el comportamiento esperado ante entradas inválidas. También evita que Claude cambie directamente el código sin conocer antes la implementación existente.
Si la tarea es grande, pide primero un plan. Un plan útil debe identificar los archivos afectados, los cambios principales, las dependencias y la estrategia de pruebas. En esta fase no buscas todavía el código definitivo. Buscas comprobar que Claude ha entendido el problema.
Lee el plan y compáralo con tus requisitos. Comprueba especialmente lo que el modelo da por supuesto.
Una revisión inicial puede plantear preguntas como:
Pedir que el modelo explique sus decisiones no sustituye a una revisión técnica, pero hace visibles sus supuestos. Puedes solicitar que presente dos alternativas y compare sus costes, riesgos y complejidad. En ocasiones la primera solución funciona, pero introduce una capa innecesaria o complica el mantenimiento.
La revisión también incluye el alcance. Si pediste corregir una función y Claude propone reorganizar diez archivos, detén el proceso y pide una justificación. Los cambios amplios pueden ser válidos, pero no deben aparecer de forma accidental.
Cuando el plan sea aceptable, permite que Claude realice una parte concreta del trabajo. Trabaja en cambios pequeños y observables. Es más fácil revisar una modificación de veinte líneas que una reescritura completa de un módulo.
Después de cada cambio, revisa el diff y ejecuta las comprobaciones correspondientes. Estas pueden incluir:
No aceptes una frase como «todo funciona» sin una evidencia concreta. Pregunta qué comando se ejecutó, qué resultado produjo y qué casos no se probaron. La respuesta debe distinguir entre lo que se ha comprobado y lo que solo se espera que funcione.
La primera implementación rara vez es la última. Una vez que el cambio funciona, pide una revisión específica. No conviene solicitar simplemente «mejora el código», porque una instrucción tan amplia puede generar cambios innecesarios.
Puedes pedir, por ejemplo:
> Revisa este cambio sin modificar su comportamiento. Busca duplicación, nombres ambiguos, errores de manejo de excepciones y problemas de seguridad relacionados con la entrada del usuario. Devuelve primero una lista priorizada de hallazgos. No cambies archivos todavía.
Esta forma de trabajo separa el diagnóstico de la modificación. Primero decides qué observaciones son válidas y cuáles merecen atención. Después autorizas cambios concretos.
La mejora también puede afectar a la documentación. Si una función tiene un comportamiento importante, documenta sus entradas, salidas, errores y límites. El código generado será más fácil de revisar dentro de unas semanas si explica las decisiones que no resultan evidentes al leerlo.
Imagina que quieres añadir una función para importar tareas desde un archivo CSV. Claude puede ayudarte a crear el lector, detectar columnas y generar pruebas. Pero varias decisiones requieren criterio humano:
Claude puede ofrecer alternativas para cada punto. Tú decides cuál encaja con el producto, los datos y el nivel de riesgo. Después puedes pedirle que implemente la alternativa elegida y que escriba pruebas para los casos definidos.
Este reparto evita dos errores opuestos. El primero es dejar que la IA tome decisiones de producto que nadie ha validado. El segundo es rechazar toda ayuda automática y repetir manualmente tareas que el modelo puede realizar con rapidez. El objetivo es asignar a cada parte el trabajo que puede hacer mejor: Claude explora, redacta y transforma; tú defines, verificas y respondes por el resultado.
EJEMPLO
Para una tarea de autenticación, no pidas únicamente «añade inicio de sesión». Define el comportamiento: qué campos se reciben, cómo se almacenan las contraseñas, qué respuesta se devuelve ante credenciales incorrectas, cómo se limita el número de intentos y qué datos quedan registrados.
Después solicita un plan y una revisión de seguridad antes de implementar. La seguridad no debe quedar como una mejora opcional al final, porque las decisiones iniciales sobre sesiones, contraseñas y errores condicionan toda la solución.
El proceso necesita una pausa cuando ocurre alguna de estas situaciones:
En esos casos, vuelve a un punto conocido del repositorio, resume el objetivo y trabaja con una tarea más pequeña. El control no consiste en escribir cada línea manualmente. Consiste en conservar una visión precisa del sistema, sus límites y las razones de cada modificación.
Antes de aceptar un resultado generado por IA, aplica esta regla:
> Si no puedes describir qué hace el código, por qué lo hace y cómo lo has comprobado, todavía no está listo para formar parte de tu proyecto.
Claude Code puede aumentar mucho tu velocidad, especialmente cuando necesitas explorar una tecnología, preparar una primera versión o automatizar tareas repetitivas. Su valor crece cuando lo utilizas dentro de un proceso explícito. Especifica el objetivo, revisa el plan, ejecuta cambios acotados, comprueba el resultado y mejora lo necesario. La IA aporta capacidad de producción; el criterio sobre el software sigue siendo tuyo.
Programar con Claude Code no consiste en escribir una instrucción extensa y aceptar todo lo que produzca. El resultado depende de un ciclo de trabajo repetible:
Este ciclo mantiene separadas dos responsabilidades. Claude puede analizar archivos, proponer soluciones, escribir código y ayudarte a investigar un error. Tú sigues siendo responsable de decidir qué problema se está resolviendo, qué comportamiento es correcto y si el resultado es seguro para usarlo.
La regla práctica es sencilla: Claude propone y ejecuta cambios; tú defines los criterios de aceptación y validas el resultado.
Claude Code trabaja sobre un directorio de proyecto. Puede leer los archivos que le indiques, examinar la estructura, consultar configuraciones y utilizar herramientas disponibles en el entorno, según los permisos concedidos. Sin embargo, tener acceso a un proyecto no significa que la herramienta conozca automáticamente tus objetivos, restricciones o decisiones de diseño.
Antes de pedir una modificación, proporciona cuatro datos:
Por ejemplo, «añade autenticación» es una petición demasiado amplia. No especifica el tipo de usuarios, el mecanismo de sesión, las rutas afectadas, la persistencia de datos ni los requisitos de seguridad. Una petición más útil sería:
> Añade un middleware para proteger las rutas que empiezan por /admin. Usa la sesión existente del proyecto y no modifiques el esquema de la base de datos. Si el usuario no está autenticado, devuelve un error 401 en la API. Antes de editar archivos, inspecciona cómo se gestionan actualmente las sesiones y dime qué archivos piensas modificar.
La última frase es importante. Pedir un plan previo permite detectar malentendidos antes de que aparezcan cambios en el código. Para tareas con varias partes, conviene trabajar en dos fases:
No es necesario adjuntar todo el proyecto en cada petición. Es mejor indicar dónde está la información relevante. Por ejemplo:
> Revisa src/auth/, src/routes/ y las pruebas relacionadas con sesiones. No analices todavía el resto del proyecto. Identifica cómo se determina si una petición pertenece a un usuario autenticado y señala los puntos que habría que modificar para proteger /admin.
Este enfoque reduce el ruido y facilita que la respuesta se centre en el problema actual. También ayuda a controlar el contexto disponible: cuanto más código irrelevante se incluye, más difícil resulta distinguir las dependencias importantes.
Una vez acordado el plan, divide la implementación en cambios que puedan comprobarse de forma independiente. En lugar de pedir «construye toda la aplicación», empieza por una pieza concreta:
Cada cambio debe tener un resultado observable. Si el cambio modifica cinco áreas distintas sin una razón clara, será más difícil localizar un fallo y revisar la propuesta.
Una petición operativa puede seguir esta estructura:
> Implementa el primer punto del plan. Modifica únicamente src/auth/middleware.ts y los archivos de prueba necesarios. Conserva la API pública existente. Añade una prueba para una petición autenticada y otra para una petición sin sesión. No cambies la configuración de producción. Cuando termines, resume los archivos modificados y los comandos que debo ejecutar para validar el cambio.
La indicación «modifica únicamente» no garantiza por sí sola que no haya otros cambios, pero establece un límite claro que después podrás comprobar mediante el control de versiones.
En un proyecto con Git, revisa siempre el estado antes de empezar. Los comandos siguientes muestran la rama actual, los archivos modificados y las diferencias pendientes:
BASH
git status --short git branch --show-current git diff --stat git diff
El primer comando resume los archivos modificados. El segundo indica la rama activa. Los dos últimos permiten conocer el tamaño y el contenido de las diferencias. Si ya existían cambios sin confirmar, anótalos o guárdalos antes de pedir una tarea nueva. De lo contrario, podrías atribuir a Claude un cambio que ya estaba presente.
Después de cada modificación, vuelve a consultar el estado y la diferencia:
BASH
git status --short git diff -- src/auth/middleware.ts tests/auth/middleware.test.ts
La segunda orden limita la revisión a dos rutas concretas. Si Claude ha tocado otro archivo, git status lo mostrará.
Que el código se pueda ejecutar no significa que sea correcto. Ejecutar una aplicación solo demuestra que ha superado una parte del proceso. Una validación profesional combina varias comprobaciones:
Pide a Claude que identifique los comandos de validación del proyecto, pero no asumas que la lista es correcta. Comprueba los scripts y la configuración existentes. En un proyecto de Node.js, por ejemplo, podrías encontrar comandos como los siguientes en package.json:
BASH
npm run lint npm test npm run build
Cada comando debe ejecutarse desde el directorio adecuado y con las dependencias instaladas. Si uno falla, conserva el mensaje completo del error y proporciona a Claude el contexto necesario:
> npm test falla en tests/auth/middleware.test.ts. El error completo es el siguiente: [...]. Analiza primero si el fallo procede de la implementación, de la prueba o de la configuración. No cambies la prueba para ocultar el error sin explicar antes por qué la expectativa es incorrecta.
Esta última restricción evita una solución frecuente y peligrosa: modificar la prueba para que acepte una implementación defectuosa. Las pruebas son parte del contrato del sistema. Si una expectativa ya no representa el comportamiento deseado, debe cambiarse con una justificación explícita, no únicamente porque dificulta que el comando termine correctamente.
NO ACEPTES «YA ESTÁ PROBADO» COMO RESULTADO
Pide los comandos exactos que se ejecutaron, su salida y cualquier limitación de la comprobación. Una respuesta de Claude no sustituye al resultado real de una prueba. Si no se ha ejecutado un comando, debe quedar indicado como pendiente.
La explicación de Claude puede ser clara y aun así ocultar un error. La revisión debe centrarse en el código y en los efectos del cambio.
Comprueba, como mínimo, estos puntos:
Una revisión eficaz puede dividirse en dos lecturas. En la primera, comprueba el diseño general: si la solución está en el lugar adecuado y si respeta la arquitectura existente. En la segunda, revisa los detalles: condiciones, tipos, valores nulos, excepciones, consultas, permisos y datos que cruzan los límites de la aplicación.
También conviene pedir una revisión independiente después de implementar una tarea:
> Revisa el cambio actual como si fueras responsable de aprobarlo. Busca errores funcionales, problemas de seguridad, casos límite y regresiones. No propongas mejoras de estilo que no afecten al comportamiento hasta haber identificado primero los riesgos. Para cada problema, indica el archivo, la línea aproximada, la consecuencia y una forma de reproducirlo.
La petición funciona mejor si se realiza después de ejecutar las pruebas y revisar la diferencia. Claude dispondrá entonces de información concreta, y no tendrá que inferir qué se ha modificado.
Cuando una prueba falla, no conviene enviar una instrucción vaga como «arréglalo». Esa petición puede provocar cambios amplios y dificultar la investigación. Un ciclo de depuración más controlado contiene:
Por ejemplo:
> La función parse_price debe aceptar "12.50" y devolver 12.5. Para una cadena vacía debe devolver un error de validación. Actualmente acepta "12,50" y devuelve 1250. El problema se reproduce ejecutando pytest tests/test_prices.py. Analiza primero la causa. No cambies el formato aceptado sin indicarlo y añade una prueba que cubra el separador decimal incorrecto.
La separación entre diagnóstico y corrección resulta útil. Primero pide una hipótesis y una prueba que la confirme. Después solicita el cambio. Así reduces el riesgo de que se modifique el código basándose en una explicación equivocada.
Cuando el cambio sea correcto, deja el proyecto en un estado comprensible:
Un mensaje de commit útil describe el comportamiento, no la interacción con la herramienta:
BASH
git add src/auth/middleware.ts tests/auth/middleware.test.ts git commit -m "Protege las rutas administrativas con la sesión existente"
El comando git add debe incluir únicamente los archivos que pertenecen a esa tarea. Antes de confirmar el commit, revisa de nuevo el estado para evitar incluir credenciales, archivos temporales o cambios de otra tarea.
Puedes aplicar el ciclo completo con esta secuencia:
Primero, inspecciona. Describe el objetivo y pide que se localicen los archivos, dependencias y pruebas relevantes. Todavía no solicites cambios si el problema no está claro.
Después, define el plan. Pide una propuesta breve, con los archivos que se modificarán, los riesgos y la forma de validar el resultado.
A continuación, implementa una parte. Limita el alcance y exige que se mantengan las interfaces que no forman parte de la tarea.
Ejecuta las comprobaciones. Usa las pruebas, el análisis estático y la compilación disponibles en el proyecto.
Revisa la diferencia. Comprueba el código generado, los archivos modificados y los efectos de seguridad o compatibilidad.
Corrige mediante nueva evidencia. Entrega errores reproducibles y solicita cambios específicos, sin reiniciar el proyecto desde cero.
Cierra el ciclo. Documenta la decisión, confirma las pruebas ejecutadas y guarda el cambio en el control de versiones.
Este procedimiento evita dos extremos. En uno, el desarrollador acepta código que no entiende porque funciona en el primer intento. En el otro, revisa manualmente cada carácter sin aprovechar la capacidad de Claude para explorar, explicar y automatizar tareas repetitivas.
La productividad no procede de eliminar la revisión. Procede de hacer que la revisión se apoye en cambios pequeños, pruebas reproducibles y criterios explícitos. Claude Code puede acelerar cada etapa, pero el control se conserva cuando sabes qué has pedido, qué se ha modificado y qué evidencia demuestra que el resultado es válido.
¿Quieres saber cómo sigue? Consigue el libro completo:
Precios consultados en las tiendas el 16/11/2026; pueden cambiar.
Volver a la ficha