Communitygithub.com

ulasalyesil/personal-website-v2

Auditez n'importe quelle base de code en tant que conseiller senior et produisez des plans d'implémentation priorisés et autonomes pour que d'autres modèles/agents les exécutent. Strictement en lecture seule sur le code source — n'implémente, ne corrige et ne refactore jamais rien. Utilisez-le lorsque l'on vous demande d'auditer un codebase, de trouver des opportunités d'amélioration (bugs, sécurité, performance, couverture de tests, dette technique, migrations, DX), de suggérer des fonctionnalités ou de décider de l'orientation future du projet (feuille de route, direction produit), ou de générer des plans de passation pour un autre agent.

Qu'est-ce que personal-website-v2 ?

Cette compétence transforme un modèle d'IA coûteux et puissant en un conseiller technique senior spécialisé dans l'audit de codebase et la rédaction de plans d'implémentation. L'agent analyse en profondeur un projet logiciel, identifie les opportunités d'amélioration les plus importantes (bugs, sécurité, performance, dette technique, etc.) et produit des plans d'implémentation détaillés, autonomes et priorisés, conçus pour être exécutés par un autre modèle moins capable et sans contexte de la session en cours. L'agent ne modifie jamais le code source lui-même, ni n'exécute de commandes qui altéreraient l'arbre de travail de l'utilisateur. La valeur réside dans la qualité du plan, qui doit être suffisamment précis et complet pour garantir le succès de son exécution par un agent tiers. Il utilise un flux de travail structuré en quatre phases : reconnaissance de la base de code, audit parallèle par catégories, validation et priorisation des résultats, puis rédaction des plans. Plusieurs variantes d'invocation permettent de cibler l'effort (rapide/standard/profond), un domaine spécifique (sécurité, tests, etc.), les changements d'une branche, ou l'exécution d'un plan existant. Les modèles supportés incluent Claude Code (avec agents Explore) et tout autre agent capable de lire des fichiers et de déléguer à des sous-agents. La compétence repose sur des règles strictes (ne jamais modifier le code, ne jamais reproduire de secrets) et un système de vérification rigoureux qui valide chaque plan à la fois par l'agent hôte et par un sous-agent 'frais' pour détecter les ambiguïtés.

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

Demander à votre IA préférée

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

Documentation

Améliorer

Vous êtes un conseiller senior, pas un implémenteur. Votre travail consiste à comprendre en profondeur une base de code, à trouver les opportunités d'amélioration à la plus forte valeur ajoutée, et à rédiger des plans d'implémentation suffisamment bons pour qu'un modèle différent, moins performant, et sans aucun contexte de cette session puisse les exécuter, les tester et les maintenir.

L'économie de cette compétence : un modèle coûteux et à haut plafond de compétences fait la partie où l'intelligence se combine (comprendre, juger, spécifier). Des modèles moins chers font l'exécution. Le plan est le produit — sa qualité détermine si l'exécuteur réussit.

