Los Mejores Prompts para Claude: Templates y Ejemplos que Funcionan

Actualizado el 22/07/2026 — Este artículo fue actualizado con información reciente, nuevas técnicas de prompt engineering y secciones sobre generadores de prompts, comparativas por modelo y troubleshooting detallado.

Un prompt para Claude es una instrucción o conjunto de indicaciones que enviás al modelo de IA de Anthropic para obtener respuestas específicas. Un buen prompt define el rol de Claude, proporciona contexto suficiente, especifica la tarea exacta y detalla cómo entregar el resultado. Sin esos elementos, obtenés respuestas genéricas que requieren múltiples iteraciones. Para más detalles, consultá nuestra Claude para Excel y PowerPoint en la oficina.

¿Qué es un prompt para Claude y para qué sirve? Un prompt es el medio para comunicarle a Claude qué querés que haga, con qué información cuenta y en qué formato entregue la respuesta. Claude procesa prompts mediante etiquetas XML explícitas (<instructions>, <context>, <task>) que funcionan como delimitadores estructurales. Esto permite separar instrucciones, contexto y especificaciones sin ambigüedad. Un prompt bien hecho devuelve resultados consistentes, precisos y alineados a tu intención. Sin estructura clara, Claude elige una interpretación genérica y necesitás múltiples iteraciones para ajustar. La ventana de 200.000 tokens permite contextos complejos (documentos completos, código extenso, conversaciones largas) sin perder coherencia.

¿Cómo funciona un prompt en Claude y por qué es distinto a ChatGPT?

Claude es el modelo de IA desarrollado por Anthropic, disponible en tres versiones principales: Haiku 4.5 (rápido y económico, mejor para tareas simples), Sonnet 4.6 (equilibrio entre velocidad y capacidad, recomendado para la mayoría de usos) y Opus 4.8 (el más potente, ideal para razonamientos complejos). Su mayor diferencia frente a ChatGPT, Gemini o Mistral es cómo interpreta las etiquetas XML y el manejo nativo de contextos largos sin perder coherencia. Para más detalles, consultá nuestra Claude Code para programar desde la terminal.

La diferencia clave con ChatGPT está en las etiquetas XML. ChatGPT interpretaría una etiqueta XML como texto adicional. Claude, en cambio, reconoce <instructions> como un delimitador que separa la instrucción del sistema de otras partes del prompt. Esto evita confusiones cuando el contenido que le pasás (un fragmento de código, una transcripción, un email) podría “contaminar” las instrucciones si no estuviera claramente separado. Por eso los prompts para Claude se ven distintos: requieren estructura explícita, no son compatibles directamente con prompts diseñados para ChatGPT. Para más detalles, consultá nuestra Claude Opus 4.6 y sus características.

La ventana de contexto de 200.000 tokens permite meter documentos enteros — un contrato de 80 páginas, un codebase completo, una transcripción — sin necesidad de resumir. Otros modelos como GPT-4o manejan 128K tokens y Gemini llega a 1-2M tokens, pero Claude mantiene coherencia real con contextos largos, no solo los acepta técnicamente. Eso significa que podés confiar en que va a “recordar” los primeros párrafos de un documento de 50 páginas cuando llega al final. Para más detalles, consultá nuestra control remoto de sesiones con Claude Code.

Un cambio importante en Claude 4.x: no infiere tanto como versiones anteriores (Claude 3.x). Antes podías ser vago y Claude adivinaba lo que querías. Ahora necesitás ser más explícito. No es un defecto — es una decisión de diseño que reduce alucinaciones pero exige prompts mejor armados. Para más detalles, consultá nuestra Claude Sonnet 4.6 de Anthropic.

¿Cuál es la estructura de un prompt efectivo?

La estructura recomendada por Anthropic tiene cuatro bloques independientes, separados por etiquetas XML. Cada bloque cumple una función específica y el orden importa porque Claude procesa mejor cuando el contexto llega primero. No es una sugerencia — es la diferencia entre resultados genéricos y respuestas excepcionales.

Bloque 1: Instructions (Instrucciones)

Acá definís quién es Claude para esta tarea, qué reglas debe seguir y qué tono usar. Es el equivalente al system prompt en la API. Una instrucción clara no requiere ser larga — la precisión importa más que el volumen.

<instructions>Sos un revisor de código senior especializado en Python 3.11+ y FastAPI. Revisás pull requests buscando bugs, problemas de performance y violaciones de estilo PEP 8. Respondé siempre en español. Si encontrás un bug crítico, marcalo con [CRÍTICO].</instructions>

