> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Guia rápido de templates de prompt

> Templates de prompt prontos para uso em tarefas comuns

<Note>Use estes templates como ponto de partida para seus prompts. Personalize as seções entre colchetes `[como esta]` de acordo com suas necessidades específicas.</Note>

<div id="bug-fixes">
  ## Correções de bugs
</div>

<div id="fix-a-specific-bug">
  ### Corrigir um bug específico
</div>

```
Corrija o bug em que `[describe the bug behavior]`.

Etapas para reproduzir:
1. `[Step 1]`
2. `[Step 2]`
3. `[Step 3]`

Comportamento esperado: `[what should happen]`
Comportamento atual: `[what actually happens]`

Por favor:
1. Investigue a causa raiz em `[relevant file/directory]`
2. Implemente uma correção que resolva a causa raiz
3. Adicione um teste de regressão para evitar que esse problema ocorra novamente
4. Execute o conjunto de testes existente para garantir que não haja regressões
```

<div id="investigate-production-issue">
  ### Investigar problema em produção
</div>

```
Usuários estão relatando `[descreva o problema]` em produção.

Por favor:
1. Use o MCP `[Sentry/DataDog/ferramenta de monitoramento de logs]` para obter logs de erros recentes e stack traces
2. Identifique a causa raiz do problema
3. Implemente uma correção
4. Adicione tratamento de erros adequado para evitar problemas semelhantes
5. Crie um teste de regressão
6. Vincule o monitoramento/alerta na descrição do PR
```

<div id="feature-implementation">
  ## Implementação de funcionalidades
</div>

<div id="add-a-new-api-endpoint">
  ### Adicionar um novo endpoint de API
</div>

```
Create a new API endpoint `[endpoint path]` that `[describe what it does]`.

Requirements:
- Method: `[GET/POST/PUT/DELETE]`
- Request body: `[describe request structure]`
- Response format: `[describe response structure]`
- Authentication: `[describe auth requirements]`

Please:
1. Reference the existing `[similar endpoint file]` for patterns
2. Implement the endpoint following our existing conventions
3. Add input validation and error handling
4. Write unit tests for the new endpoint
5. Update API documentation if applicable
6. Run the test suite to ensure everything passes
```

<div id="add-a-new-ui-component">
  ### Adicionar um novo componente de UI
</div>

```
Add a new `[component type]` component to `[file/location]`.

Requirements:
- Component name: `[ComponentName]`
- Props: `[list props and their types]`
- Functionality: `[describe what it should do]`
- Styling: Use `[existing component/library]` as a reference

Please:
1. Create the component following our existing patterns
2. Implement the required functionality
3. Add proper TypeScript types
4. Style it to match our design system
5. Add unit tests for the component
6. Integrate it into `[parent component/page]`
7. Test it manually by running the dev server
```

<div id="implement-a-feature-from-design">
  ### Implemente uma funcionalidade com base no design
</div>

```
Implement the `[feature name]` from this design file: `[Figma/link to design]`

Focus on the `[specific frame/section]` frame.

Requirements:
- Use our existing components from `[component library path]`
- Follow the styling in `[design system file]`
- Ensure responsive design at `[breakpoint 1]` and `[breakpoint 2]`

Please:
1. Implement the feature following the design specifications
2. Reuse existing components where possible
3. Test at desktop (1440px) and mobile (375px) widths
4. Take screenshots to verify it matches the design
5. Do not open a PR until it visually matches the design
```

<div id="code-refactoring">
  ## Refatoração de código
</div>

<div id="refactor-a-module">
  ### Refatore um módulo
</div>

```
Refactor the `[module/file name]` to improve `[specific aspect: maintainability/performance/readability]`.

Current issues:
- `[Issue 1]`
- `[Issue 2]`
- `[Issue 3]`

Requirements:
- Keep all existing functionality intact
- Follow the patterns in `[reference file]`
- Improve `[specific metric: code complexity/performance]`

Please:
1. Analyze the current implementation
2. Refactor following best practices
3. Ensure all existing tests still pass
4. Add tests for any new functions introduced
5. Run the full test suite
6. Measure and report performance improvements if applicable
```

