Ingenieria de prompts de IA: Comandos e técnicas essenciais para desenvolvedores

Dicas de prompting específicos por ferramenta

Codex CLI sobresale em um amplo espectro de escenarios de desenvolvimento. Aquí estão os casos de uso mais comuns onde oferece as mayores ganancias de produtividade.

Biblioteca de plantillas de prompts

Prompting zero-shot

Prompting few-shot

Quando necessitas validar rápidamente uma idea, Codex CLI pode generar um prototipo funcional em minutos em vez de horas. Descreve a funcionalidade central que desejas e genera uma implementação funcional com estrutura apropriada, manejo de erros e inclusive estilo básico se estás construyendo uma interfaz web. Isto acorta drásticamente o ciclo de retroalimentação de a idea ao prototipo funcional:

Prompting de cadena de pensamiento

Variável de entorno (recomendado): Configura OPENAI_API_KEY em tua arquivo de configuração de shell. Isto mantém a clave segura e automaticamente disponivel para todas as sesiones de terminal:

Prompting de rol

Write a Python function that validates an email address using regex.
The function should return True for valid emails and False for invalid ones.

Prompts de sistema vs. prompts de usuario

Arquivo de configuração: Crea um arquivo ~/.codex/config.json para armazenar tua clave API. Isto é útil para pipelines CI/CD e scripts de automatização.

"Actúa como..." / "És um..." — asignação de roles

Convert these database column names to camelCase JavaScript variable names:

user_first_name -> userFirstName
created_at_timestamp -> createdAtTimestamp
is_email_verified -> isEmailVerified
total_order_count ->

Now convert: product_category_id

"Passo a passo" — cadena de pensamiento

Janela de contexto

"Pensa em voz alta" — transparência no razonamiento

Analyze this React component for performance issues. Think step by step:

1. First, identify all state variables and their update patterns
2. Then, check for unnecessary re-renders
3. Next, look for missing memoization opportunities
4. Finally, suggest specific optimizations with code examples

Here's the component:
[component code]

"Explícamelo como se tuviera 5 anhos" — explicação simplificada

Costo relativo

"Revisa e critica" — revisão de código

Act as a senior security engineer with 15 years of experience in web application security. Review this authentication implementation and identify any vulnerabilities, ranking them by severity. For each vulnerability, explain the attack vector and provide a secure code fix.

"Escreve experimentas para" — geração de experimentas

Geração de código complejo, operações multi-arquivo

"Refactoriza usando..." — refactorização basada em patrones

"Encontra erros em" — depuração

# System prompt example
You are a TypeScript expert working on a Next.js 14 project using:
- App Router (not Pages Router)
- Server Components by default
- Prisma for database access
- Tailwind CSS for styling
- Zod for validation

Always use strict TypeScript. Prefer server actions over API routes.
Never use 'any' type. Use 'unknown' and narrow with type guards.

# User prompt example
Add a user profile page that shows the current user's name, email,
avatar, and last 10 activity records. Include loading states and
error handling.

Portando uma ferramenta de Python a Go? Traduciendo componentes React a Vue? Codex CLI maneja a traducção de lenguajes com uma precisão surpreendente, entendiendo no solo as diferenças de sintaxe senão também os patrones idiomáticos de cada lenguaje. Solo apunta ao arquivo fuente e especifica o lenguaje objetivo:

"Adiciona manejo de erros" — mejora de robustez

Tarefas simples, explicação de código, soluciones rápidas

Prompt de implementação de funções

You are a senior backend engineer at a fintech company who specializes
in building secure, high-throughput payment processing systems.
You have deep expertise in PostgreSQL, Redis, and distributed systems.
You always consider edge cases, race conditions, and failure modes.

Design a payment processing API that handles:
- Credit card payments via Stripe
- Bank transfers via Plaid
- Retry logic with exponential backoff
- Idempotency keys to prevent duplicate charges

Razonamiento complejo, depuração de problemas difíciles

Prompt de design de API

Debug this SQL query that's causing a timeout. Think step by step:

1. First, analyze the query structure and joins
2. Identify potential performance bottlenecks
3. Check for missing indexes
4. Suggest an optimized version with EXPLAIN analysis