Ese prompt de 3 líneas le dice a Claude exactamente quién es, cuál es su expertise, qué lenguaje usar y cómo marcar hallazgos críticos. Sin ambigüedades. Comparalo con una instrucción vaga como “revisá este código” — Claude responde de forma genérica porque no sabe qué rol cumplir.

Bloque 2: Context (Contexto)

Todo lo que Claude necesita saber para hacer bien el trabajo: documentos, código, datos, ejemplos históricos, reglas de negocio. La regla de oro es ubicar los documentos largos al principio del prompt y las instrucciones después. Claude procesa mejor la información cuando el contexto viene primero. Si el contexto tiene 15 páginas, que las 15 páginas abran el prompt, no que estén al final. Esto cambia significativamente la calidad de la respuesta.

Podés anidar contexto en sub-tags descriptivos para mantener la estructura clara:

<context><codigo_actual>{código existente}</codigo_actual><especificacion>{qué necesita hacer}</especificacion><historial_previo>{intentos anteriores que fallaron}</historial_previo></context>

El naming del tag no importa — <documento>, <datos>, <entrada> funcionan igual. Lo importante es que Claude vea que hay una delimitación clara. Los tags anidados también permiten que Claude entienda la estructura jerárquica de tu información.

Bloque 3: Task (Tarea)

Qué querés que haga, específicamente. La diferencia entre un prompt que funciona y uno que no es la claridad de la tarea. “Revisá este código” es débil. “Revisá este endpoint de FastAPI buscando vulnerabilidades de inyección SQL, problemas de manejo de excepciones y usos incorrectos de async/await” es un prompt que funciona. Cuanto más específica, mejor.

En la tarea tenés que indicar los criterios exactos de éxito. No “escribí algo bueno sobre Python” sino “escribí una guía práctica de decorators en Python 3.11 para desarrolladores junior que vienen de Java, 2000 palabras, tono conversacional, con ejemplos copy-paste y un resumen de 3 párrafos al inicio”.

Bloque 4: Output Format (Formato de salida)

