IA transformou o desenvolvimento de software. Este capítulo cobre técnicas de prompting para geração de código, debugging, revisão e workflows de desenvolvimento.

<Callout type="info" title="IA como Parceira de Código">
IA se destaca em geração de código, debugging e documentação—mas sempre revise código gerado para segurança, correção e manutenibilidade. Nunca implante código de IA sem testar.
</Callout>

## Geração de Código

### O Que Fazer e Não Fazer: Prompts de Código

<Compare 
  before={{ label: "❌ Requisição vaga", content: "Escreva uma função para validar emails." }}
  after={{ label: "✓ Especificação completa", content: "Escreva uma função Python que valida endereços de email.\n\nEntrada: string (email potencial)\nSaída: tuple[bool, str | None] - (is_valid, error_message)\nTrate: string vazia, None, caracteres unicode\nUse regex, inclua type hints e docstring." }}
/>

### Geração de Função

<TryIt compact prompt={`Escreva uma função \${linguagem:Python} que \${descricao:valida endereços de email}.

Requisitos:
- Entrada: \${tiposEntrada:string (email potencial)}
- Saída: \${tipoSaida:boolean e mensagem de erro opcional}
- Trate casos limite: \${casosLimite:string vazia, None, caracteres unicode}
- Performance: \${performance:padrão}

Inclua:
- Type hints/annotations
- Docstring com exemplos
- Validação de entrada
- Tratamento de erros`} />

### Geração de Classe/Módulo

<TryIt compact prompt={`Crie uma classe \${linguagem:Python} para \${proposito:gerenciar sessões de usuário}.

Design da classe:
- Nome: \${nomeClasse:SessionManager}
- Responsabilidade: \${responsabilidade:gerenciar ciclo de vida de sessão do usuário}
- Propriedades: \${propriedades:session_id, user_id, created_at, expires_at}
- Métodos: \${metodos:create(), validate(), refresh(), destroy()}

Requisitos:
- Siga padrão \${padraoDesign:Singleton}
- Inclua encapsulamento adequado
- Adicione docstrings abrangentes
- Inclua exemplo de uso

Testes:
- Inclua esqueleto de teste unitário`} />

### Geração de Endpoint de API

<TryIt compact prompt={`Crie um endpoint de API REST para \${recurso:perfis de usuário}.

Framework: \${framework:FastAPI}
Método: \${metodo:GET}
Caminho: \${caminho:/api/users/{id}}

Requisição:
- Headers: \${headers:Authorization Bearer token}
- Schema do body: \${schemaBody:N/A para GET}
- Query params: \${queryParams:include_posts (boolean)}

Resposta:
- Sucesso: \${respostaSucesso:200 com objeto usuário}
- Erros: \${respostasErro:401 Não Autorizado, 404 Não Encontrado}

Inclua:
- Validação de entrada
- Verificação de autenticação
- Tratamento de erros
- Consideração de rate limiting`} />

## Debugging

<Callout type="tip" title="Princípio de Debugging">
Sempre inclua o **comportamento esperado**, **comportamento real** e **mensagem de erro** (se houver). Quanto mais contexto você fornecer, mais rápido IA pode identificar a causa raiz.
</Callout>

### Análise de Bug

<TryIt compact prompt={`Faça debug deste código. Ele deveria \${comportamentoEsperado:retornar a soma de todos os números} mas em vez disso \${comportamentoReal:retorna 0 para todas entradas}.

Código:
\${codigo:cole seu código aqui}

Mensagem de erro (se houver):
\${erro:nenhum}

Passos para debug:
1. Identifique o que o código está tentando fazer
2. Trace a execução com a entrada dada
3. Encontre onde comportamento esperado e real divergem
4. Explique a causa raiz
5. Forneça a correção com explicação`} />

### Interpretação de Mensagem de Erro

<TryIt compact prompt={`Explique este erro e como corrigir:

Erro:
\${mensagemErro:cole mensagem de erro ou stack trace aqui}

Contexto:
- Linguagem/Framework: \${framework:Python 3.11}
- O que eu estava tentando fazer: \${acao:lendo um arquivo JSON}
- Código relevante: \${trechoCodigo:cole código relevante}

Forneça:
1. Explicação em português claro do erro
2. Causa raiz
3. Correção passo a passo
4. Como prevenir isso no futuro`} />

### Debugging de Performance

<TryIt compact prompt={`Este código está lento. Analise e otimize:

Código:
\${codigo:cole seu código aqui}

Performance atual: \${performanceAtual:leva 30 segundos para 1000 itens}
Performance alvo: \${performanceAlvo:menos de 5 segundos}
Restrições: \${restricoes:limite de memória 512MB}

Forneça:
1. Identifique gargalos
2. Explique por que cada um é lento
3. Sugira otimizações (ranqueadas por impacto)
4. Mostre código otimizado
5. Estime melhoria`} />