SELECT u.name, COUNT(o.id), SUM(o.amount)
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
LEFT JOIN order_items oi ON o.id = oi.order_id
WHERE o.created_at > '2026-01-01'
GROUP BY u.name
HAVING COUNT(o.id) > 10
ORDER BY SUM(o.amount) DESC;

Medio-baixo

Prompt de esquema de base de datos

I need to choose between WebSocket and Server-Sent Events for a
real-time notification system. Think aloud about the trade-offs,
considering: browser support, bidirectional communication needs,
server resource usage, and scalability. Then recommend one with
justification.

Razonamiento avanzado com contexto mais amplo

Prompt de componente UI

Explain like I'm 5: What is a monad in functional programming,
and why do Haskell developers keep talking about them?
Use a real-world analogy, not code.

Modelo subyacente

Prompt de configuração e DevOps

Review and critique this Express.js middleware. Focus on:
- Security vulnerabilities
- Error handling gaps
- Performance concerns
- Best practice violations
- Suggest improvements with code examples

[paste your middleware code]

Velocidade de geração de código

Encadenamiento de prompts

Write tests for the UserService.register method using Jest.
Cover these scenarios:
- Happy path with valid input
- Duplicate email registration
- Invalid email format
- Password too short
- Missing required fields
- Database connection failure
- Concurrent registration attempts

Use describe/it blocks. Include setup and teardown.
Mock the database layer.

Generalmente mais rápida

Preenchimento de contexto

Refactor this notification system using the Strategy pattern.
Currently, all notification types (email, SMS, push) are handled
in a single class with if-else chains. Create separate strategy
classes for each notification type, a context class that delegates
to the active strategy, and a factory for creating strategies.

[paste your current code]

Ligeramente mais lenta, mais deliberada

Especificação de restricciones

Find bugs in this async Node.js function. It's supposed to process
a batch of orders and update their status, but sometimes orders
get processed twice and the status updates are inconsistent under
high load.

[paste your function code]

Qualidade de revisão de código

Control de formato de salida

Add error handling to this file upload function. Consider:
- File size limits
- Invalid file types
- Network interruptions during upload
- Disk space errors
- Concurrent upload conflicts
- Partial upload cleanup

Use try-catch with specific error types. Add retry logic for
transient failures. Return meaningful error messages to the client.

Cada projeto acumula código boilerplate — endpoints CRUD, validação de formularios, flujos de autenticação, migraciones de base de datos, arquivos de configuração. Codex CLI elimina a monotonia de escrever código repetitivo. Descreve o patrón uma vez e genera todo o boilerplate com a estrutura apropriada, dejándote libre para enfocarte nas partes únicas de tua aplicação.

Refinamiento iterativo

Boa, detecta problemas obvios

Instrucciones vagas

Implement a user avatar upload feature for a Next.js 14 application.

Tech stack: Next.js App Router, TypeScript, Prisma, PostgreSQL, AWS S3

Requirements:
- Accept JPEG, PNG, WebP (max 5MB)
- Resize to 200x200 and 400x400 thumbnails using Sharp
- Upload originals to S3 with unique keys
- Store S3 URLs in the User model
- Delete old avatar when uploading a new one
- Return presigned URLs for frontend display

Acceptance criteria:
- Invalid file types return 400 with error message
- Files over 5MB return 413
- Successful upload returns 200 with avatar URLs
- Old avatars are cleaned up from S3

Create: API route, service layer, Prisma schema update, and types.

Excelente, análisis mais profundo e matizado

Falta de contexto

Design a RESTful API for a project management application.

Architecture: Express.js with TypeScript, following clean architecture
Auth: JWT with refresh token rotation
Versioning: URL-based (/api/v1/)
Response format: { success: boolean, data?: T, error?: { code, message } }

Endpoints needed:
- Projects CRUD with team membership
- Tasks CRUD with assignee, priority, status
- Comments on tasks with mentions
- Activity feed (recent actions across projects)

Include:
- Request/response TypeScript interfaces
- Zod validation schemas
- Error handling middleware
- Pagination for list endpoints (cursor-based)

Razonamiento de formato largo

Sobrecarga de prompts

Design a Prisma schema for an e-commerce platform with these entities:

- Users (authentication, profile, addresses)
- Products (variants, categories, inventory)
- Orders (line items, status history, payments)
- Reviews (ratings, images, helpful votes)
- Cart (items, applied coupons)