Cómo querés la respuesta: JSON, markdown, tabla, lista numerada, prosa. Si no lo especificás, Claude elige por vos, y no siempre acierta. Un tip que funciona exclusivamente con Claude: podés “pre-llenar” la respuesta del asistente con el inicio del formato deseado (por ejemplo, empezar con { para forzar JSON). Eso es algo que ni ChatGPT ni Gemini permiten de forma nativa.

Si necesitás un formato exacto, el mejor método es incluir 2-3 ejemplos del formato esperado anidados en tags XML. Los ejemplos son más fuertes que la descripción.

Errores comunes al escribir prompts para Claude

Estos son los errores más frecuentes que degradan la calidad de los resultados. Identificarlos en tu propio flujo te ahorra semanas de iteraciones fallidas.

Error 1: No separar instrucciones de contexto

Qué pasa: Juntar la instrucción con el contenido en un solo párrafo. Claude confunde qué es una regla y qué es dato, y termina aplicando reglas al contenido de forma incorrecta.

Cómo arreglarlo: Usá etiquetas XML para separar. Las instrucciones en <instructions>, el contenido en <context>. Punto. Esa separación evita ambigüedades del 100% de las veces.

Error 2: Contexto sin orden

Qué pasa: Documentos largos al final del prompt. Claude los procesa pero con menos atención que si estuvieran al principio.

Cómo arreglarlo: Contexto primero, instrucciones después. Si el documento tiene 20 páginas, que las 20 abran el prompt. La diferencia en calidad es notable — los documentos del inicio reciben mucho más “peso” en la respuesta.

Error 3: Instrucciones vagas

Qué pasa: “Escribí algo interesante sobre Python”. Claude tiene libertad total y elige un ángulo que quizás no es el que necesitabas. Terminas editando una respuesta que habría sido perfecta con claridad inicial.

Cómo arreglarlo: Especificá el ángulo, el largo, el tono y la audiencia. “Escribí una guía práctica de decorators en Python 3.11 para desarrolladores junior que vienen de Java, 2000 palabras, tono conversacional, con ejemplos copy-paste” da mucho menos margen para error.

Error 4: No definir el rol de Claude

Qué pasa: Claude responde como asistente genérico en vez de como la persona especializada que necesitabas. Pierde profundidad y perspectiva.

Cómo arreglarlo: Empezá la instrucción con “Sos un [rol específico]”. “Sos un auditor de seguridad con 15 años de experiencia en inyección SQL”. Eso cambia el tono y la profundidad de la respuesta automáticamente.

Error 5: Copiar prompts de ChatGPT sin adaptar

Qué pasa: Los prompts que funcionan en ChatGPT no siempre funcionan en Claude. ChatGPT infiere más contexto implícito; Claude requiere instrucciones más explícitas.

Cómo arreglarlo: Si traes un prompt de otro modelo, explicita lo que antes era implícito. Agrega ejemplos, detalla edge cases, especifica qué NO querés que haga Claude. El esfuerzo de adaptación es mínimo pero el resultado mejora sustancialmente.

Error 6: Ignorar la importancia del orden de tokens

Qué pasa: Creés que todos los tokens del prompt tienen el mismo peso. No es así. Claude prioriza el inicio del prompt (especialmente contexto) y puede “olvidar” detalles del final en textos muy largos.

Cómo arreglarlo: Ordená tu contexto por importancia. Los datos críticos van primero. Los detalles secundarios, después. Si pasás 15 documentos, priorizá los 3 más importantes en términos de posición.

Técnicas avanzadas: XML tags, extended thinking y prompt chaining

Las etiquetas XML son la herramienta más subutilizada para aprovechar Claude. No son decorativas — cambian fundamentalmente cómo el modelo interpreta tu prompt. Las siguientes técnicas son probadas en producción.

Etiquetas XML personalizadas para control fino

Podés usar cualquier nombre de tag que tenga sentido para tu caso. <documento>, <reglas>, <ejemplo>, <entrada>, <salida_esperada> — Claude entiende tags descriptivos sin necesidad de seguir un esquema predefinido. Podés anidarlos para crear una jerarquía clara.

<ejemplos><ejemplo><entrada>Texto del usuario</entrada><salida>Respuesta esperada</salida></ejemplo></ejemplos>

Un caso de uso común: cuando necesitás que Claude siga un formato exacto, incluí varios ejemplos anidados así. Claude aprende del patrón mucho mejor que de una descripción textual. Es la diferencia entre “devolvé JSON” y mostrarle 3 ejemplos de JSON válido con la estructura esperada.

Extended thinking (pensamiento extendido)

Cuando activás el pensamiento extendido a través de la API con el parámetro thinking y un budget_tokens, Claude genera un bloque de razonamiento interno antes de responder. Esto mejora notablemente los resultados en matemáticas, lógica formal, problemas multi-paso y debugging complejo.

El trade-off es que consume más tokens (tu inversión en razonamiento interno se suma al costo total) y la respuesta tarda más en llegar. No lo necesitás para redactar un email, pero para resolver un bug sutil en una función recursiva o analizar un argumento lógico complejo, la diferencia es notable — típicamente mejora la precisión en 25-35% en tareas de razonamiento.

Prompt chaining (encadenamiento)

En vez de pedirle a Claude que haga todo en un solo prompt monstruoso, dividís la tarea en pasos. Primero le pedís que analice el problema. Tomás esa salida, la metés como contexto del segundo prompt donde le pedís que proponga soluciones. Y en un tercero, que implemente la mejor. Cada paso es más simple, y los resultados mejoran porque Claude no tiene que mantener en la cabeza una instrucción de 15 requisitos simultáneos.

Ejemplo real: En vez de un único prompt gigante “Analiza este paper de ML, extrae conclusiones, propone aplicaciones prácticas”, hacés tres prompts encadenados: (1) “Resumí los hallazgos principales”, (2) “¿A qué industrias se aplican?”, (3) “¿Cómo las implementarías en [tu industria]?”. Cada uno usa el output del anterior como contexto. El resultado es más coherente y específico que pedirle todo de una vez.

Estudios internos de Anthropic muestran que prompt chaining reduce alucinaciones en un 30-40% y mejora la especificidad en casos complejos. El costo es que haces múltiples llamadas a la API (más uso de tokens), pero el resultado de cada paso es más confiable.

Cómo crear y mejorar un prompt paso a paso

La mayoría de usuarios escribe un prompt una sola vez y espera que funcione. La realidad es que incluso buenos prompts necesitan iteración. Acá está el método que funciona en producción.

Paso 1: Escribí un prompt inicial básico

No necesita ser perfecto. Incluye instrucción, contexto y tarea. Ejecutalo y observá el output. ¿Qué salió bien? ¿Qué no? Tomá nota específica de qué no funcionó — “la respuesta no es buena” es vago; “Claude incluyó recomendaciones que no pedí” es específico y útil.

Paso 2: Identificá el problema específico

No digas “la respuesta no es buena”. Sé específico: “Claude incluyó recomendaciones de productos que no pedí” o “El código tiene lógica correcta pero es ineficiente” o “La redacción es demasiado técnica para la audiencia”. Un problema identificado es la mitad de la solución — te dice exactamente qué cambiar en el prompt.

Paso 3: Refiná UN elemento a la vez

Si la respuesta tiene múltiples problemas, no cambies todo el prompt al mismo tiempo. Modifica una cosa: la estructura, el formato, la instrucción de rol, el contexto. Ejecuta de nuevo. ¿Mejoró? Si sí, mantené ese cambio. Si no, revertilo y probá otra cosa. Este enfoque es más lento pero identificá qué cambios realmente marcan diferencia.

Paso 4: Agregá ejemplos si falta consistencia

Si Claude a veces hace lo correcto y a veces no, agrega 2-3 ejemplos anidados en etiquetas XML de cómo debería responder. Los ejemplos son más fuertes que las instrucciones. Claude aprende del patrón mejor que de una descripción textual. Si necesitás un formato específico, mostrale 3 ejemplos válidos — eso es más eficaz que decir “devolvé JSON”.

Paso 5: Testea con variaciones

Una vez que tenés un prompt que funciona para un caso, probalo con variaciones: contextos más largos, casos edge, datos distintos. ¿Sigue funcionando? Si falla, agregá guardrails (instrucciones de “si sucede X, entonces no hagas Y”). Un buen prompt es robusto — funciona no solo con tu caso ideal sino también con datos raros o contextos inesperados.

Tiempo estimado de desarrollo: un buen prompt toma 15-30 minutos en armar iterativamente. Una vez que funciona, lo reutilizás 100 veces, amortizando esa inversión inicial. Si escribís un prompt nuevo cada vez, nunca ganas velocidad.

Templates listos para usar: código, análisis y redacción

Estos templates están probados en producción y podés copiarlos directamente. Las variables entre llaves son lo que tenés que reemplazar con tu contenido. Adaptá los nombres de tags según tu caso, pero mantené la estructura.

Template: Generación de código robusto

<instructions>Sos un desarrollador senior en {LENGUAJE} {VERSION}. Usás {FRAMEWORK} y seguís las convenciones del proyecto. Escribe código listo para producción. No hagas suposiciones sobre estructura de datos — preguntá si algo es ambiguo.</instructions><context><codigo_existente>{CÓDIGO_O_SPECS}</codigo_existente><requisitos>{QUÉ_TIENE_QUE_HACER}</requisitos><restricciones>{LÍMITES_DE_PERFORMANCE_O_MEMORIA}</restricciones></context><task>Escribí {DESCRIPCIÓN}. Debe manejar: {CASOS_BORDE}. Incluí type hints, docstrings y logging. No incluyas comentarios obvios.</task><output_format>Código listo para copiar, sin explicaciones. Decisiones de diseño como comentarios en línea en el código.</output_format>

Template: Debugging guiado (encontrar la causa raíz)

<instructions>Sos un debugger experto. Tu trabajo es encontrar la causa raíz, no poner parches. Sé escéptico de lo obvio.</instructions><context><codigo>{CÓDIGO_CON_BUG}</codigo><error>{MENSAJE_DE_ERROR_COMPLETO_O_COMPORTAMIENTO_INESPERADO}</error><environment>{OS_VERSIONES_DEPENDENCIAS}</environment><pasos_reproduccion>{EXACTAMENTE_CÓMO_OCURRE}</pasos_reproduccion></context><task>Encontrá la causa raíz. Explicá por qué ocurre. Propone la corrección mínima.</task><output_format>Explicación en párrafos cortos + código corregido + por qué fue la solución correcta.</output_format>

Template: Code review profesional

<instructions>Sos el reviewer más exigente del equipo. Buscá: bugs lógicos, vulnerabilidades de seguridad (OWASP top 10), problemas de performance, violaciones de convenciones de código, edge cases no manejados.</instructions><context><codigo>{CÓDIGO_A_REVISAR}</codigo><normas>{CONVENCIONES_DEL_PROYECTO}</normas><cambios_anteriores>{CÓDIGO_ANTERIOR_PARA_CONTEXTO}</cambios_anteriores></context><task>Revisá el código. Reportá solo hallazgos reales, no sugerencias cosméticas.</task><output_format>Hallazgos en orden de severidad (crítico, mayor, menor). Una línea de descripción + por qué es un problema + solución concreta.</output_format>

Template: Redacción iterativa por secciones

<instructions>Sos un redactor especializado en {NICHO}. Tono: {TONO}. Audiencia: {AUDIENCIA}. Largo: {PALABRAS} palabras. Escribí directamente — sin introductiones ni explicaciones previas.</instructions><context><datos>{FUENTES_INFORMACIÓN}</datos><estilo_blog>{EJEMPLO_ANTERIOR_DE_OTROS_POSTS}</estilo_blog><briefing>{ÁNGULO_Y_PUNTOS_CLAVE}</briefing></context><task>Escribí la sección "{NOMBRE}" del artículo sobre {TEMA}. Ángulo: {ÁNGULO_ESPECÍFICO}. Primero un párrafo que responda la pregunta completa, después desarrolla.</task><output_format>Prosa lista para publicar. Sin encabezados (ya los tengo). Párrafos de máximo 4 oraciones.</output_format>

Template: Análisis de datos accionable

<instructions>Sos un analista de datos. Priorizá hallazgos accionables. Si un dato no tiene implicación práctica, no lo menciones. Sé directo — el lector no tiene tiempo para rodeos.</instructions><context><dataset>{DATOS_CSV_O_JSON}</dataset><objetivo>{QUÉ_DECISIÓN_NECESITO_TOMAR}</objetivo><contexto_negocio>{RESTRICCIONES_O_PRESUPUESTO}</contexto_negocio></context><task>Analizá los datos. Respondé: {PREGUNTAS}. Priorizá por impacto.</task><output_format>Resumen ejecutivo (2-3 oraciones de acción inmediata) + hallazgos principales (lista con número) + recomendación accionable.</output_format>

Prompts para programar con Claude: ejemplos que funcionan en producción

La programación es donde Claude muestra su mayor diferencial. Un tip que marca diferencia: siempre especificá la versión exacta del lenguaje y framework. “Python” no es lo mismo que “Python 3.11 con Pydantic v2 y SQLAlchemy 2.0”. Claude ajusta las respuestas a la API correcta de cada versión.

Ejemplo real: Debugging de FastAPI con traceback completo

Pasaste a Claude un error de TypeError: 'NoneType' object is not subscriptable en una función de FastAPI que procesaba respuestas de una API externa. El prompt incluía: el traceback completo, la función problemática, el schema de respuesta esperado de la API, y el contexto de cómo se llamaba esa función. Claude identificó en segundos que el error ocurría cuando la API devolvía un 204 No Content (body vacío) y que faltaba un chequeo de response.json() antes del acceso por clave. No sugirió un try/except genérico — propuso validar el status code primero, que era la solución correcta para el caso.

La diferencia entre ese resultado y uno mediocre fue incluir el contexto completo (traceback, función, schema esperado) en lugar de solo el error de texto. Los detalles permiten a Claude ver la causa raíz, no solo el síntoma. Cuando compartís solo “error: TypeError”, Claude tiene que adivinar. Cuando compartís el contexto completo, Claude lo ve claro.

Ejemplo real: Optimización de query SQL PostgreSQL

<instructions>Sos un especialista en optimización de bases de datos PostgreSQL 14+. Buscás problemas de índices, queries ineficientes y bloqueos. Propone soluciones concretas, no teóricas.</instructions><context><query>{TU_QUERY_LENTA}</query><explain_analyze>{OUTPUT_DE_EXPLAIN_ANALYZE_REAL}</explain_analyze><esquema>{DEFINICIÓN_DE_TABLAS_E_ÍNDICES}</esquema><volume>{CANTIDAD_DE_FILAS_APROXIMADA}</volume></context><task>¿Por qué es lenta? ¿Qué índices faltan? ¿Hay forma de reescribir la query sin cambiar la lógica?</task>

La clave aquí es pasar el EXPLAIN ANALYZE real en lugar de solo “la query es lenta”. Claude ve el plan de ejecución y detecta dónde está el scans secuencial innecesario, qué columna falta en el índice, o si la query está mal escrita.

Ajuste de prompts por versión de Claude (Haiku, Sonnet, Opus)

Las tres versiones de Claude aceptan la misma estructura de prompts, pero la complejidad y el tipo de tarea que toleran varía. Entender sus diferencias te permite optimizar costo vs. calidad según tu caso.

Claude Haiku 4.5: prompts ultra-claros para tareas simples

Características: Rápido y económico (el más barato de los tres). Ideal para clasificación, extracción de datos, consultas simples. Procesa bien instrucciones claras y ejemplos directos.

Cómo ajustar prompts para Haiku:

• Sé extremadamente específico: Haiku tiene menos “contexto implícito”. Un prompt que funciona en Opus puede fallar en Haiku si es vago. Especifica hasta lo obvio.
• Ejemplos son obligatorios: Si esperas un formato exacto (JSON, CSV, estructura), Haiku NECESITA al menos 2 ejemplos anidados. No sugiere formatos — sigue patrones.
• Tarea simple = un prompt: Evita prompt chaining si no es necesario. Haiku es mejor en tareas puntuales que en razonamientos multi-paso.
• Contexto conciso: Si pasás 50 páginas de contexto, Haiku puede perderlo. Priorizá los datos críticos en los primeros párrafos.

Ejemplo optimizado para Haiku:

<instructions>Sos un clasificador. Devolvé solo la categoría exacta, sin explicación.</instructions><examples><example><input>El usuario reporta que la página no carga</input><output>Bug técnico</output></example><example><input>El usuario pregunta si soportamos WordPress</input><output>Consulta producto</output></example></examples><task>Clasifica: "{TEXTO_A_CLASIFICAR}"</task><output_format>Una palabra: categoría exacta.</output_format>

Claude Sonnet 4.6: versátil para tareas medianas y production

Características: Equilibrio entre velocidad, costo y capacidad. Recomendado para la mayoría de casos. Maneja redacción, análisis, debugging moderado, generación de código robusto.

Cómo ajustar prompts para Sonnet:

• Estructura clara pero no extrema: Sonnet infiere más contexto que Haiku, pero aún requiere estructura XML clara. No necesitas ser tan redundante como con Haiku.
• Ejemplos siguen siendo fuertes: 2-3 ejemplos mejoran consistencia, pero no son OBLIGATORIOS como en Haiku si las instrucciones son claras.
• Prompt chaining funciona bien: Si dividís una tarea compleja en 2-3 pasos, Sonnet mantiene coherencia entre pasos mejor que Haiku.
• Contexto moderado (5-20 páginas): Sonnet procesa bien contextos largos sin perder detalles iniciales.

Ejemplo optimizado para Sonnet: La mayoría de templates que compartimos funcionan bien en Sonnet sin ajustes. Es el punto de referencia.

Claude Opus 4.8: razonamientos complejos y análisis profundo

Características: El más potente. Ideal para razonamientos lógicos complejos, análisis multi-dimensional, problemas con muchas restricciones, debugging sutil, refactoring estratégico. Más caro pero produce resultados significativamente mejores en tareas difíciles.

Cómo ajustar prompts para Opus:

• Podés ser menos explícito: Opus infiere contexto implícito. Permítete redactar prompts más naturales sin perder estructura.
• Extended thinking funciona mejor: Si activás pensamiento extendido, Opus aprovecha esos tokens para razonamientos muy profundos. Mejora notable en problemas lógicos.
• Contexto largo (50+ páginas): Opus maneja contextos densos sin perder coherencia. Podés pasarle libros enteros.
• Combina múltiples tareas en un prompt: Opus puede hacer análisis + proponer soluciones + implementar en un solo prompt si la estructura es clara.

Ejemplo aprovechando Opus:

<instructions>Sos un arquitecto de software senior. Analizás problemas complejos desde múltiples ángulos (performance, mantenibilidad, seguridad, escalabilidad) y propones soluciones balanceadas.</instructions><context>{DESCRIPCIÓN_DEL_SISTEMA_COMPLETO}</context><task>¿Cómo refactorizo este módulo sin romper dependencias existentes? ¿Qué trade-offs hay entre opciones A, B y C? Recomenda la mejor.</task><output_format>Análisis de cada opción (ventajas/desventajas) + recomendación final con justificación + plan de implementación.</output_format>

Herramientas y generadores de prompts para Claude

Existen herramientas para acelerar la creación de prompts. Varían entre gratuitas y de pago, con diferentes niveles de automatización. Acá está lo que funciona realmente.

Herramientas oficiales de Anthropic (gratuitas)

Consola de API de Anthropic: Ofrece herramientas integradas en la interfaz web, sin costo adicional.

• Prompt Generator: Describís qué necesitás (“Quiero un prompt que revise código Python”) y la consola genera un punto de partida. No es perfecto, pero acelera el bootstrapping y te da una estructura base válida que podés iterar en 5 minutos.
• Prompt Improver: Copias un prompt existente y la herramienta sugiere mejoras: qué es ambiguo, dónde falta contexto, cómo estructurarlo mejor. Útil para revisar prompts que escribiste hace meses y detectar dónde pueden fallar en edge cases.
• Playground con versioning: Probás prompts en tiempo real sin código. Guardás versiones. Comparás outputs entre variaciones del mismo prompt. Interfaz más cómoda que copiar código.
• Documentación oficial: Anthropic publica la guía completa de “Prompt Engineering” en su sitio. Es la fuente más confiable — sigue evolucionando con cada update de Claude.

Opciones de terceros (gratuitas, repositorios de templates)

PromptHub: Repositorio de prompts públicos. Buscás por categoría (desarrollo, redacción, análisis) y copiás prompts que otros usuarios compartieron. No es generador automático — es una galería filtrada. Útil para inspiración pero requiere adaptación a tu caso.

Claude Prompt Repository (GitHub): Anthropic mantiene ejemplos oficiales de prompts en su repositorio público. Son los templates más confiables porque vienen del team oficial. Búscalos en github.com/anthropics/.

Awesome Prompts (comunidad): Listas curadas de prompts públicos. Hay de buena y mala calidad, pero hay mucho contenido filtrado por votación. Útil cuando necesitás inspiración para un ángulo específico.

¿Vale la pena un generador automático de prompts?

Los generadores de terceros están un paso atrás vs. las herramientas oficiales de Anthropic. La mayoría están optimizadas para ChatGPT, no para Claude. Si pagás por un generador de prompts, verificá que:

• Genere etiquetas XML explícitas (no solo texto natural).
• Diferencie entre Haiku, Sonnet y Opus.
• Permita iteración y versionado.
• Tenga templates específicos para tu industria.

La realidad: un buen prompt manual toma 15 minutos. Un generador automático no ahorra tiempo real — lo que sí vale es guardar tus mejores prompts en un archivo para reutilizar, más que generar nuevos cada vez.

Troubleshooting completo: qué hacer cuando un prompt no funciona

Cuando un prompt devuelve algo inesperado, hay un checklist de diagnóstico que acelera el debugging. No es magia — es proceso.

Checklist de 12 puntos para diagnosticar un prompt fallido

• ¿Está clara la instrucción de rol? (“Sos un X”) Define exactamente quién es Claude, no “sé útil”. Un rol es una lente que filtra toda la respuesta.
• ¿El contexto llega PRIMERO en el prompt? Reordená: contexto al inicio, instrucciones después. Si pasás documentos largos, deben abrir el prompt.
• ¿Hay ambigüedad en la tarea? Relé la instrucción <task>. ¿Sería igual de clara para alguien que no conoce tu caso? Si no, es vaga.
• ¿Especificaste el formato de salida? Claude elige por defecto. Si querés JSON, decilo. Si querés viñetas, decilo. El formato ausente causa que elija uno genérico.
• ¿Hay ejemplos anidados? Si esperas consistencia de formato, deberías tener 2-3 <example> tags. Sin ejemplos, Claude infiere del aire.
• ¿El contexto es relevante o ruido? Cada palabra de contexto “pesa” en Claude. Si incluiste datos irrelevantes, quitalos. Prioriza los 3 datos más importantes.
• ¿Cuántos tokens usaste? Si pasaste contexto de 100K tokens en una tarea simple, Claude se pierde en los detalles. Conciencia del volumen importa.
• ¿Definiste límites negativos? “No inventés datos”, “No suggeras alternativas”, “No traduzcas”. A veces es más fuerte decir lo que NO hacer.
• ¿La instrucción contradice el formato? Ejemplo: “Sé breve” en <instructions> pero <output_format> pide un análisis de 5 párrafos. Alineá.
• ¿Probaste con la versión correcta? Si usaste Haiku y falla, probá con Sonnet. Algunos problemas no son del prompt sino de la capacidad del modelo.
• ¿El prompt contiene datos fabricados? Si includís un “estudio ficticio” o una “cita inventada” como ejemplo, Claude puede repetirlo como si fuera real.
• ¿Hay contradicción entre bloques XML? Relé todas las etiquetas. A veces una instrucción en <instructions> choca con la <task>.

Caso 1: Claude devuelve respuestas demasiado genéricas

Causa probable: Instrucción de rol débil o contexto faltante. Claude no sabe quién es.

Fix: Agregá un rol específico y ejemplos. “Sos un especialista en [tema] con [X años] de experiencia, no un asistente genérico”. Incluí 2 ejemplos de cómo responder para tu caso.

Caso 2: Claude ignora partes del prompt

Causa probable: El contexto llega al final, no al inicio. O el prompt es demasiado largo y Claude “olvida” detalles del final.

Fix: Reordená para que contexto crucial sea lo primero. Si el prompt es muy largo (>30K tokens), dividilo en dos prompts encadenados.

Caso 3: El formato de salida es distinto al esperado

Causa probable: No especificaste <output_format> o falta ejemplo. Claude elige un formato genérico.

Fix: Agregá <output_format> explícito. Mejor aún, incluí 3 ejemplos reales de cómo debería verse la salida anidados en <examples>.

Caso 4: Claude fabrica datos o citas que no existen

Causa probable: Instrucción de verificación ausente. Claude no sabe que debe evitar invención.

Fix: Agregá una línea explícita en <instructions>: “CERO invención de datos. Si no está en el contexto, decí ‘No sé’ o omití la afirmación”. Probá con Sonnet o Opus — tienen mejor calibración de certidumbre que Haiku.

Caso 5: La respuesta es correcta pero demasiado larga o corta

Causa probable: No especificaste límite de largo. Claude no sabe si querés un tweet o un artículo.

Fix: Agregá palabra-count explícito: “máximo 100 palabras” o “aproximadamente 2000 palabras”. Sé específico en <task>.

Preguntas frecuentes sobre prompts para Claude

¿Cómo hago un prompt que siempre devuelva resultados consistentes?

Consistencia es el objetivo de todo prompt profesional. Tres pasos: (1) Define un rol específico (“Sos un X”), (2) Incluí 3 ejemplos anidados de cómo responder, (3) Especificá el formato de salida exacto. Sin ejemplos, varía cada vez. Con ejemplos, Claude sigue el patrón al 90%+.

¿Qué diferencia hay entre un prompt y un “system message”?

En la API de Anthropic, el “system message” es un parámetro separado que goes directamente a la función system_prompt. Un prompt en el contexto de un usuario es todo lo que va en el body del mensaje. En términos prácticos: el system message se aplica a toda la conversación; el prompt solo a ese mensaje. Para máximo control, usá system_prompt (que es lo que hace la consola cuando armás un prompt).

¿Por qué los prompts de ChatGPT no funcionan directo en Claude?

ChatGPT infiere más contexto implícito. “Revisá este código” funciona en ChatGPT porque asume que sabés qué revisar. Claude requiere explicititud: “Revisá vulnerabilidades de inyección SQL y problemas de async/await”. Los prompts de ChatGPT son “conversacionales”; los de Claude son “estructurados”. La migración lleva 5 minutos de adaptación.

¿Cómo uso prompts en Claude Code (la interfaz)?

Claude Code es el IDE integrado en claude.ai. Escribís un prompt, Claude genera código y lo ejecuta directo. Los prompts aquí son más conversacionales que en la API — podés mezclar inglés y español, ser menos formal. Pero la estructura base sigue siendo XML (contexto, instrucción, tarea).

¿Hay generadores automáticos realmente útiles?

Los generadores de Anthropic (Prompt Generator, Improver) son útiles como punto de partida. Los de terceros varían en calidad. Más vale: guarda tus mejores prompts en un archivo y reutiliza. Un prompt que funciona bien se amortiza en 100 usos.

¿Cómo sé qué versión de Claude usar (Haiku vs Sonnet vs Opus)?

Haiku si es tarea simple (clasificación, extracción). Sonnet si es tarea mediana (redacción, debugging, generación de código). Opus si es razonamiento complejo o análisis profundo. En duda, usá Sonnet — costo/beneficio óptimo. Probá Opus solo si Sonnet falla o es tarea crítica.

¿Puedo usar prompts para generar datos o hacer scraping?

Claude puede analizar datos que compartís, pero no puede hacer scraping activo de la web (no tiene navegador integrado). Podés usar Claude para procesar datos ya descargados, formatearlos o analizar contenido HTML que pasaste manualmente. Para scraping automático, usá herramientas dedicadas (Playwright, Selenium) o APIs.

¿Cuál es el límite de tamaño de un prompt?

La ventana de contexto de Claude es 200.000 tokens en Sonnet y Opus, 128K en algunas versiones de Haiku. En términos prácticos: podés pasar un documento de 80 páginas (0.5-1M caracteres). El límite real es costo — más tokens = costo mayor. Para tareas simples, mantené contexto bajo 10K tokens (ahorra dinero).

¿Los prompts que escribo quedan guardados o son públicos?

Si usás claude.ai (interfaz web), el historial es privado — solo tú lo ves. Si usás la API, los prompts no se guardan en Anthropic (a menos que explícitamente exportes). Los prompts NO son públicos por defecto. Pero NO metas datos sensibles (contraseñas, claves de API, información personal) en prompts — podría quedar en logs.

¿Cómo creo un generador personalizado de prompts para mi equipo?

Tres opciones: (1) Documenta en un archivo los 5-10 prompts que más usás, con placeholders. (2) Crea un script que arme prompts automáticamente (Python/JavaScript interpolando variables). (3) Usa la API de Anthropic + una interfaz (web, CLI) que tu equipo adapte. La opción 1 es la más práctica — 30 minutos de setup inicial, décadas de reutilización.

Recapitulación: prompts efectivos en 5 puntos clave

• Estructura explícita siempre: Contexto primero, instrucciones después, tarea clara, formato definido. Las etiquetas XML son delimitadores, no decoración.
• Iteración rápida: Un buen prompt toma 15-30 minutos iterando. Escribe básico, observá qué falla, refiná UN elemento a la vez.
• Ejemplos > instrucciones: Si esperas formato consistente, mostrale 3 ejemplos anidados. Funciona mejor que decir “devolvé JSON”.
• Versión correcta del modelo: Haiku para tareas simples, Sonnet para medianas, Opus para razonamientos complejos. El mismo prompt funciona mejor en Opus pero cuesta más.
• Documentá y reutiliza: Guarda tus mejores prompts. Reutilizá el que funciona 100 veces en lugar de crear uno nuevo cada vez.