<div id="convert-to-new-pattern">
  ### Converter para o novo padrão
</div>

```
Converta `[arquivo/diretório]` para usar `[novo padrão/biblioteca/framework]`.

Referência: `[link para documentação ou arquivo de exemplo]`

Requisitos:
- Manter todas as funcionalidades existentes
- Seguir as convenções em `[arquivo de exemplo]`
- Atualizar qualquer código dependente

Por favor:
1. Revise a documentação e os exemplos
2. Converta o código etapa por etapa
3. Atualize os imports e as dependências
4. Certifique-se de que todos os testes passem
5. Execute `[build command]` para verificar se não há erros
6. Teste a funcionalidade manualmente
```

<div id="testing">
  ## Testes
</div>

<div id="add-test-coverage">
  ### Adicione cobertura de testes
</div>

```
Add comprehensive test coverage for `[file/module/function]`.

Current coverage: `[current coverage %]`
Target coverage: `[target coverage %]`

Please:
1. Analyze the existing code to identify edge cases
2. Write unit tests for all public methods
3. Add integration tests if applicable
4. Reference `[existing test file]` for testing patterns
5. Run `npm test -- --coverage` and verify coverage meets target
6. Ensure all tests pass
```

<div id="debug-failing-tests">
  ### Depurar testes que falharam
</div>

```
Corrija os testes com falha em `[test file or directory]`.

Falhas nos testes:
- `[Test name 1]`: `[error message]`
- `[Test name 2]`: `[error message]`

Por favor:
1. Investigue por que esses testes estão falhando
2. Determine se os testes ou a implementação precisam de correção
3. Corrija a causa raiz
4. Garanta que todos os testes do conjunto passem
5. Execute o conjunto completo de testes para verificar se há regressões
```

<div id="documentation">
  ## Documentação
</div>

<div id="document-a-module">
  ### Documentar um módulo
</div>

```
Adicione documentação abrangente a `[file/module]`.

Por favor:
1. Adicione comentários JSDoc/TypeDoc a todas as funções públicas
2. Documente parâmetros, valores de retorno e exceções
3. Adicione exemplos de uso para funções complexas
4. Crie um README se este for um novo módulo
5. Siga nosso guia de estilo de documentação em `[style guide link]`
6. Atualize a documentação principal da API, se aplicável
```

<div id="update-api-documentation">
  ### Atualize a documentação da API
</div>

```
Atualize a documentação da API para `[endpoint/function]`.

Alterações realizadas:
- `[Change 1]`
- `[Change 2]`

Por favor:
1. Atualize a especificação `[OpenAPI/Swagger]`
2. Atualize quaisquer comentários de código inline
3. Adicione exemplos de uso caso o comportamento tenha sido alterado
4. Atualize o `[documentation file]`
5. Verifique se o build da documentação é concluído com sucesso
```

<div id="performance-optimization">
  ## Otimização de desempenho
</div>

<div id="optimize-database-queries">
  ### Otimize as consultas ao banco de dados
</div>

```
Otimize as consultas ao banco de dados em `[arquivo/módulo]`.

Problemas de desempenho:
- `[Consulta específica]` está lenta (leva `[tempo]`)
- `[Operação específica]` causa consultas N+1

Por favor:
1. Analise os planos de execução das consultas
2. Adicione índices apropriados em `[tabela/coluna]`
3. Refatore as consultas para usar joins em vez de N+1
4. Faça benchmark antes e depois da otimização
5. Garanta que todos os testes ainda passem
6. Documente as melhorias de desempenho
```

<div id="optimize-frontend-performance">
  ### Otimize o desempenho do frontend
</div>

```
Optimize the performance of `[component/page]`.

Performance issues:
- Slow initial load time
- Large bundle size
- Unnecessary re-renders

Please:
1. Analyze the bundle size using `[bundle analyzer]`
2. Implement code splitting for `[large module]`
3. Add memoization where appropriate
4. Optimize images and assets
5. Lazy load components below the fold
6. Measure performance improvements using Lighthouse
7. Ensure functionality remains intact
```

<div id="security">
  ## Segurança
</div>