Requirements:
- Use PostgreSQL with UUID primary keys
- Soft deletes with deletedAt timestamps
- Proper indexes for common query patterns
- Enums for order status, payment status
- Decimal fields for prices (not float)
- Full-text search on product name and description
- Include a migration file

Forte com modelos de razonamiento

Ignorar o formato de salida

Create a reusable DataTable component in React with TypeScript.

Styling: Tailwind CSS + shadcn/ui conventions
Features:
- Column definitions with sort, filter, and custom renderers
- Server-side pagination with page size selector
- Row selection (single and multi) with checkboxes
- Loading skeleton state
- Empty state with custom message
- Responsive: card layout on mobile, table on desktop

Accessibility:
- Keyboard navigation (arrow keys, Enter, Escape)
- Screen reader announcements for sort and filter changes
- ARIA labels on all interactive elements

Props interface:
- data, columns, isLoading, pagination, onSort, onFilter, onSelect

Include a usage example with a user list table.

Excecional, especialmente em arquitectura

No iterar

Create a Docker Compose setup for a development environment with:
- Next.js app (hot reload enabled)
- PostgreSQL 16 with persistent volume
- Redis for session storage
- MinIO (S3-compatible) for local file storage

Requirements:
- All services on a shared network
- Environment variables from .env file
- Health checks for all services
- Volumes for node_modules (avoid bind mount issues)
- PostgreSQL initialized with seed data
- Non-root containers where possible

Also create:
- Dockerfile for the Next.js app (multi-stage build)
- .env.example with all required variables
- Makefile with common commands (up, down, logs, reset-db)

Quando estás atascado em um bug, Codex CLI pode analizar registros de erros, rastrear rutas de código e sugerir correcciones. Pega tua mensaje de error e código relevante, e proporcionará diagnósticos e soluciones:

Que é a ingenieria de prompts e por que é importante para os desenvolvedores?

Operações multi-arquivo

Quais são as técnicas de prompting mais importantes para desenvolvedores?

# Step 1: Design the architecture
"Design the architecture for a real-time chat application.
List the components, their responsibilities, and how they
communicate. Use a diagram-like text format."

# Step 2: Define the data model
"Based on the architecture above, design the database schema
for the chat application. Include users, conversations,
messages, and read receipts. Use Prisma schema format."

# Step 3: Implement the API
"Implement the REST API for the chat application based on
the architecture and schema we designed. Start with the
message endpoints: send, list, delete."

# Step 4: Add WebSocket support
"Now add WebSocket support for real-time message delivery.
Use Socket.io. Integrate with the existing message API."

# Step 5: Write tests
"Write integration tests for the chat API and WebSocket
events using Jest and Supertest."

Que ferramenta de programação AI é melhor para a ingenieria de prompts?

Excelente, edição batch eficiente

Que erros comuns devo evitar ao fazer prompts de código a a IA?

 {
    await this.db.query('UPDATE users SET email = $1 WHERE id = $2', [email, id]);
    await this.cache.del(`user:${id}`);
  }
}
```

Here is the User type:
```typescript
interface User {
  id: string;
  email: string;
  name: string;
  role: 'admin' | 'user';
  createdAt: Date;
}
```

Now, add an updateProfile method that allows updating name and email,
with validation that the email is not already taken by another user.

Observa como proporcionar o código e os tipos existentes permite a a IA generar métodos que se alinean perfectamente com os patrones existentes, utilizando a mesma estrategia de caché e seguindo as definiciones de tipo existentes.

Muito boa, abordagem mais cauteloso

A ingenieria de prompts é a prática de disenhar e otimizar as entradas de texto que das a os modelos de IA para obter a melhor salida possível. Para os desenvolvedores, é uma habilidade crítica que determina se a IA genera código de qualidade de producção o basura com erros. Um buen prompting pode reducir o tiempo de desenvolvimento em um 40-60%, enquanto que um mal prompting conduce a uma depuração interminavel.

Build a URL shortener API with these constraints:

MUST:
- Use Node.js 20+ with native fetch (no axios)
- Use PostgreSQL via pg driver (no ORM)
- Generate short codes of exactly 7 characters
- Support custom aliases (max 20 chars)
- Return 301 for existing short URLs
- Rate limit to 100 creates per hour per IP

MUST NOT:
- Use any ORM or query builder
- Store full URLs without normalization
- Allow short codes that conflict with existing routes
- Return database errors to the client

PERFORMANCE:
- Handle 10,000 requests per second
- Cache hot URLs in Redis with 5-minute TTL
- P99 latency under 50ms for redirects

Até 200K tokens

As técnicas mais importantes incluem: prompting de cadena de pensamiento (pedir a a IA que explique seu razonamiento passo a passo), prompting de rol (asignar uma pessoa especialista como "és um desenvolvedor senior de React"), prompting few-shot (proporcionar exemplos de a salida desejada) e especificação de restricciones (definir explicitamente que bibliotecas, patrones e estilos usar). Cada técnica tem fortalezas específicas para diferentes tarefas de desenvolvimento.

Analyze this codebase and provide the output in this exact format:

## Architecture Overview
[2-3 paragraph summary]

## Component Diagram
```mermaid
graph TD
    [components and relationships]
