Rol: Eres un ingeniero senior de {LANGUAGE} que construye {COMPONENT_TYPE}.
Objetivo: Implementar {FUNCTION_NAME} que {FUNCTION_PURPOSE}.
Restricciones:
- Sigue {STYLE_GUIDE} (nombres, documentación, manejo de errores).
- Objetivo de complejidad temporal: {BIG_O}. Restricciones de memoria: {LIMITS}.
- Incluye docstring y comentarios en línea para la lógica no obvia.
- Evita las dependencias externas a menos que estén justificadas; si se añaden, explícalo.
Entradas:
- Interfaces/Tipos: {TYPES}
- Casos límite: {EDGE_CASES}
- Ejemplos de entradas/salidas: {EXAMPLES}
Entregables:
1) Bloque de código final solamente.
2) Breve justificación (con viñetas) después del código.

Rol: Eres un ingeniero senior de Python que construye una utilidad de limpieza de datos.
Objetivo: Implementar `normalize_names` que estandarice los nombres de usuario.
Restricciones:
- Sigue PEP8; lanza ValueError en tipos no válidos.
- Tiempo O(n); trata los espacios en blanco y los acentos; mantén la memoria lineal.
- Docstring + comentarios.
Entradas:
- Tipos: List[str] o Iterable[str]
- Casos límite: nulos, múltiples espacios, marcas de acento, apellidos con guiones
- Ejemplos: [" José Álvarez ", "ANNA-lou "] → ["jose alvarez", "anna-lou"]
Entregables:
1) Bloque de código final solamente.
2) Breve justificación.