<div id="fix-security-vulnerability">
  ### Corrigir vulnerabilidade de segurança
</div>

```
Fix the security vulnerability identified in `[file/module]`.

Vulnerability type: `[e.g., SQL injection, XSS, CSRF]`
Severity: `[High/Medium/Low]`

Please:
1. Review the security advisory: `[link to advisory]`
2. Implement the recommended fix
3. Add input validation and sanitization
4. Add a security test to prevent regression
5. Run the security audit: `[audit command]`
6. Ensure no other similar vulnerabilities exist
```

<div id="add-security-headers">
  ### Adicionar cabeçalhos de segurança
</div>

```
Adicione cabeçalhos de segurança ao `[application/API]`.

Cabeçalhos obrigatórios:
- `[Header 1]`: `[value]`
- `[Header 2]`: `[value]`
- `[Header 3]`: `[value]`

Por favor:
1. Configure os cabeçalhos em `[config file]`
2. Teste se os cabeçalhos estão definidos corretamente usando `[tool/method]`
3. Certifique-se de que as funcionalidades existentes não sejam afetadas
4. Documente as melhorias de segurança
```

<div id="migration-upgrades">
  ## Migração e upgrades
</div>

<div id="upgrade-dependency">
  ### Atualizar dependência
</div>

```
Atualize `[package/library]` da versão `[old version]` para a versão `[new version]`.

Por favor:
1. Revise o changelog para verificar breaking changes: `[changelog link]`
2. Atualize a dependência em `[package.json/requirements.txt]`
3. Atualize qualquer uso de API deprecated
4. Execute o script de migração, se aplicável: `[migration command]`
5. Execute todos os testes para garantir a compatibilidade
6. Teste a aplicação manualmente
7. Atualize a documentação se as APIs foram alteradas
```

<div id="migrate-to-new-service">
  ### Migrar para o novo serviço
</div>

```
Migrate from `[old service]` to `[new service]`.

Reference documentation: `[link to new service docs]`

Please:
1. Set up the new service following the documentation
2. Migrate existing data/configuration
3. Update all code to use the new service
4. Reference `[example file]` for implementation patterns
5. Run integration tests to verify functionality
6. Gradually roll out and monitor for issues
7. Decommission the old service after verification
```

<div id="code-review">
  ## Revisão de código
</div>

<div id="review-a-pull-request">
  ### Revisar um Pull Request
</div>

```
Revise o pull request: `[PR link or number]`

Áreas de foco:
- Qualidade e manutenibilidade do código
- Implicações de desempenho
- Considerações de segurança
- Cobertura de testes
- Documentação

Por favor:
1. Revise cada arquivo alterado
2. Deixe comentários específicos e práticos
3. Verifique se as alterações atendem à descrição do PR
4. Verifique casos de borda e tratamento de erros
5. Certifique-se de que os testes são adequados
6. Aprove ou solicite alterações com feedback claro
```

<div id="general-purpose">
  ## Objetivo geral
</div>

<div id="research-and-implement">
  ### Investigar e implementar
</div>

```
Preciso implementar `[feature/functionality]` usando `[technology/library]`.

Por favor:
1. Pesquise as melhores práticas para `[technology/library]`
2. Encontre e revise a documentação: `[expected doc sources]`
3. Consulte exemplos de código aberto, se aplicável
4. Proponha uma abordagem antes de implementar
5. Implemente a solução seguindo as melhores práticas
6. Adicione testes e documentação
7. Verifique se funciona conforme o esperado
```

<div id="debug-and-fix">
  ### Depuração e correção
</div>

```
Something is wrong with `[feature/component]`.

Symptoms:
- `[Symptom 1]`
- `[Symptom 2]`

Please:
1. Investigate the issue in `[relevant files]`
2. Add logging/debugging statements as needed
3. Identify the root cause
4. Implement a fix
5. Test the fix thoroughly
6. Remove any temporary debugging code
7. Ensure no regressions
```

<Tip>**Dica extra**: Para tarefas recorrentes, considere criar um [Playbook](/pt-BR/product-guides/creating-playbooks) com esses templates para reutilizá-los com facilidade.</Tip>