```

## API Endpoints
| Method | Path | Description | Auth |
|--------|------|-------------|------|

## Database Tables
| Table | Columns | Indexes | Relations |
|-------|---------|---------|-----------|

## Recommendations
1. [Priority] [Description] - [Estimated effort]
2. ...

## Technical Debt
- [ ] [Description] - [Impact: High/Medium/Low]

Precios API de OpenAI (pago por token)

No há uma única "melhor" ferramenta — diferentes ferramentas sobresalen em diferentes estilos de prompting. Claude Code e Claude (web) são excelentes para prompts de razonamiento complejos de múltiples pasos com contexto extenso. GitHub Copilot e Cursor são melhores para prompts cortos e contextuales dentro do IDE. ChatGPT é versátil para prompts de planificação e arquitectura. A melhor estrategia é dominar técnicas de prompting que funcionen em todas as ferramentas.

# Iteration 1: Get a starting point
"Write a rate limiter middleware for Express.js"

# Iteration 2: Add specificity
"Good start. Now modify it to use Redis for distributed
rate limiting across multiple server instances. Use sliding
window instead of fixed window."

# Iteration 3: Add edge cases
"Add handling for: Redis connection failures (fall back to
in-memory), custom rate limits per route, burst allowance
for legitimate traffic spikes, and proper headers
(X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset)."

# Iteration 4: Add tests
"Write comprehensive tests for all the scenarios we've
covered, including Redis failures and burst handling."

Os erros comuns incluem: prompts vagos como "arregla este código" em vez de descrever o comportamento esperado, no proporcionar suficiente contexto como rutas de arquivos e dependencias, sobrecargar o prompt com demasiadas requisições no relacionadas, no especificar o formato de salida desejado e no iterar quando a primera respuesta no é satisfactoria. Siempre sei específico, proporciona contexto e refina iterativamente.

Codex CLI pode identificar causas raíz que poderiam tomar horas descubrir manualmente — desajustes de renderizado servidor/cliente, condiciones de carrera, versiones de dependencia incorrectas o erros lógicos sutiles em condicionales complejos.

A ingenieria de prompts é a habilidade mais importante de a era de a IA. Dominarla transforma a os desenvolvedores de consumidores pasivos de IA a creadores que orquestan asistentes de IA para produzir código de qualidade de producção. Os prompts que escribes determinan no solo se a IA completa uma tarefa, senão se o resultado é mantenivel, seguro e alineado com os estándares de tua projeto.

ChatGPT / GPT-4

Experimenta tuas prompts com nossa ferramenta de experimenta de IA gratuita. Experimenta com diferentes técnicas de prompting e compara os resultados de diferentes modelos.

• Usa instrucciones personalizadas: Configura tua stack tecnológico e preferências nas instrucciones personalizadas de ChatGPT para no ter que repetirlas em cada conversação.
• Identificar oportunidades de refactorização
• Usa formato markdown nos prompts: GPT-4 responde bem a prompts estructurados com cabeçalhos, vinhetas e bloques de código.
• Executar migraciones a gran escala
• Usa mensajes do sistema: Na API, usa mensajes do sistema para estabelecer instrucciones persistentes como estándares de codificação e contexto do projeto.

# Effective GPT-4 prompt structure
**Role:** Senior TypeScript developer
**Task:** Implement a JWT authentication middleware
**Context:** Express.js API, PostgreSQL, existing User model
**Constraints:** No external auth libraries, use crypto module
**Output:** Complete, production-ready code with types
**Format:** Single file with inline comments for complex logic

Claude / Claude Code

Experimenta o probador de prompts

• Usa CLAUDE.md: Isto é lo mais impactante que podes fazer. Coloca o contexto de tua projeto, convenciones e preferências em CLAUDE.md.
• Especifica ubicaciones de arquivos explicitamente: Claude Code funciona melhor quando especificas que arquivos ler e modificar.
• Déjalo executar comandos: Claude Code pode executar comandos de experimenta e construção. Pídele que verifique seu trabalho ejecutando experimentas.
• Usa /compact em sesiones largas: Quando o contexto se vuelve extenso, usa /compact para comprimir a conversação conservando a informação mais importante.
• Aprovecha as tags XML: Claude responde bem a as partes do prompt delimitadas com XML, separando claramente as diferentes secciones de uma requisição.

# Effective Claude Code prompt
Read the following files to understand the current architecture:
- src/routes/userRoutes.ts
- src/middleware/authMiddleware.ts
- src/models/User.ts

Then refactor the authentication flow to support:
1. JWT access tokens (15 min expiry) + refresh tokens (7 day expiry)
2. Token rotation on refresh (invalidate old refresh token)
3. Rate limiting on the refresh endpoint (5 per minute per user)

Update all related files and run the test suite when done.

GitHub Copilot

AI e flujos de trabalho de desenvolvimento: Como integrar a IA em tua proceso de desenvolvimento

• Geração de documentação asistida por IA
• Usa tipos de TypeScript: Os tipos e interfaces bem definidos guían a Copilot em direção a a implementação correta.
• Proporciona exemplos em comentarios: Muestra a entrada/salida esperada em comentarios para ajudar a Copilot a coincidir com o formato desejado.
• Acepta sugestões parciais: Às vezes Copilot tem a estrutura correta mas detalhes incorrectos. Acepta a sugestão e logo edita os detalhes.
• Usa Copilot Chat para tarefas complejas: Para cambios em múltiples arquivos o decisiones de arquitectura, usa Copilot Chat em vez de sugestões online.

> {
  // Copilot will generate the implementation based on these types

Cursor

Compreendendo as ferramentas de programação AI

• Usa referencias @file: Referencia arquivos específicos com @filename para dar a Cursor um contexto preciso.
• Usa @codebase para contexto amplo: Quando necesites que Cursor busque em todo o projeto, usa @codebase.
• Usa @docs para documentação de bibliotecas: Cursor pode referenciar documentação de bibliotecas de terceros com @docs.
• Aprovecha Cmd+K para edição online: Selecciona código e usa Cmd+K para descrever cambios em lenguaje natural.
• Configura regras de projeto: Usa um arquivo .cursorrules (similar a CLAUDE.md) para estabelecer instrucciones de projeto persistentes.

# Effective Cursor prompt
@src/services/paymentService.ts @src/types/payment.ts

Refactor the processPayment function to use the Strategy pattern.
Create separate strategy classes for each payment provider
(Stripe, PayPal, BankTransfer). The function should accept a
payment method and delegate to the appropriate strategy.

Keep the same public API so existing callers don't break.

Codex CLI

Configuração de um entorno de desenvolvimento impulsionado por IA

• Proporciona objetivos claros: Codex CLI funciona melhor com objetivos de alto nivel claros em vez de instrucciones passo a passo.
• Especifica o directorio de trabalho: Asegúrate de executar Codex CLI desde o directorio raíz correto do projeto.
• Usa o modo de propuesta primero: Antes de deixar que Codex haga cambios, usa o modo de propuesta para revisar seu plan.
• Configura os permissões de sandbox com cuidado: Controla lo que Codex pode executar configurando os permissões de sandbox.
• Itera nos resultados: Como com outras ferramentas, o primer tento pode necessitar refinamiento através de prompts de seguimiento.

Erros comuns e como evitarlos

Desenvolvimento de funções asistido por IA

Precios API de Anthropic (pago por token)

Depuração e correcção de erros asistida por IA

# Bad
"Fix the login bug"

# Good
"Fix the bug where users with uppercase emails cannot log in.
The issue is in src/auth/login.ts - the email comparison is
case-sensitive but emails are stored in lowercase in the database.
The fix should normalize the email to lowercase before comparison."

Código abierto

Refactorização e migração de código asistida por IA

# Bad
"Write a function to send emails"

# Good
"Write an email sending function for our NestJS application.
We use:
- @nestjs/mailer with Handlebars templates
- SMTP via AWS SES
- Templates stored in src/templates/emails/
- Existing MailService class in src/mail/mail.service.ts

The function should accept a template name, recipient, and
template variables. Include error handling for SES throttling
and bounce notifications."

Explorar ToolHub

Documentação asistida por IA

# Bad - Too many tasks in one prompt
"Build a complete user management system with authentication,
profile management, email verification, password reset,
role-based access control, and an admin dashboard"

# Good - Break it into focused prompts
Prompt 1: "Design the database schema for a user management system..."
Prompt 2: "Implement the authentication endpoints..."
Prompt 3: "Add email verification flow..."
Prompt 4: "Implement role-based access control middleware..."

Dica de segurança: Nunca codifiques tua clave API em arquivos fuente nem a commits ao control de versiones. Usa variáveis de entorno o os comandos de autenticação integrados, e considera configurar límites de uso no panel de tua cuenta de OpenAI para prevenir cargos inesperados.

Melhores práticas de desenvolvimento com IA

# Bad
"List all the API endpoints"

# Good
"List all API endpoints in a markdown table with these columns:
| Method | Path | Description | Auth Required | Request Body | Response |"

Dica profissional: Depois de generar código com Codex CLI, ejecuta codex "revisa mis cambios recientes em busca de possíveis problemas, vulnerabilidades de segurança e adherencia a as melhores práticas" para obter uma segunda opinión impulsionada por IA antes de commitear.

Tipos de ferramentas de programação AI

# Instead of accepting the first response, iterate:
"Good start. Now add input validation using Zod schemas."
"Now add proper error handling with custom error classes."
"Now add logging for all operations."
"Now write tests for all the edge cases we've discussed."

Codex CLI é um excelente companhero de aprendizagem. Em vez de revisar documentação extensa, podes pedirle que demuestre como realizar uma tarefa específica com o framework que estás aprendendo. Solicita exemplos funcionales com explicações, logo haz perguntas de seguimiento sobre patrones e convenciones:

Arquivos de configuração a nivel de projeto

Plantilla 1: Implementação de funcionalidade

You are a senior {language} developer specializing in {framework}.

Implement {feature_description} for our {project_type} application.

Tech stack:
- {language} {version} with {framework} {version}
- {database} for data storage
- {orm} for database access
- {testing_framework} for tests

Requirements:
- {requirement_1}
- {requirement_2}
- {requirement_3}

Constraints:
- Must follow existing patterns in the codebase
- Must include input validation
- Must handle errors gracefully
- Must be backward compatible

Output:
1. Implementation code with inline comments for complex logic
2. Unit tests covering happy path and edge cases
3. Brief explanation of design decisions

Plantilla 2: Investigação de bugs

You are a debugging specialist with expertise in {language}/{framework}.

Investigate and fix this bug:

**Symptom:** {describe_the_observed_behavior}
**Expected:** {describe_the_expected_behavior}
**Frequency:** {always/sometimes/under_specific_conditions}
**Environment:** {production/staging/development}

Relevant code:
```
{paste_relevant_code}
```

Error output / stack trace:
```
{paste_error_output}
```

Think step by step:
1. Identify the root cause
2. Explain why this bug occurs
3. Provide the fix with code
4. Suggest how to prevent similar bugs
5. Write a regression test

Plantilla 3: Revisão de código

You are a senior code reviewer at a {company_type} company.

Review this {language} code for:

1. **Correctness:** Logic errors, off-by-one errors, null handling
2. **Security:** Injection, XSS, auth bypasses, data exposure
3. **Performance:** N+1 queries, unnecessary allocations, missing caches
4. **Maintainability:** Code smells, naming, complexity
5. **Testing:** Missing test cases, brittle tests

Code to review:
```
{paste_code}
```

For each issue found, provide:
- Severity: 🔴 Critical / 🟡 Warning / 🔵 Info
- Category: Which of the 5 areas above
- Description: What's wrong and why
- Suggestion: How to fix it, with code example

End with an overall assessment and top 3 priorities.

Plantilla 4: Design de endpoints API

Design a {http_method} {endpoint_path} endpoint for {resource_description}.

Framework: {framework}
Auth: {auth_method}
Database: {database}

The endpoint should:
- {functionality_1}
- {functionality_2}
- {functionality_3}

Provide:
1. Route definition with middleware chain
2. Request validation schema ({validation_library})
3. Controller/handler function
4. Service layer function
5. Database query/function
6. Response types (success and error)
7. Example curl request and response

Plantilla 5: Migração de base de datos

Create a database migration for {change_description}.

Current schema:
```
{current_schema}
```

Desired changes:
- {change_1}
- {change_2}

ORM: {orm_name}
Database: {database_type}

Requirements:
- Migration must be reversible (include down migration)
- Preserve existing data (write data migration SQL if needed)
- Add appropriate indexes for new columns
- Consider performance impact on large tables
- Include rollback safety checks

Plantilla 6: Geração de suite de experimentas

Write a comprehensive test suite for {function_or_class_name}.

Testing framework: {framework}
Mocking library: {library}

Code under test:
```
{paste_code}
```

Test categories to cover:
- ✅ Happy path: All valid inputs produce correct outputs
- 🔄 Edge cases: Empty inputs, boundary values, null/undefined
- ❌ Error cases: Invalid inputs, permission denied, network failures
- 🏎️ Performance: Response time expectations for critical paths
- 🔒 Security: Auth checks, input sanitization

For each test:
- Use descriptive test names that read like documentation
- Follow Arrange-Act-Assert pattern
- Include setup/teardown for shared state
- Mock external dependencies

Plantilla 7: Plan de refactorização

You are a software architect specializing in {language} refactoring.

Current code:
```
{paste_current_code}
```

Problems with current code:
- {problem_1}
- {problem_2}

Refactor using {pattern_or_principle}.

Provide:
1. **Analysis:** What's wrong and why the current approach doesn't scale
2. **Target Architecture:** How the refactored code should be structured
3. **Step-by-step Plan:** Ordered refactoring steps (safe, incremental)
4. **Refactored Code:** Complete implementation
5. **Migration Guide:** How to transition from old to new without breaking changes
6. **Risk Assessment:** What could go wrong and how to mitigate

Plantilla 8: Geração de documentação

Generate documentation for this {language} code:

```
{paste_code}
```

Documentation type: {JSDoc/TSDoc/Python docstrings/README section}

Requirements:
- Document all public functions/classes/methods
- Include parameter descriptions with types
- Include return type descriptions
- Add usage examples for non-obvious APIs
- Note any side effects or important caveats
- Use {style_guide} conventions

For README documentation, include:
- Overview (1-2 paragraphs)
- Installation instructions
- Quick start example
- API reference table
- Configuration options

Plantilla 9: Otimização de performance

You are a performance engineering specialist.

Analyze and optimize this code for performance:

```
{paste_code}
```

Current performance:
- {metric}: {current_value}
- Target: {target_value}
- Bottleneck suspected at: {location}

Optimization constraints:
- Must not change the public API
- Must maintain all existing test passes
- Must not sacrifice readability for micro-optimizations
- {additional_constraint}

Provide:
1. **Profiling Analysis:** Where time/memory is being spent
2. **Optimization Strategies:** Ranked by expected impact
3. **Optimized Code:** With comments explaining each change
4. **Benchmark Comparison:** Before vs after expected metrics
5. **Trade-offs:** Any readability or complexity costs

Plantilla 10: Auditoria de segurança

You are a security engineer specializing in {language}/{framework} security.

Perform a security audit on this code:

```
{paste_code}
```

Check for:
- Injection attacks (SQL, NoSQL, command, LDAP)
- Authentication and authorization bypasses
- Cross-site scripting (XSS) vulnerabilities
- Cross-site request forgery (CSRF) exposure
- Insecure direct object references (IDOR)
- Sensitive data exposure (logging, error messages)
- Insecure cryptography or key management
- Race conditions in concurrent operations
- Denial of service vulnerabilities

For each finding:
- Severity: Critical / High / Medium / Low
- OWASP Category: Which Top 10 category
- Description: Clear explanation of the vulnerability
- Attack Scenario: How an attacker would exploit it
- Remediation: Specific code fix
- Verification: How to confirm the fix works