CommunityProgramación y desarrollogithub.com

diseñar-una-interfaz

Genera múltiples diseños de interfaz radicalmente diferentes para un módulo usando subagentes en paralelo. Útil cuando el usuario quiere diseñar una API, explorar opciones de interfaz, comparar formas de módulos o menciona 'diseñarlo dos veces'.

¿Qué es diseñar-una-interfaz?

Esta habilidad implementa el principio 'Diseñarlo dos veces' del libro 'Una filosofía del diseño de software' de John Ousterhout. Su propósito es ayudar a desarrolladores a explorar múltiples alternativas de diseño de interfaz para un módulo, en lugar de conformarse con la primera idea que se les ocurra. El flujo de trabajo comienza con la recopilación de requisitos (problema a resolver, quiénes son los llamadores, operaciones clave, restricciones). Luego lanza 3 o más subagentes en paralelo, cada uno con una restricción de diseño diferente (por ejemplo, minimizar número de métodos, maximizar flexibilidad, optimizar para el caso más común, inspirarse en un paradigma específico). Cada subagente produce una propuesta que incluye firma de interfaz, ejemplo de uso, lo que oculta internamente y las ventajas/desventajas del enfoque. Tras presentar los diseños, se comparan en simplicidad, propósito general vs. especializado, eficiencia de implementación, profundidad del módulo y facilidad de uso correcto. Finalmente, se sintetiza la mejor solución combinando ideas. La habilidad es compatible con cualquier agente de IA que pueda lanzar subagentes (como Claude Code o Cursor) y está diseñada para mejorar la calidad de las decisiones arquitectónicas.

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

Installed? Explore more Programación y desarrollo skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Diseñar una Interfaz

Basado en 'Diseñarlo dos veces' de 'Una filosofía del diseño de software': tu primera idea probablemente no sea la mejor. Genera múltiples diseños radicalmente diferentes y luego compáralos.

Flujo de trabajo

1. Recopilar Requisitos

Antes de diseñar, comprende:

  • ¿Qué problema resuelve este módulo?
  • ¿Quiénes son los llamadores? (otros módulos, usuarios externos, pruebas)
  • ¿Cuáles son las operaciones clave?
  • ¿Alguna restricción? (rendimiento, compatibilidad, patrones existentes)
  • ¿Qué debe ocultarse internamente vs. exponerse?

Pregunta: '¿Qué necesita hacer este módulo? ¿Quién lo usará?'

2. Generar Diseños (Subagentes en Paralelo)

Lanza 3+ subagentes simultáneamente usando la herramienta Task. Cada uno debe producir un enfoque radicalmente diferente.

Plantilla de prompt para cada subagente:

Diseña una interfaz para: [descripción del módulo]

Requisitos: [requisitos recopilados]

Restricción para este diseño: [asignar una restricción diferente a cada agente]
- Agente 1: 'Minimizar el número de métodos - apuntar a 1-3 métodos como máximo'
- Agente 2: 'Maximizar la flexibilidad - soportar muchos casos de uso'
- Agente 3: 'Optimizar para el caso más común'
- Agente 4: 'Inspirarse en [paradigma/biblioteca específico]'

Formato de salida:
1. Firma de la interfaz (tipos/métodos)
2. Ejemplo de uso (cómo lo usa el llamador)
3. Lo que este diseño oculta internamente
4. Ventajas y desventajas de este enfoque

3. Presentar Diseños

Muestra cada diseño con:

  1. Firma de la interfaz - tipos, métodos, parámetros
  2. Ejemplos de uso - cómo lo usan realmente los llamadores en la práctica
  3. Lo que oculta - complejidad mantenida interna

Presenta los diseños secuencialmente para que el usuario pueda asimilar cada enfoque antes de comparar.

4. Comparar Diseños

Después de mostrar todos los diseños, compáralos según:

  • Simplicidad de la interfaz: menos métodos, parámetros más simples
  • Propósito general vs. especializado: flexibilidad vs. enfoque
  • Eficiencia de implementación: ¿la forma permite una implementación eficiente?
  • Profundidad: interfaz pequeña que oculta complejidad significativa (bueno) vs. interfaz grande con implementación delgada (malo)
  • Facilidad de uso correcto vs. facilidad de mal uso

Discute las ventajas y desventajas en prosa, no en tablas. Destaca dónde los diseños divergen más.

5. Sintetizar

A menudo el mejor diseño combina ideas de múltiples opciones. Pregunta:

  • '¿Qué diseño se adapta mejor a tu caso de uso principal?'
  • '¿Hay elementos de otros diseños que valga la pena incorporar?'

Criterios de Evaluación

De 'Una filosofía del diseño de software':

Simplicidad de la interfaz: Menos métodos, parámetros más simples = más fácil de aprender y usar correctamente.

Propósito general: Puede manejar casos de uso futuros sin cambios. Pero cuidado con la sobre-generalización.

Eficiencia de implementación: ¿La forma de la interfaz permite una implementación eficiente? ¿O fuerza mecánicas internas incómodas?

Profundidad: Interfaz pequeña que oculta complejidad significativa = módulo profundo (bueno). Interfaz grande con implementación delgada = módulo superficial (evitar).

Anti-patrones

  • No permitas que los subagentes produzcan diseños similares - impón diferencias radicales
  • No te saltes la comparación - el valor está en el contraste
  • No implementes - esto es puramente sobre la forma de la interfaz
  • No evalúes basándote en el esfuerzo de implementación

Skills relacionados