## Revisão de Código

### O Que Fazer e Não Fazer: Prompts de Revisão de Código

<Compare 
  before={{ label: "❌ Requisição genérica", content: "Revise este código." }}
  after={{ label: "✓ Critérios específicos", content: "Revise este código para um pull request.\n\nVerifique:\n1. Correção: bugs, erros de lógica, casos limite\n2. Segurança: riscos de injeção, problemas de auth\n3. Performance: N+1 queries, memory leaks\n4. Manutenibilidade: nomenclatura, complexidade\n\nFormato: 🔴 Crítico / 🟡 Importante / 🟢 Sugestão" }}
/>

### Revisão Abrangente

<TryIt compact prompt={`Revise este código para um pull request.

Código:
\${codigo:cole seu código aqui}

Revise para:
1. **Correção**: Bugs, erros de lógica, casos limite
2. **Segurança**: Vulnerabilidades, riscos de injeção, problemas de auth
3. **Performance**: Ineficiências, N+1 queries, memory leaks
4. **Manutenibilidade**: Legibilidade, nomenclatura, complexidade
5. **Melhores práticas**: convenções \${framework:Python/Django}

Formate sua revisão como:
🔴 Crítico: deve corrigir antes de merge
🟡 Importante: deveria corrigir
🟢 Sugestão: seria bom ter
💭 Pergunta: esclarecimento necessário`} />

### Revisão de Segurança

<TryIt compact prompt={`Realize uma revisão de segurança deste código:

Código:
\${codigo:cole seu código aqui}

Verifique:
- [ ] Vulnerabilidades de injeção (SQL, XSS, comando)
- [ ] Falhas de autenticação/autorização
- [ ] Exposição de dados sensíveis
- [ ] Dependências inseguras
- [ ] Problemas criptográficos
- [ ] Lacunas de validação de entrada
- [ ] Tratamento de erro que vaza info

Para cada descoberta:
- Severidade: Crítico/Alto/Médio/Baixo
- Localização: Número da linha ou função
- Problema: Descrição
- Exploração: Como poderia ser atacado
- Correção: Remediação recomendada`} />

## Refatoração

### Detecção de Code Smells

<TryIt compact prompt={`Analise este código por code smells e oportunidades de refatoração:

Código:
\${codigo:cole seu código aqui}

Identifique:
1. Métodos longos (sugira extração)
2. Código duplicado (sugira melhorias DRY)
3. Condicionais complexos (sugira simplificação)
4. Nomenclatura pobre (sugira nomes melhores)
5. Acoplamento forte (sugira desacoplamento)

Para cada problema, mostre código antes/depois.`} />

### Aplicação de Design Pattern

<TryIt compact prompt={`Refatore este código usando o padrão \${nomePadrao:Factory}.

Código atual:
\${codigo:cole seu código aqui}

Objetivos:
- \${porquePadrao:desacoplar criação de objeto do uso}
- \${beneficios:testes e extensibilidade mais fáceis}

Forneça:
1. Explicação do padrão
2. Como se aplica aqui
3. Código refatorado
4. Trade-offs a considerar`} />

## Testes

### Geração de Teste Unitário

<TryIt compact prompt={`Escreva testes unitários para esta função:

Função:
\${codigo:cole sua função aqui}

Framework de teste: \${frameworkTeste:pytest}

Cubra:
- Caminho feliz (entradas normais)
- Casos limite (vazio, null, valores de fronteira)
- Casos de erro (entradas inválidas)
- \${cenariosEspecificos:acesso concorrente, entradas grandes}

Formato: padrão Arrange-Act-Assert
Inclua: Nomes de teste descritivos`} />

### Geração de Casos de Teste

<TryIt compact prompt={`Gere casos de teste para esta funcionalidade:

Funcionalidade: \${descricaoFuncionalidade:registro de usuário com verificação de email}
Critérios de aceitação: \${criteriosAceitacao:usuário pode se cadastrar, recebe email, pode verificar conta}

Forneça casos de teste neste formato:

| ID | Cenário | Dado | Quando | Então | Prioridade |
|----|---------|------|--------|-------|------------|
| TC01 | ... | ... | ... | ... | Alta |`} />

## Arquitetura & Design

### Design de Sistema

<TryIt compact prompt={`Projete um sistema para \${requisito:aplicação de chat em tempo real}.

Restrições:
- Carga esperada: \${cargaEsperada:10.000 usuários concorrentes}
- Requisitos de latência: \${latencia:< 100ms entrega de mensagem}
- Disponibilidade: \${disponibilidade:99.9%}
- Orçamento: \${orcamento:moderado, preferir open source}

Forneça:
1. Diagrama de arquitetura de alto nível (ASCII/texto)
2. Descrições dos componentes
3. Fluxo de dados
4. Escolhas de tecnologia com justificativa
5. Estratégia de escalabilidade
6. Trade-offs e alternativas consideradas`} />

