Projetar uma Interface

Gere múltiplos designs de interface radicalmente diferentes para um módulo usando subagentes paralelos. Use quando o usuário quiser projetar uma API, explorar opções de interface, comparar formatos de módulo ou mencionar 'projete duas vezes'.

O que é Projetar uma Interface?

Esta skill capacita o agente a aplicar o princípio 'Projete Duas Vezes' do livro 'Uma Filosofia de Design de Software' de John Ousterhout. Em vez de se contentar com a primeira ideia, ela orquestra múltiplos subagentes para criar simultaneamente abordagens de interface radicalmente diferentes para um módulo. O processo inclui: (1) coleta de requisitos com perguntas focadas, (2) geração paralela de 3+ designs com restrições distintas (como minimizar métodos, maximizar flexibilidade, otimizar para o caso comum), (3) apresentação sequencial de cada design com assinatura, exemplo de uso e o que é ocultado internamente, (4) comparação detalhada usando critérios como simplicidade da interface, profundidade do módulo e facilidade de uso correto, e (5) síntese para combinar os melhores insights. A skill é útil para qualquer desenvolvedor que esteja projetando uma API, refatorando módulos ou explorando opções de design, e funciona em qualquer plataforma de agente que suporte ferramentas de task para subagentes paralelos. Ela se baseia diretamente nos conceitos de design profundo (pequena interface escondendo complexidade significativa) versus design raso, e fornece critérios de avaliação claros para evitar armadilhas comuns, como designs muito semelhantes ou pular a fase de comparação.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/AppuzMathew9/Skill/tree/main/skills/design-an-interface

Installed? Explore more Programação e Desenvolvimento skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

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:

  1. Assinatura da interface - tipos, métodos, parâmetros
  2. Exemplos de uso - como os chamadores realmente a usam na prática
  3. 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

Habilidades Relacionadas