Protocolo
de implementação

Por que o DIP?

Agentes de código são poderosos, mas sem estrutura eles se enrolam. Jogar um épico inteiro pra um agente gera resultado inconsistente. O DIP resolve isso quebrando o trabalho em partes bem definidas e documentadas que os agentes conseguem executar de forma confiável.

O Protocolo

Sete passos que transformam uma visão de produto em unidades de trabalho estruturadas e executáveis por agentes, mantendo a incerteza explícita.

1. 01

   Reunião de Refinamento

   O time inteiro — Design, Produto, Negócio, Tecnologia — define um marco junto. Alinhamento entre áreas garante que o marco capture todas as perspectivas antes de qualquer código.

2. 02

   Documento do Marco

   O time produz um milestone.md — definição completa do épico, com metas, escopo, critérios de sucesso, restrições e uma baseline de URA (Unknowns, Risks, Assumptions).

3. 03

   Fases de Implementação

   O time de desenvolvimento quebra o marco em fases coerentes no implementation-phases.md. Cada fase é um agrupamento lógico de trabalho que pode ser concluído e validado de forma independente, com snapshot de URA e gate de saída.

4. 04

   PRDs

   Cada fase é quebrada em PRDs individuais — documentos autocontidos que funcionam como cards de Jira detalhados. Um PRD tem tudo que um agente de código precisa: descrição, critérios de aceite, requisitos não-funcionais, URA e contexto técnico.

5. 05

   Implementação

   O agente pega os PRDs da fase ativa e implementa um por um, validando premissas, reduzindo incógnitas e reagindo a gatilhos de risco, atendendo os critérios de aceite.

6. 06

   Relatório de Fase

   Quando todos os PRDs de uma fase são concluídos, um relatório é gerado resumindo o que foi construído, desvios do plano, resultados de URA e contexto necessário pra próxima fase.

7. 07

   Loop

   O ciclo se repete pra cada fase até o marco estar completo. Cada relatório ancora a próxima fase, preservando contexto ao longo de toda a implementação.

project/
├── AGENTS.md
├── .cursor/
│   └── rules/
│       ├── dip-protocol.mdc
│       ├── prd-writing.mdc
│       ├── report-writing.mdc
│       └── milestone-writing.mdc
└── docs/
    └── milestones/
        └── milestone-1/
            ├── milestone.md
            ├── implementation-phases.md
            ├── phases/
            │   ├── phase-1/
            │   │   ├── prd-user-auth.md
            │   │   └── prd-database-schema.md
            │   └── phase-2/
            │       └── prd-api-endpoints.md
            └── reports/
                ├── report-phase-1.md
                └── report-phase-2.md

Artefatos do Agente

O DIP se integra com os artefatos do agente de código pra criar um fluxo completo. Três camadas que se complementam sem sobrepor.

Como é um PRD

Cada PRD é uma unidade de trabalho autocontida — tipo um card de Jira detalhado em markdown. Tem tudo que um agente de código precisa pra implementar aquela parte: critérios de aceite, requisitos não-funcionais, URA, contexto técnico e limites claros.

---
title: User Authentication Flow
status: pending
priority: high
complexity: medium
phase: phase-1
milestone: milestone-1
---

# User Authentication Flow

## Description
Implement email/password authentication with session
management. Users should be able to sign up, log in,
and maintain sessions across page refreshes.

## Acceptance Criteria
- [ ] User can sign up with email and password
- [ ] User can log in with existing credentials
- [ ] Session persists across page refreshes
- [ ] Error messages displayed for invalid inputs
- [ ] Password reset flow via email

## Non-Functional Requirements
- Response time < 200ms for auth endpoints
- Passwords hashed with bcrypt (min 12 rounds)
- Rate limiting: max 5 failed attempts per minute
- HTTPS required for all auth endpoints

## Unknowns, Risks, and Assumptions (URA)
### Unknowns
| Unknown | Why It Matters | Discovery Action | Decision Deadline | Owner | Status |
|---------|----------------|------------------|-------------------|-------|--------|
| Peak auth load profile | Affects session architecture | Run load test with synthetic traffic | 2026-03-12 | Backend Lead | open |

### Assumptions
| Assumption | Confidence (1-5) | Validation Method | Validation Date | Impact If False | Owner | Status |
|------------|------------------|-------------------|-----------------|-----------------|-------|--------|
| Redis cache can sustain p95 < 30ms | 3 | Benchmark in staging | 2026-03-14 | Platform Engineer | open |

### Risks
| Risk Statement (If..., then...) | Likelihood (1-5) | Impact (1-5) | Response | Trigger | Owner | Status |
|---------------------------------|------------------|--------------|----------|---------|-------|--------|
| If auth DB latency spikes, then login completion may drop | 3 | 4 | reduce | p95 DB latency > 150ms for 10m | Backend Lead | monitoring |

## Technical Considerations
- Use JWT tokens stored in httpOnly cookies
- Refresh token rotation for extended sessions
- Consider OAuth2 integration in a future PRD

## Related Files
- src/auth/handlers.ts
- src/middleware/auth.ts
- src/db/schema/users.ts

## Out of Scope
- Social login (Google, GitHub) — separate PRD
- Two-factor authentication — separate PRD
- Admin role management — phase-2

Começando

Adote o DIP no seu projeto em cinco passos. O protocolo funciona com qualquer stack e qualquer agente de código.

1. 1

   Adicionar a estrutura do DIP

   Crie a estrutura de pastas no seu projeto pra abrigar marcos, fases e relatórios.

   mkdir -p docs/milestones/milestone-1/{phases/phase-1,reports}

2. 2

   Copiar os templates

   Baixe os templates do DIP e coloque no seu projeto. Cada template inclui diretrizes de formatação, estrutura de URA e instruções inline para agentes de IA.

3. 3

   Configurar seu AGENTS.md

   Adicione um AGENTS.md na raiz do projeto declarando que o projeto segue o DIP, apontando pro marco ativo e identificando a fase atual.

4. 4

   Adicionar Cursor Rules

   Copie as regras do DIP pra .cursor/rules/ pra orientação automática ao escrever documentos do protocolo. As regras impõem formato de PRD, estrutura de relatório e conformidade com o protocolo.

   cp templates/rules/*.mdc .cursor/rules/

5. 5

   Rodar uma reunião de refinamento

   Reúna seu time — Design, Produto, Negócio, Tecnologia. Defina um marco junto, estabeleça a baseline inicial de URA, quebre o trabalho em fases e comece o loop.