### Design de Schema de Banco de Dados

<TryIt compact prompt={`Projete um schema de banco de dados para \${aplicacao:plataforma de e-commerce}.

Requisitos:
- \${funcionalidade1:Contas de usuário com perfis e endereços}
- \${funcionalidade2:Catálogo de produtos com categorias e variantes}
- \${funcionalidade3:Pedidos com itens de linha e rastreamento de pagamento}

Forneça:
1. Descrição de entidade-relacionamento
2. Definições de tabela com colunas e tipos
3. Índices para queries comuns
4. Relacionamentos de chave estrangeira
5. Queries de exemplo para operações-chave`} />

## Geração de Documentação

### Documentação de API

<TryIt compact prompt={`Gere documentação de API a partir deste código:

Código:
\${codigo:cole seu código de endpoint aqui}

Formato: \${formato:OpenAPI/Swagger YAML}

Inclua:
- Descrição do endpoint
- Schemas de request/response
- Exemplos de requests/responses
- Códigos de erro
- Requisitos de autenticação`} />

### Documentação Inline

<TryIt compact prompt={`Adicione documentação abrangente a este código:

Código:
\${codigo:cole seu código aqui}

Adicione:
- Docstring de arquivo/módulo (propósito, uso)
- Docstrings de função/método (params, returns, raises, exemplos)
- Comentários inline apenas para lógica complexa
- Type hints se faltando

Estilo: \${estiloDoc:Google}`} />

## Templates de Prompt do prompts.chat

### Aja como um Desenvolvedor Sênior

```
Quero que você aja como um desenvolvedor de software sênior. Vou 
fornecer código e fazer perguntas sobre ele. Você revisará o código, 
sugerirá melhorias, explicará conceitos e ajudará a debugar problemas. 
Suas respostas devem ser educativas e me ajudar a me tornar um 
desenvolvedor melhor.
```

### Aja como um Revisor de Código

```
Quero que você aja como um revisor de código. Vou fornecer pull 
requests com mudanças de código, e você os revisará completamente. 
Verifique bugs, problemas de segurança, problemas de performance e 
aderência a melhores práticas. Forneça feedback construtivo que 
ajude o desenvolvedor a melhorar.
```

### Aja como um Arquiteto de Software

```
Quero que você aja como um arquiteto de software. Vou descrever 
requisitos e restrições de sistema, e você projetará arquiteturas 
escaláveis e manuteníveis. Explique suas decisões de design, 
trade-offs e forneça diagramas quando útil.
```

## Integração com Workflow de Desenvolvimento

### Geração de Mensagem de Commit

<TryIt compact prompt={`Gere uma mensagem de commit para estas mudanças:

Diff:
\${diff:cole git diff aqui}

Formato: Conventional Commits
Tipo: \${tipoCommit:feat}

Forneça:
- Linha de assunto (50 chars máx, modo imperativo)
- Corpo (o que e por que, quebrado em 72 chars)
- Rodapé (referencia issues se aplicável)`} />

### Geração de Descrição de PR

<TryIt compact prompt={`Gere uma descrição de pull request:

Mudanças:
\${mudancas:liste suas mudanças ou cole resumo do diff}

Template:
## Resumo
Breve descrição das mudanças

## Mudanças Feitas
- Mudança 1
- Mudança 2

## Testes
- [ ] Testes unitários adicionados/atualizados
- [ ] Teste manual completado

## Screenshots (se mudanças de UI)
placeholder

## Issues Relacionadas
Fecha #\${numeroIssue:123}`} />

## Resumo

<Callout type="tip" title="Técnicas-Chave">
Inclua contexto completo (linguagem, framework, restrições), especifique requisitos precisamente, solicite formatos de saída específicos, peça explicações junto com código, e inclua casos limite para tratar.
</Callout>

<Quiz 
  question="Qual é o elemento mais importante a incluir ao pedir para IA fazer debug de código?"
  options={[
    "Apenas a linguagem de programação",
    "Comportamento esperado, comportamento real e mensagem de erro",
    "Apenas o trecho de código",
    "O nome do arquivo"
  ]}
  correctIndex={1}
  explanation="Debugging requer contexto: o que deveria acontecer vs. o que realmente acontece. Mensagens de erro e stack traces ajudam IA a identificar o problema exato rapidamente."
/>

IA é uma parceira de código poderosa—use para geração, revisão, debugging e documentação enquanto mantém seu julgamento arquitetural.
