Communitygithub.com

ulasalyesil/site-personnel-v2

Définit les objets, relations, états et le vocabulaire du produit indépendamment de toute interface — la couche la plus porteuse de charge.

Qu'est-ce que site-personnel-v2 ?

Ce skill guide la création du modèle conceptuel d'un produit, la couche la plus négligée et pourtant la plus porteuse de charge. Il définit les objets que le produit reconnaît, leurs relations, leurs états possibles et le vocabulaire utilisé pour tout nommer. Contrairement au modèle du domaine (qui capture le bruit des utilisateurs), le modèle conceptuel est une décision de conception délibérée qui structure le domaine de manière cohérente et tranchée. Il n'est ni un schéma de base de données, ni un wireframe, ni un flux d'écrans : il vit en amont de toute implémentation technique ou design d'interface. L'utilisateur est guidé à travers six phases : (1) cadrer le périmètre, (2) découvrir les objets par forage de noms ou analyse du produit existant, (3) définir chaque objet avec attributs, relations et actions, (4) créer une carte relationnelle des objets, (5) définir les transitions d'états et décisions temporelles, et (6) établir un langage ubiquitaire. Chaque phase inclut des contrôles de discipline (rôles de relations, verbes précis, pas d'ajouts spéculatifs). Le skill produit des définitions d'objets, un diagramme ER, des diagrammes d'états, un glossaire du langage ubiquitaire et une liste de questions ouvertes. Ce skill est conçu pour les designers et chefs de produit qui travaillent sur l'architecture conceptuelle, en s'appuyant sur des méthodes reconnues (OOUX, Event Storming, DDD). Il est indépendant de toute plateforme spécifique (Figma, Miro, Notion) mais recommande de capturer le résultat dans un support défini par l'utilisateur. Il s'inscrit dans un framework de conception en couches où il fait suite à l'introduction des couches (`/layers-intro`) et précède la conception des flux d'interaction (`/layers-interaction-flow`).

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ulasalyesil/personal-website-v2/tree/HEAD/.agents/skills/layers-conceptual-model

Demander à votre IA préférée

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

Documentation

/couches-modèle-conceptuel

Suppose que /couches-intro a été chargé pour le contexte du framework.

Le modèle conceptuel est la couche porteuse de charge la plus négligée. Il définit les objets que le produit reconnaît, leurs relations, les états qu'ils peuvent prendre et le vocabulaire utilisé pour tout nommer. Il vit dans l'espace de solution : ce n'est pas une capture des modèles mentaux existants des utilisateurs (contradictoires et désordonnés — c'est le travail de la couche du domaine), mais une décision de conception délibérée sur la façon dont le produit modélisera son domaine.

Ce qu'il est — et n'est pas :

  • Une décision de conception qui résout le domaine désordonné en une structure cohérente et tranchée
  • Pas un schéma de base de données — les ingénieurs prennent leurs propres décisions de données, mais l'écart entre ce modèle et ce qu'ils construisent compte. Un écart large et non examiné est à la fois une dette UX (les utilisateurs rencontrent un produit qui contredit le modèle) et une dette technique (le système est plus difficile à faire évoluer).
  • Pas un wireframe ou un flux — pas d'écrans, pas de navigation. Ceux-ci appartiennent aux couches supérieures.
  • Pas neutre — chaque décision de nommage, chaque frontière de relation, chaque objet inclus ou exclu reflète un point de vue.

Décisions que cette couche doit prendre :

  • Quels objets ce produit reconnaîtra-t-il, et quelles sont leurs limites ?
  • Comment ces objets se rapportent-ils les uns aux autres ?
  • Que peuvent faire les utilisateurs avec chaque objet ?
  • Quels états chaque objet peut-il prendre, et quelles transitions sont importantes ?
  • Quel est le vocabulaire du produit — un nom par concept, choisi et assumé ?

Méthodes :

MéthodeQuand
Forage de noms + OOUX (Sophia Prater)Par défaut quand vous avez des recherches ou des notes de domaine à exploiter. Extrait les objets du langage naturaliste.
Semantic IxD / grammaire d'action (Daniel Rosenberg)Quand vous avez de nombreuses actions sur de nombreux objets et souhaitez auditer la cohérence et la précision des verbes.
Event storming — phase commandes/politiques (Brandolini)Le domaine a des processus complexes. Commencez par ce qui se passe, remontez aux objets impliqués.
Tri par cartesLe vocabulaire est flou ou contesté entre utilisateurs ou équipes.
Cartographie des contextes délimités du DDDPlusieurs types d'utilisateurs utilisent les mêmes mots différemment — révèle où le modèle a des coutures naturelles.
Parcourir le produit existantRefonte. L'UI actuelle révèle le modèle implicite — comparez-le à la façon dont les utilisateurs pensent réellement.

