Concevoir une Interface

Génère plusieurs conceptions d'interface radicalement différentes pour un module à l'aide de sous-agents parallèles. À utiliser lorsque l'utilisateur souhaite concevoir une API, explorer des options d'interface, comparer des formes de modules, ou mentionne 'concevoir deux fois'.

Qu'est-ce que Concevoir une Interface ?

Cette compétence implémente le principe 'Design It Twice' issu de 'A Philosophy of Software Design' pour les agents IA. Elle aide les développeurs à générer plusieurs conceptions d'interface radicalement différentes pour un module donné, en utilisant des sous-agents parallèles. L'utilisateur est guidé à travers un processus en cinq étapes : recueil des besoins, génération parallèle de conceptions (3+ sous-agents avec des contraintes différentes), présentation séquentielle, comparaison selon des critères tels que la simplicité, la profondeur et l'efficacité d'implémentation, et enfin synthèse pour combiner les meilleures idées. La compétence est particulièrement utile pour la conception d'API et l'exploration d'options architecturales, en évitant les anti-patterns comme la similarité des conceptions ou l'évaluation basée sur l'effort d'implémentation. Elle est conçue pour être utilisée avec des agents comme Claude Code, Cursor ou Codex via l'outil Task.

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

Installed? Explore more Développement et programmation skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Que fait Concevoir une Interface ?

Basé sur 'Design It Twice' (Concevez-le deux fois) du livre 'A Philosophy of Software Design' : votre première idée a peu de chances d'être la meilleure. Générez plusieurs conceptions radicalement différentes, puis comparez-les.

Workflow

1. Recueillir les besoins

Avant de concevoir, comprenez :

  • Quel problème ce module résout-il ?
  • Qui sont les appelants ? (autres modules, utilisateurs externes, tests)
  • Quelles sont les opérations clés ?
  • Y a-t-il des contraintes ? (performance, compatibilité, modèles existants)
  • Qu'est-ce qui doit être caché à l'intérieur vs exposé ?

Demandez : 'Qu'est-ce que ce module doit faire ? Qui l'utilisera ?'

2. Générer les conceptions (sous-agents parallèles)

Lancez 3+ sous-agents simultanément à l'aide de l'outil Task. Chacun doit produire une approche radicalement différente.

Modèle de prompt pour chaque sous-agent :

Concevez une interface pour : [description du module]

Besoins : [besoins recueillis]

Contrainte pour cette conception : [attribuez une contrainte différente à chaque agent]
- Agent 1 : 'Minimiser le nombre de méthodes - viser 1 à 3 méthodes maximum'
- Agent 2 : 'Maximiser la flexibilité - prendre en charge de nombreux cas d'utilisation'
- Agent 3 : 'Optimiser pour le cas le plus courant'
- Agent 4 : 'S'inspirer de [paradigme/bibliothèque spécifique]'

Format de sortie :
1. Signature de l'interface (types/méthodes)
2. Exemple d'utilisation (comment l'appelant l'utilise)
3. Ce que cette conception cache en interne
4. Compromis de cette approche

3. Présenter les conceptions

Affichez chaque conception avec :

  1. Signature de l'interface - types, méthodes, paramètres
  2. Exemples d'utilisation - comment les appelants l'utilisent en pratique
  3. Ce qu'elle cache - complexité maintenue en interne

Présentez les conceptions séquentiellement pour que l'utilisateur puisse assimiler chaque approche avant la comparaison.

4. Comparer les conceptions

Après avoir montré toutes les conceptions, comparez-les selon :

  • Simplicité de l'interface : moins de méthodes, paramètres plus simples
  • Généraliste vs spécialisée : flexibilité vs concentration
  • Efficacité d'implémentation : la forme permet-elle une implémentation efficace ?
  • Profondeur : petite interface cachant une complexité significative (bon) vs grande interface avec implémentation fine (mauvais)
  • Facilité d'utilisation correcte vs facilité de mauvaise utilisation

Discutez des compromis en prose, pas en tableaux. Mettez en évidence les points de divergence maximale entre les conceptions.

5. Synthèse

Souvent, la meilleure conception combine des idées issues de plusieurs options. Demandez :

  • 'Quelle conception correspond le mieux à votre cas d'utilisation principal ?'
  • 'Y a-t-il des éléments d'autres conceptions qui méritent d'être intégrés ?'

Critères d'évaluation

D'après 'A Philosophy of Software Design' :

Simplicité de l'interface : moins de méthodes, paramètres plus simples = plus facile à apprendre et à utiliser correctement.

Généraliste : peut gérer des cas d'utilisation futurs sans modifications. Mais attention à la surgénéralisation.

Efficacité d'implémentation : la forme de l'interface permet-elle une implémentation efficace ? Ou force-t-elle un fonctionnement interne maladroit ?

Profondeur : petite interface cachant une complexité significative = module profond (bon). Grande interface avec implémentation fine = module superficiel (à éviter).

Anti-patrons

  • Ne laissez pas les sous-agents produire des conceptions similaires - imposez des différences radicales
  • Ne sautez pas la comparaison - la valeur réside dans le contraste
  • Ne passez pas à l'implémentation - il s'agit uniquement de la forme de l'interface
  • N'évaluez pas en fonction de l'effort d'implémentation

Skills associés