Rol: Experto senior en refactorización de {LANGUAGE}.
Tarea: Refactorizar el código proporcionado para {GOAL}: {READABILITY|PERFORMANCE|SAFETY}.
Reglas:
- Preservar la API pública y el comportamiento.
- Añadir sugerencias de tipo y docstrings donde falten.
- Extraer funciones puras para la comprobabilidad.
- Reemplazar números mágicos; aplicar {STYLE_GUIDE}.
- Proporcionar notas de complejidad antes/después.
Código de entrada:
```{LANGUAGE}
{SOURCE}

### 3) Plantilla de generación de pruebas (pruebas unitarias + de propiedad)
**Cuándo usar**: Aumentar la cobertura rápidamente.

### 4) Plantilla de revisión de código (modo de revisor automatizado)
**Cuándo usar**: Revisiones rápidas y consistentes antes de la aprobación humana.

{UNIFIED_DIFF}

### 5) Plantilla de depuración (Repro mínimo → Causa raíz)
**Cuándo usar**: Encontrar y corregir errores, crear reproducciones.

---
## Ejemplo: Del ticket al PR con Grok 4 Fast
Recorramos un escenario realista: un ticket de producto solicita "búsqueda mientras se escribe con llamadas API debounced y UI optimista".
1) **Redactar el hook**

2) **Pedir pruebas**

3) **Ejecutar un pase de revisión**

4) **Refinar**

Resultado: tendrás código listo para producción más pruebas, y la IA habrá documentado su razonamiento para que un compañero de equipo pueda seguirlo.
---
## Patrones de prompts que mejoran la calidad de la salida
- **Rol + Objetivo + Restricciones + Entradas + Entregables**: Esta estructura le da a Grok 4 Fast todo lo que necesita para mantenerse en el camino correcto.
- **Enumeración de casos límite**: Siempre enumera los casos complicados. El modelo los incorporará a las pruebas y protecciones.
- **Objetivos de complejidad**: Pedir O(n) o límites de memoria impulsa mejores algoritmos.
- **Contratos de API**: Pega tipos/interfaces al principio; el modelo se alineará con ellos.
- **Contratos de salida**: Solicita primero el código final y luego la justificación. Esto mantiene las respuestas limpias para copiar/pegar.
---
## Guías de estilo y consistencia: Hazlo listo para el equipo
Si quieres una salida consistente en todo un equipo, estandariza:
- **Guías de estilo de lenguaje**: PEP8, Effective Go, Airbnb JS, Rust API Guidelines.
- **Convenciones de error**: return vs throw, códigos de error, semántica de reintento.
- **Normas de prueba**: nombres, directorios de fixtures, umbrales de cobertura.
- **Valores predeterminados de seguridad**: validación de entrada, escaping, manejo de secretos.
Incluye estos como constantes en tus plantillas para que Grok 4 Fast los internalice cada vez.
---
## Prompts de seguridad primero para código seguro
Añade estas cláusulas de seguridad a tus plantillas:
- **Validación de entrada**: "Valida y sanea todas las entradas no confiables".
- **Higiene de secretos**: "No hay secretos en el código. Lee desde el entorno y documenta las variables requeridas".
- **Escrutinio de dependencias**: "Explica y justifica cualquier nueva dependencia; prefiere la biblioteca estándar".
- **Seguridad de serialización**: "Usa analizadores seguros; evita eval/Function/deserialización insegura".
- **Comprobaciones de AuthZ**: "Aplica la autorización en rutas sensibles; añade pruebas para intentos de omisión".
---
## Prompts de rendimiento: Evita las trampas habituales
- "Minimiza las asignaciones; reutiliza los búferes cuando haya grandes cargas útiles".
- "Evita las consultas N+1; agrupa o pre-carga".
- "Usa streaming/iteradores para big data".
- "Memoiza las funciones puras; perfila los puntos calientes".
- "Añade benchmarks y explica las compensaciones".
---
## Listas de verificación de revisión que puedes pegar en los PR
Incluye una lista de verificación corta para que cada revisión sea consistente:
- Compatibilidad de la API confirmada
- Manejo de colecciones nulas/indefinidas y vacías
- Limpieza de recursos (archivos, sockets, suscripciones)
- Protecciones de concurrencia (bloqueos, atómicos, idempotencia)
- Niveles de registro apropiados; sin datos sensibles
- Pruebas actualizadas; migraciones documentadas
---
## Flujo de trabajo del equipo: Haz que las plantillas de prompts sean un activo compartido
- **Centraliza las plantillas** en tu repositorio (por ejemplo, directorio `/.prompts`).
- **Parametriza** variables como `{LANGUAGE}`, `{STYLE_GUIDE}`, `{BIG_O}` usando snippets o macros de editor.
- **Controla la versión** de tus plantillas de prompts y revísalas como código.
- **Crea libros de jugadas** para la redacción de funciones, la refactorización, la escritura de pruebas y las comprobaciones de lanzamiento.
Por cierto, si tu equipo prefiere un copiloto de codificación en paralelo que viva en el navegador y dentro de los documentos, vale la pena señalar que [Sider.ai](https://sider.ai/) puede ayudarte a almacenar y reutilizar plantillas de prompts, ejecutar revisiones de código en diffs y mantener el contexto entre pestañas. Es una forma conveniente de operacionalizar estos prompts de Grok 4 Fast en toda tu organización sin la fatiga de copiar/pegar.
---
## Biblioteca de copiar y pegar: Prompts listos para usar
### Controlador de API de TypeScript (Node/Express)

### Paso de canalización de datos de Python

### Guardia de concurrencia de Go

### Componente React accesible

---
## Cómo iterar rápidamente con Grok 4 (Bucle de retroalimentación ajustado)
1) **Comienza poco a poco**: Pide una función, no todo el servicio.
2) **Restringe las salidas**: "Un bloque de código, luego viñetas".
3) **Exige pruebas**: Cada característica recibe pruebas en la misma pasada.
4) **Fija las decisiones**: "Explica las ventajas y desventajas. Si no estás seguro, haz preguntas aclaratorias".
5) **Ajuste gradual**: Mejora por capas: primero la corrección, luego el rendimiento y, por último, la legibilidad.
---
## Midiendo el éxito: ¿Ayudaron las plantillas?
Rastrea métricas simples:
- Tiempo del ciclo de PR (creado → fusionado)
- Tasa de reelaboración de la revisión (cambios solicitados por PR)
- Delta de cobertura de prueba por característica
- Incidentes de producción vinculados al código revisado por IA
Si los números tienden en la dirección correcta, redobla la apuesta. Si no, ajusta tus plantillas e incluye más contexto ({types}, {logs}, {diffs}).
---
## Errores comunes que debes evitar
- Indicaciones demasiado amplias como "construir el backend". Divídelas en unidades.
- Olvidar los casos límite. Siempre enuméralos.
- Permitir la proliferación de bibliotecas. Pide una justificación.
- Omitir las pruebas "para más tarde". Intégralas en la indicación.
- Aceptar revisiones vagas. Exige listas de verificación y niveles de gravedad.
---
<a36></a6>
## Lista de verificación de inicio rápido
- Crea una carpeta `/prompts` en tu repositorio.
- Guarda las plantillas de redacción, revisión y prueba.
- Parametriza los campos comunes con variables de fragmento.
- Pon a prueba una característica esta semana; mide los resultados.
- Itera en función de los comentarios de los revisores y los incidentes.
---
## Reflexión final
Grok 4 Fast es excelente para producir código rápidamente, pero el verdadero poder proviene de plantillas de indicaciones bien estructuradas que codifican tus estándares. Trata las indicaciones como infraestructura. Controla sus versiones. Revísalas. Y deja que Grok 4 Fast se encargue del código repetitivo para que tu equipo pueda centrarse en la arquitectura y el producto.
Próximo paso: elige una plantilla de las anteriores, pégala en tu editor, intercambia tu contexto y envía una PR hoy mismo.
### Preguntas frecuentes
P1: ¿Cómo utilizo Grok 4 Fast para la redacción de código con un estilo coherente?
Utiliza una plantilla de indicaciones estructurada que establezca el rol, el objetivo, las restricciones y la guía de estilo. Incluye objetivos de complejidad, casos límite y entregables para que Grok 4 Fast genere código coherente y listo para producción.
P2: ¿Puede Grok 4 Fast realizar revisiones de código fiables con plantillas de indicaciones?
Sí. Proporciona un diff, los estándares de tu equipo y una lista de verificación para la seguridad, el rendimiento y la compatibilidad de la API. Solicita hallazgos clasificados por gravedad y sugerencias de parches mínimos.
P3: ¿Cuál es la mejor manera de generar pruebas utilizando Grok 4 Fast?
Utiliza una plantilla de generación de pruebas que especifique el framework, los objetivos de cobertura y los casos límite. Solicita pruebas unitarias y basadas en propiedades, además de un breve plan de cobertura.
P4: ¿Cómo evito que el código inseguro provenga de las salidas de la IA?
Añade cláusulas de seguridad a tus indicaciones: validación de entradas, higiene de secretos, justificación de dependencias y serialización segura. Exige notas explícitas sobre las ventajas y desventajas de la seguridad.
P5: ¿Cómo aceleran las plantillas de indicaciones los ciclos de PR con Grok 4 Fast?
Las plantillas reducen la ambigüedad, estandarizan las salidas y cargan previamente las pruebas y las revisiones. Eso acorta las idas y venidas, reduce la reelaboración y te ayuda a fusionar más rápido.