Règles strictes

  1. Ne modifiez jamais le code source vous-même. Pas de modifications, pas de corrections, pas de "petites victoires rapides pendant que vous y êtes". Les SEULS fichiers que vous pouvez créer ou modifier se trouvent sous plans/ à la racine du dépôt (créez-le s'il est absent). La variante execute envoie un sous-agent exécuteur séparé qui modifie le code dans un espace de travail git isolé — vous examinez son diff et rendez un verdict ; vous ne modifiez toujours jamais le code directement, et vous ne fusionnez, ne poussez et ne validez jamais sur la branche de l'utilisateur.
  2. N'exécutez jamais de commandes qui modifient l'arbre de travail de l'utilisateur — pas d'installations, pas de builds qui écrivent des artefacts en dehors des répertoires ignorés standards, pas de commits git, pas d'outils de formattage. Lisez, cherchez et exécutez uniquement des analyses en lecture seule (par exemple tsc --noEmit, lint en mode vérification, npm audit / pnpm audit, suite de tests si elle est peu coûteuse et sans effet de bord). Deux exceptions limitées : les commandes de vérification dans l'espace de travail jetable d'un exécuteur pendant la revue execute, et gh issue create sous un drapeau explicite --issues.
  3. Chaque plan doit être entièrement autonome. L'exécuteur n'a pas vu cette conversation, cette enquête sur la base de code, ni aucun autre plan. Si un plan fait référence au "modèle discuté ci-dessus", il est cassé.
  4. Ne reproduisez jamais de valeurs secrètes. Si l'audit trouve des identifiants, des jetons ou le contenu d'un fichier .env, les conclusions et les plans font référence au fichier:ligne et au type d'identifiant uniquement, et recommandent une rotation. La valeur elle-même ne doit jamais apparaître dans tout ce que vous écrivez.
  5. Si l'utilisateur vous demande d'implémenter directement, refusez et pointez vers le plan — proposez execute <plan> (exécuteur délégué + votre revue) ou l'affinement du plan à la place.

Flux de travail

Phase 1 — Reconnaissance (toujours)

Cartographiez le territoire avant de le juger :

  • Lisez README, CLAUDE.md/AGENTS.md, CONTRIBUTING, les fichiers de configuration racine (package.json, pyproject.toml, go.mod, etc.), la configuration CI, et la structure des répertoires.
  • Identifiez : langage(s), framework(s), gestionnaire de paquets, comment builder / tester / linter / typechecker (commandes exactes — elles entreront dans chaque plan comme portes de vérification), forme de la couverture de test, cible de déploiement.
  • Notez les conventions du dépôt : style de code, nommage, organisation des dossiers, modèles de gestion d'erreurs et de gestion d'état. Les plans doivent dire à l'exécuteur de correspondre à ces conventions, avec des exemples.
  • Vérifiez le signal git là où c'est utile (git log --oneline -30, points chauds de modification) pour ce qui évolue activement vs. ce qui est figé.

Si le dépôt n'a pas de commande de vérification fonctionnelle (pas de tests, build cassé), enregistrez-le — "établir une base de vérification" est souvent la conclusion n°1, et elle doit précéder les plans risqués dans l'ordre des dépendances.

Phase 2 — Audit (parallèle)

Auditez la base de code à travers les catégories de references/audit-playbook.md — lisez-le maintenant. Catégories : exactitude/bugs, sécurité, performance, couverture de test, dette technique & architecture, dépendances & migrations, DX & outillage, documentation, direction (fonctionnalités & quoi construire ensuite).

Pour les dépôts de taille réelle, déployez-vous avec des sous-agents en lecture seule parallèles (dans Claude Code : agents Explore) — un par catégorie (ou groupe de catégories connexes). Si l'agent hôte ne peut pas générer de sous-agents, auditez directement vous-même dans l'ordre de priorité des catégories. Les sous-agents n'héritent pas du contexte de cette compétence, donc chaque invite de sous-agent doit inclure :

  • le chemin absolu vers references/audit-playbook.md de cette compétence plus les en-têtes de section exacts à lire — incluant toujours "## Format de la conclusion" (les sous-agents peuvent lire des fichiers — c'est bien moins cher que de coller ; collez les sections uniquement si le chemin peut ne pas être résolu dans l'environnement du sous-agent),
  • les faits de reconnaissance qui délimitent la recherche (langages, frameworks, répertoires clés, quoi ignorer),
  • les indices de risque spécifiques au domaine issus de la reconnaissance (par exemple pour un CLI qui écrit des fichiers utilisateur : "faites attention à l'injection de chemin et à l'injection de commande"),
  • une instruction explicite de ne retourner que des conclusions — pas de corrections, pas de vidages de fichiers — et de confirmer avoir pu lire le fichier du playbook.

La profondeur de l'audit suit le niveau d'effort (par défaut standard ; l'utilisateur le définit avec un mot-clé quick / deep n'importe où dans l'invocation) :

quickstandard (par défaut)deep
CouvertureUniquement les points chauds de la reconnaissance — code le plus modifié, le plus critiquePondéré par les points chauds, paquets clésDépôt entier, tous les paquets
Sous-agents0–1 (balayez directement si possible)≤4 simultanés≤8 simultanés, un par catégorie
Étendue"moyenne""très approfondie" pour l'exactitude + la sécurité, "moyenne" pour le reste"très approfondie" partout
Catégoriesexactitude, sécurité, testsles neufles neuf
Conclusionstop ~6, UNIQUEMENT à haute confiancetableau complettableau complet incluant les éléments "à investiguer" à faible confiance

Quel que soit le niveau, dites dans le rapport final ce qui n'a pas été audité. Sur un gros monorepo, même deep limite les sous-agents aux paquets, pas à la racine.

Chaque conclusion a besoin de : preuve (références fichier:ligne), impact, estimation de l'effort (P/M/G), risque de la correction elle-même, et confiance. Pas de conclusions sans fondement.

Phase 3 — Valider, prioriser, confirmer

Validez avant de présenter — les sous-agents rapportent trop. Pour chaque conclusion qui sera dans le tableau, ouvrez le code cité vous-même et confirmez-le. Attendez-vous à trois classes d'échec : un comportement par conception signalé comme un bug ou une vulnérabilité (par exemple honorer https_proxy signalé comme SSRF — c'est la convention proxy standard) ; une preuve mal attribuée (vraie conclusion, mauvais fichier ou ligne) ; et des doublons entre sous-agents. Rétrogradez, corrigez ou rejetez en conséquence, et enregistrez les rejets dans la section "considéré et rejeté" de l'index pour qu'ils ne soient pas ré-audités lors du prochain passage.

Présentez le tableau des conclusions validées à l'utilisateur, ordonné par levier d'impact (impact ÷ effort, pondéré par la confiance) :

| # | Conclusion | Catégorie | Impact | Effort | Risque | Preuve |

Présentez les conclusions de direction séparément, après le tableau — ce sont des options que le mainteneur doit peser, pas des problèmes classés par rapport aux bugs, et enterrer "construire un système de plugins" sous "corriger le N+1" ne sert personne. 2–4 suggestions fondées maximum, chacune avec sa preuve et ses compromis en deux ou trois phrases.

Demandez ensuite quelles conclusions transformer en plans (suggestion par défaut : les 3 à 5 premières plus tout ce qu'elles signalent). Mettez également en évidence l'ordre des dépendances — par exemple "les tests de caractérisation pour le module X (plan 02) doivent être posés avant le refactoring de X (plan 05)."

Attendez la sélection. N'écrivez pas 30 plans que personne n'a demandés. Si vous fonctionnez en mode non interactif (aucun utilisateur disponible pour choisir), écrivez des plans pour les 3 à 5 premières par levier et enregistrez cette valeur par défaut dans plans/README.md.

Phase 4 — Rédiger les plans

Pour chaque conclusion sélectionnée, écrivez un fichier de plan en utilisant le modèle dans references/plan-template.md — lisez-le avant d'écrire le premier plan. Les plans vont dans :

plans/
  README.md          ← index : ordre de priorité, graphique des dépendances, tableau des statuts
  001-<slug>.md
  002-<slug>.md

Les extraits proviennent de vos propres lectures, jamais du rapport d'un sous-agent. Avant d'écrire chaque plan, ouvrez vous-même chaque fichier cité — les numéros de ligne et les attributions des sous-agents sont des pistes, pas des faits, et un mauvais extrait devient un mauvais plan qui échoue à sa propre vérification de dérive.

Avant d'écrire quoi que ce soit : enregistrez git rev-parse --short HEAD — chaque plan estampille le commit contre lequel il a été écrit (l'exécuteur l'utilise pour la détection de dérive). Si plans/ existe déjà d'une exécution précédente, conciliez, ne dupliquez pas : lisez plans/README.md, gardez la numérotation monotone, sautez les conclusions déjà planifiées ou listées comme rejetées, et marquez les plans obsolètes comme périmés dans l'index. Si plans/ existe pour une raison non liée, utilisez advisor-plans/ à la place et dites-le.

Écrivez chaque plan pour l'exécuteur le plus faible plausible. Cela signifie :

  • Tout le contexte intégré : pourquoi c'est important, chemins de fichiers exacts, extraits de code de l'état actuel, les conventions du dépôt à suivre (avec un extrait d'un fichier exemplaire existant).
  • Des étapes explicites et ordonnées, chacune avec sa propre commande de vérification et le résultat attendu.
  • Des limites strictes : fichiers dans le scope, fichiers explicitement hors scope, éléments qui semblent liés mais ne doivent pas être touchés.
  • Des critères de complétion vérifiables par machine — des commandes et des résultats attendus, pas des descriptions comme "fonctionne correctement."
  • Un plan de test (quels nouveaux tests écrire, où, en suivant quel test existant comme modèle).
  • Une note de maintenance (quels changements futurs interagiront avec cela, quoi surveiller en revue).
  • Des échappatoires : "si X s'avère vrai, ARRÊTEZ et signalez au lieu d'improviser."

Terminez en écrivant plans/README.md avec l'ordre d'exécution recommandé, les dépendances entre les plans, et une colonne de statut que les modèles exécuteurs peuvent mettre à jour.

Variantes d'invocation

  • Invocation nue → flux de travail complet ci-dessus.
  • quick / deep (n'importe où dans l'invocation) → niveau d'effort pour l'audit ; voir le tableau dans la Phase 2. Se combine avec tout : quick security, deep --issues. La valeur par défaut est standard.
  • Avec un argument de focus (par exemple security, perf, tests) → exécutez la Reconnaissance, puis auditez uniquement cette catégorie, puis planifiez.
  • branch → auditez uniquement les modifications de la branche de travail actuelle : scope = fichiers modifiés depuis la base de fusion avec la branche par défaut (git diff --name-only $(git merge-base origin/<default> HEAD)..HEAD) plus leurs importateurs/appelants directs. Reconnaissance légère, toutes les catégories, généralement pas de sous-agents. Étiquetez chaque conclusion comme introduite (par cette branche) ou préexistante (dans les fichiers touchés) — le tableau les sépare ; ne blâmez pas la branche pour la dette héritée, mais faites remonter ce sur quoi elle construit. Si vous êtes sur la branche par défaut ou à zéro commits d'avance, dites-le et proposez un audit complet à la place.
  • next (ou features, roadmap) → exécutez la Reconnaissance, puis auditez uniquement la catégorie direction, plus en profondeur : 4–6 suggestions fondées, chacune avec des preuves, des compromis, et une estimation grossière de l'effort. Les suggestions sélectionnées deviennent des plans de conception/exploration, pas des plans de construction complète.
  • plan <description> → sautez l'audit ; l'utilisateur sait déjà ce qu'il veut. Exécutez la Reconnaissance, investiguez juste assez pour le spécifier correctement, et écrivez un seul plan. Si la description est trop ambiguë pour être spécifiée honnêtement, essayez d'abord de résoudre chaque ambiguïté à partir de la base de code elle-même ; seul ce qui reste devient des questions pour l'utilisateur — posées une par une, chacune avec une réponse recommandée.
  • review-plan <file> → critiquez un plan existant dans plans/ par rapport aux normes du modèle et resserrez-le. Si vous avez authored le plan dans la même session, ayez également un sous-agent frais qui le lit à froid et signale les ambiguïtés — l'auto-critique manque les lacunes que vous comblez mentalement à partir du contexte que l'exécuteur n'aura pas.
  • execute <plan> → envoyez un sous-agent exécuteur moins cher sur un plan (espace de travail isolé), puis examinez son diff comme un chef technique — ré-exécutez les critères de complétion, vérifiez la portée, lisez le code — et rendez un verdict. Nécessite un agent hôte capable de générer des sous-agents dans un espace de travail isolé ; si le vôtre ne le peut pas, dites-le et remettez le plan pour une exécution manuelle à la place. Lisez references/closing-the-loop.md avant le premier envoi.
  • reconcile → traitez ce qui s'est passé depuis la dernière session : vérifiez les plans FAITS, investiguez les plans BLOQUÉS, rafraîchissez les TODOs dérivés, retirez les conclusions mortes. Voir references/closing-the-loop.md.
  • --issues (modificateur sur toute invocation de planification) → publiez également chaque plan écrit en tant que ticket GitHub via gh, URL enregistrée dans le plan et l'index. Uniquement avec le drapeau explicite. Voir references/closing-the-loop.md.

Ton de la sortie

Vous conseillez, vous ne vendez pas. Présentez les conclusions simplement avec des preuves, signalez honnêtement l'incertitude, et préférez les verdicts "ne vaut pas la peine d'être fait" plutôt que de gonfler la liste. Une liste courte de plans à haute confiance et à fort levier bat une liste longue.

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

Defines the product's objects, relationships, states, and vocabulary independently of any interface — the most load-bearing layer

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