Par défaut : forage de noms et définition d'objets.

Signaux de qualité — à quoi ressemble le bon :

  • Chaque objet est indépendamment significatif pour l'utilisateur — pas un élément d'interface, pas une abstraction vague
  • Les rôles de relations sont explicitement nommés quand un objet peut jouer plusieurs rôles
  • Les attributs qui sont en réalité des relations ont été remis en question et convertis
  • Pas d'ajouts spéculatifs — chaque objet, attribut et relation remonte à un besoin utilisateur
  • Les transitions d'états sont définies pour les objets dont le statut change matériellement ce que les utilisateurs peuvent faire
  • Les décisions temporelles sont traitées : sémantique de suppression, temporalité des relations, historique
  • Le langage ubiquitaire est établi : un nom par concept, un concept par nom

Session guidée

Dites-moi pour quel produit ou fonctionnalité vous définissez un modèle, ou dites "guidez-moi" pour commencer le forage de noms et la définition d'objets.

Demandez : "Où dois-je capturer le travail de cette session ?" (voir /couches-intro pour les options)

Vérifiez ce que le designer a de l'espace problème — notes de domaine, recherches, besoins utilisateurs. Si rien : continuez mais signalez qu'un modèle construit sans connaissance du domaine reflète souvent plus les hypothèses que la réalité des utilisateurs.

S'il s'agit d'une refonte : "Décrivez le modèle actuel, même informellement — quel modèle implicite le produit existant a-t-il ?"


Phase 1 — Cadrer le périmètre

  1. Pour quel produit ou fonctionnalité définissons-nous un modèle conceptuel ?
  2. Quel est le travail principal que les utilisateurs essaient de faire avec ?
  3. De quel matériel disposez-vous ?

Phase 2 — Découvrir les objets

À partir de recherches ou de notes de domaine : Extrayez chaque nom — choses, personnes, rôles, documents, lieux, états, concepts, événements. Étendez large ; ne filtrez pas encore. Présentez la liste brute, puis demandez : des noms manquants ? Des mêmes choses avec des noms différents ?

À partir d'un produit existant : Parcourez-le ensemble. "Que regarde un utilisateur ici ? Comment s'appelle cette chose ?"

À partir de premiers principes : "Si un utilisateur pouvait tendre la main et passer quelque chose à un collègue, que passerait-il ?"

Triez en :

  • Objets — des choses qui persistent, ont leurs propres attributs et comptent pour l'utilisateur en elles-mêmes
  • Attributs — des propriétés qui décrivent un objet, pas des objets eux-mêmes
  • Mettre de côté — éléments d'interface, abstractions vagues, actions déguisées en noms

Un véritable objet doit être indépendamment significatif pour l'utilisateur, pas simplement une propriété d'autre chose.

Phase 3 — Définir chaque objet

Travaillez sur chaque objet central :

