Projete uma Interface
Baseado em "Projete Duas Vezes" de "Uma Filosofia de Design de Software": sua primeira ideia dificilmente será a melhor. Gere múltiplos designs radicalmente diferentes e depois compare.
Fluxo de Trabalho
1. Coletar Requisitos
Antes de projetar, entenda:
- Que problema este módulo resolve?
- Quem são os chamadores? (outros módulos, usuários externos, testes)
- Quais são as operações principais?
- Há restrições? (desempenho, compatibilidade, padrões existentes)
- O que deve ser escondido internamente versus exposto?
Pergunte: "O que este módulo precisa fazer? Quem vai usá-lo?"
2. Gerar Designs (Subagentes Paralelos)
Crie 3+ subagentes simultaneamente usando a ferramenta Task. Cada um deve produzir uma abordagem radicalmente diferente.
Modelo de prompt para cada subagente:
Projete uma interface para: [descrição do módulo]
Requisitos: [requisitos coletados]
Restrições para este design: [atribua uma restrição diferente a cada agente]
- Agente 1: "Minimize o número de métodos - mire no máximo 1-3 métodos"
- Agente 2: "Maximize a flexibilidade - suporte muitos casos de uso"
- Agente 3: "Otimize para o caso mais comum"
- Agente 4: "Inspire-se em [paradigma/biblioteca específico]"
Formato de saída:
1. Assinatura da interface (tipos/métodos)
2. Exemplo de uso (como o chamador a usa)
3. O que este design esconde internamente
4. Compensações desta abordagem
3. Apresentar os Designs
Mostre cada design com:
- Assinatura da interface - tipos, métodos, parâmetros
- Exemplos de uso - como os chamadores realmente a usam na prática
- O que ela esconde - complexidade mantida internamente
Apresente os designs sequencialmente para que o usuário absorva cada abordagem antes da comparação.
4. Comparar os Designs
Após mostrar todos os designs, compare-os com base em:
- Simplicidade da interface: menos métodos, parâmetros mais simples
- Propósito geral vs especializado: flexibilidade versus foco
- Eficiência da implementação: o formato permite uma implementação eficiente?
- Profundidade: interface pequena escondendo complexidade significativa (bom) versus interface grande com implementação fina (ruim)
- Facilidade de uso correto versus facilidade de uso incorreto
Discuta as compensações em texto, não em tabelas. Destaque onde os designs mais divergem.
5. Sintetizar
Frequentemente o melhor design combina insights de múltiplas opções. Pergunte:
- "Qual design melhor se encaixa no seu caso de uso principal?"
- "Há elementos de outros designs que valem a pena incorporar?"
Critérios de Avaliação
De "Uma Filosofia de Design de Software":
Simplicidade da interface: Menos métodos, parâmetros mais simples = mais fácil de aprender e usar corretamente.
Propósito geral: Pode lidar com casos de uso futuros sem alterações. Mas cuidado com a generalização excessiva.
Eficiência da implementação: O formato da interface permite uma implementação eficiente? Ou força complexidades internas desnecessárias?
Profundidade: Interface pequena escondendo complexidade significativa = módulo profundo (bom). Interface grande com implementação fina = módulo raso (evitar).
Antipadrões
- Não deixe que subagentes produzam designs semelhantes - exija diferença radical
- Não pule a comparação - o valor está no contraste
- Não implemente - isto é puramente sobre o formato da interface
- Não avalie com base no esforço de implementação