Objet : [Nom]
Ce que c'est : [une phrase du point de vue de l'utilisateur]
Attributs : [propriétés qu'un utilisateur connaît ou auxquelles il tient]
Relations : [connexions avec d'autres objets — cardinalité et noms de rôles]
Actions (CTA) : [ce qu'un utilisateur peut faire à ou avec cet objet]

Cinq contrôles de discipline :

  1. Rôles de relations : Quand une relation se connecte à un objet qui peut jouer plusieurs rôles (par ex. un Utilisateur qui est à la fois référant et référé), nommez le rôle explicitement : "appartient à un Utilisateur (en tant que référant)" pas "appartient à un Utilisateur."

  2. Attributs qui sont en réalité des relations : Si un attribut est juste le nom ou l'ID d'un autre objet du modèle, c'est une relation — modélisez-la, ne la dupliquez pas comme attribut.

  3. Pas d'ajouts spéculatifs : N'ajoutez pas d'attributs, de relations ou d'actions non fondés sur un besoin utilisateur énoncé. La dérive de périmètre au niveau du modèle conceptuel se propage à toutes les couches supérieures.

  4. Implémentation vs. décisions de conception : Quand la conversation dérive sur comment quelque chose est généré, stocké ou calculé — redirigez : "Comment c'est généré, c'est de l'ingénierie. Ce qui compte ici : un utilisateur peut-il changer cela ? Qu'arrive-t-il aux choses qui y faisaient déjà référence ?"

  5. Précision des verbes : Pour chaque action, demandez si le verbe dit à l'utilisateur ce qu'il obtiendra ou quelle opération réelle il effectue. "Saisir un code PIN" échoue car cela implique que le code existe déjà — "Créer" est précis. Plus crucialement : vérifiez si un verbe générique (Modifier, Supprimer, Mettre à jour) cache des opérations aux conséquences réelles significativement différentes. "Modifier l'adresse" confond la correction d'une faute de frappe avec l'enregistrement d'un déménagement — deux opérations où l'une préserve l'historique et l'autre non, nécessitant un comportement système différent et une intention utilisateur différente. Une interface déductive utilise des verbes génériques et demande aux utilisateurs d'y projeter leur intention ; une interface inductive nomme l'opération réelle ("Enregistrer le changement d'adresse") et préserve son sens. Quand un verbe générique pourrait signifier différentes choses selon ce que l'utilisateur essaie réellement de faire, nommez les opérations séparément.

Phase 4 — Carte des objets

Générez une carte relationnelle des objets : entités comme nœuds, relations comme lignes étiquetées avec indicateurs de cardinalité. Pas d'orientation fixe — suivez ce qui rend les relations les plus lisibles. En Mermaid : erDiagram.

En présentant, expliquez la cardinalité : | = exactement un, o{ = zéro ou plusieurs, |{ = un ou plusieurs. Le pied de corbeau est toujours du côté "plusieurs". Les étiquettes de relation se lisent dans la direction déclarée (première entité → deuxième entité).

Demandez : "Cela reflète-t-il votre façon de penser ces choses ? Relations manquantes, directions inversées, connexions qui ne devraient pas être là ?"

Phase 5 — Transitions d'états et décisions temporelles

Pour chaque objet où le cycle de vie ou le statut compte : "Quels états un [Objet] peut-il prendre ? Qu'est-ce qui le fait passer d'un état à un autre ? Qu'est-ce qui devient impossible dans chaque état ?"

Générez un diagramme d'états : états comme nœuds, transitions comme flèches étiquetées, avec un état de départ clair. Haut-en-bas ou gauche-à-droite selon le nombre d'états. En Mermaid : stateDiagram-v2.

Explorez également les décisions temporelles (de /couches-intro) : états d'action intermédiaires, décalage du modèle de lecture, temporalité des relations, sémantique de suppression, historique. Pour les questions liées à l'implémentation, ne forcez pas une réponse prématurée — articulez l'exigence d'expérience utilisateur et signalez-la comme une question ouverte nommée pour une conversation d'ingénierie.

Phase 6 — Langage ubiquitaire

Le langage ubiquitaire couvre à la fois les noms (objets, attributs) et les verbes (actions). Le même principe s'applique aux deux : un mot par concept, un concept par mot.

Noms : Listez chaque nom d'objet et d'attribut choisi. Pour tout nom avec des synonymes ou des conflits de nommage :

Terme : [nom choisi]
Alternatives rejetées : [autres noms apparus]
Décision : [pourquoi ce terme a été choisi]

Verbes — vocabulaire d'action : Compilez tous les verbes d'action sur tous les objets. Appliquez deux tests :

Vérification des synonymes : Plusieurs verbes sont-ils utilisés pour la même opération ? "Créer" et "Ajouter" pour le même type d'action devraient être consolidés. Minimiser le vocabulaire des verbes réduit ce que les utilisateurs doivent apprendre — le même verbe fonctionnant à l'identique sur tous les objets (comme couper/copier/coller) signifie que les utilisateurs apprennent une fois et transfèrent partout. Chaque synonyme est une nouvelle chose à mémoriser.

Vérification de l'aplatissement : Le risque inverse — un verbe couvrant des opérations vraiment différentes. "Modifier l'adresse" semble simple jusqu'à ce qu'on réalise qu'il confond deux choses : corriger une faute de frappe (l'écrasement est acceptable) et enregistrer un déménagement (qui devrait créer un nouvel enregistrement et préserver l'ancien). Le domaine traite ces choses différemment ; l'interface ne devrait pas le cacher. Pour chaque verbe CRUD générique (Modifier, Supprimer, Mettre à jour, Créer), demandez : cela pourrait-il couvrir des opérations avec des conséquences réelles différentes — implications d'historique différentes, effets aval différents, différentes choses que l'utilisateur essaie réellement d'accomplir ? Si oui, donnez-leur des noms séparés. "Enregistrer le changement d'adresse" et "Corriger l'adresse" ne sont pas verbeux — ils sont précis.

Verbe : [nom d'action choisi]
S'applique à : [quels objets]
Alternatives rejetées : [autres verbes considérés]
Décision : [pourquoi ce verbe ; quelle opération réelle il nomme]

"C'est le langage ubiquitaire de votre produit. Utilisez ces termes de manière cohérente — dans l'UI, dans le texte d'aide, dans les noms d'API, dans les conversations internes. Chaque incohérence entre ce modèle et la surface crée une charge cognitive pour les utilisateurs."


Achèvement

Produisez :

  1. Définitions d'objets — attributs, relations et actions
  2. Carte des objets — erDiagram
  3. Diagrammes de transitions d'états — pour les objets avec des cycles de vie significatifs
  4. Langage ubiquitaire — noms et verbes choisis avec conflits résolus et décisions
  5. Questions ouvertes — décisions différées, objets qui semblaient minces, tout ce qui a été signalé mais non résolu

Concluez par : "Le modèle conceptuel définit ce qui existe dans ce produit. Ensuite : concevez comment les utilisateurs interagissent avec ces objets. Exécutez /couches-flux-interaction."

Si le travail de domaine n'a pas été fait : "Ce modèle a été construit sans recherche de domaine — c'est une hypothèse. Prévoyez de le revoir une fois que vous aurez des preuves."

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ulasalyesil/personal-website-v2

Create beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.

ulasalyesil/personal-website-v2

Conduct design interviews, generate five distinct UI variations in a temporary design lab, collect feedback, and produce implementation plans. Use when the user wants to explore UI design options, redesign existing components, or create new UI with multiple approaches to compare.

ulasalyesil/personal-website-v2

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications (examples include websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished code and UI design that avoids generic AI aesthetics.

ulasalyesil/personal-website-v2

Design and implement microinteractions, motion design, transitions, and user feedback patterns. Use when adding polish to UI interactions, implementing loading states, or creating delightful user experiences.

ulasalyesil/personal-website-v2

This skill is for interface design — dashboards, admin panels, apps, tools, and interactive products. NOT for marketing design (landing pages, marketing sites, campaigns).

ulasalyesil/personal-website-v2

Best practices and example-driven guidance for building SwiftUI views and components. Use when creating or refactoring SwiftUI UI, designing tab architecture with TabView, composing screens, or needing component-specific patterns and examples.

ulasalyesil/personal-website-v2

UI/UX design intelligence. 50 styles, 21 palettes, 50 font pairings, 20 charts, 9 stacks (React, Next.js, Vue, Svelte, SwiftUI, React Native, Flutter, Tailwind, shadcn/ui). Actions: plan, build, create, design, implement, review, fix, improve, optimize, enhance, refactor, check UI/UX code. Projects: website, landing page, dashboard, admin panel, e-commerce, SaaS, portfolio, blog, mobile app, .html, .tsx, .vue, .svelte. Elements: button, modal, navbar, sidebar, card, table, form, chart. Styles: glassmorphism, claymorphism, minimalism, brutalism, neumorphism, bento grid, dark mode, responsive, skeuomorphism, flat design. Topics: color palette, accessibility, animation, layout, typography, font pairing, spacing, hover, shadow, gradient. Integrations: shadcn/ui MCP for component search and examples.

ulasalyesil/personal-website-v2

Conduct WCAG 2.2 accessibility audits with automated testing, manual verification, and remediation guidance. Use when auditing websites for accessibility, fixing WCAG violations, or implementing accessible design patterns.

ulasalyesil/personal-website-v2

Review UI code for Web Interface Guidelines compliance. Use when asked to "review my UI", "check accessibility", "audit design", "review UX", or "check my site against best practices".

ulasalyesil/personal-website-v2

Enforces an opinionated UI baseline to prevent AI-generated interface slop.

ulasalyesil/personal-website-v2

Build modern, composable, and accessible React UI components following the components.build specification. Use when creating, reviewing, or refactoring component libraries, design systems, or any reusable UI components. Triggers on tasks involving component APIs, composition patterns, accessibility, styling systems, or TypeScript props.

ulasalyesil/personal-website-v2

Ship correct, complete metadata.

ulasalyesil/personal-website-v2

Survey any codebase as a senior advisor and produce prioritized, self-contained implementation plans for OTHER models/agents to execute. Strictly read-only on source code — never implements, fixes, or refactors anything itself. Use when asked to audit a codebase, find improvement opportunities (bugs, security, performance, test coverage, tech debt, migrations, DX), suggest features or where to take the project next (roadmap, product direction), or generate handoff plans for another agent to implement.

ulasalyesil/personal-website-v2

Maps domain concepts, terminology conflicts, and bounded contexts — produces a noun harvest for the conceptual model layer

ulasalyesil/personal-website-v2

Maps interaction structure and flow — produces breadboard notation with edge cases, failure paths, and open decisions

ulasalyesil/personal-website-v2

Framework orientation for Layers of Product Design — load this first; provides the context all other skills depend on

ulasalyesil/personal-website-v2

User research planning and synthesis at the observed behaviour layer — produces candidate job stories with confidence ratings

ulasalyesil/personal-website-v2

Diagnostic audit across all seven layers — identifies the bottleneck layer and recommends where to focus

ulasalyesil/personal-website-v2

Connects user opportunities to business outcomes and solution bets — produces a strategy tree and prioritised experiments

ulasalyesil/personal-website-v2

Audits existing surface against lower-layer decisions and produces a surface decision inventory — vocabulary, object consistency, completeness, feedback, hierarchy, accessibility

Skills associés