Communitygithub.com

product-capability

Traduire l'intention d'un PRD, les demandes de roadmap ou les discussions produit en un plan de capacité prêt pour l'implémentation, qui expose les contraintes, invariants, interfaces et décisions non résolues avant le début du travail multi-service. À utiliser lorsque l'utilisateur a besoin d'une voie ECC-native allant du PRD au SRS plutôt que de prose de planification vague.

Qu'est-ce que product-capability ?

Ce skill transforme une intention produit en contraintes d'ingénierie explicites. Il est conçu pour être utilisé lorsqu'il existe un PRD, un élément de roadmap, une discussion ou une note de fondateur, mais que les contraintes d'implémentation restent implicites. Il est particulièrement utile lorsque la fonctionnalité traverse plusieurs services, dépôts ou équipes, nécessitant un contrat de capacité avant le codage. Le skill produit un artefact durable et réutilisable qui distingue les promesses visibles par l'utilisateur des détails d'implémentation, tout en marquant explicitement les questions non résolues. Il est compatible avec Claude Code, Codex, Cursor, OpenCode et les surfaces de planification ECC 2.0.

Compatible avec✓Claude Code✓Codex CLI✓Cursor✓OpenCode
npx skills add https://github.com/affaan-m/everything-claude-code/tree/main/skills/product-capability

Demander à votre IA préférée

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

Documentation

Capacité Produit

Ce skill transforme l'intention produit en contraintes d'ingénierie explicites.

Utilisez-le lorsque le fossé n'est pas "que devrions-nous construire ?" mais "que doit être exactement vrai avant que l'implémentation commence ?"

Quand l'utiliser

  • Un PRD, un élément de roadmap, une discussion ou une note de fondateur existe, mais les contraintes d'implémentation sont encore implicites
  • Une fonctionnalité traverse plusieurs services, dépôts ou équipes et nécessite un contrat de capacité avant le codage
  • L'intention produit est claire, mais les implications architecturales, de données, de cycle de vie ou de politique sont encore floues
  • Les ingénieurs seniors répètent les mêmes hypothèses cachées lors des revues
  • Vous avez besoin d'un artefact réutilisable qui peut survivre à travers les environnements et les sessions

Artefact Canonique

Si le dépôt a un fichier de contexte produit durable comme PRODUCT.md, docs/product/ ou un répertoire de spécification de programme, mettez-le à jour là.

Si aucun manifeste de capacité n'existe encore, créez-en un en utilisant le modèle à :

  • docs/examples/product-capability-template.md

Le but n'est pas de créer une autre pile de planification. Le but est de rendre les contraintes de capacité cachées durables et réutilisables.

Règles Non Négociables

  • N'inventez pas de vérité produit. Marquez explicitement les questions non résolues.
  • Séparez les promesses visibles par l'utilisateur des détails d'implémentation.
  • Signalez ce qui est une politique fixe, ce qui est une préférence architecturale et ce qui est encore ouvert.
  • Si la demande entre en conflit avec les contraintes existantes du dépôt, dites-le clairement au lieu de lisser le problème.
  • Préférez un artefact de capacité réutilisable plutôt que des notes ad hoc dispersées.

Entrées

Lisez uniquement ce qui est nécessaire :

  1. Intention produit
    • ticket, discussion, PRD, note de roadmap, message de fondateur
  2. Architecture actuelle
    • documentation du dépôt, contrats, schémas, routes, workflows existants
  3. Contexte de capacité existant
    • PRODUCT.md, documents de conception, RFCs, notes de migration, documents de modèle opérationnel
  4. Contraintes de livraison
    • authentification, facturation, conformité, déploiement, rétrocompatibilité, performance, politique de revue

Workflow Principal

1. Reformuler la capacité

Compressez la demande en une déclaration précise :

  • qui est l'utilisateur ou l'opérateur
  • quelle nouvelle capacité existe après cette livraison
  • quel résultat change grâce à elle

Si cette déclaration est faible, l'implémentation dérivera.

2. Résoudre les contraintes de capacité

Extrayez les contraintes qui doivent être vraies avant l'implémentation :

  • règles métier
  • limites de périmètre
  • invariants
  • limites de confiance
  • propriété des données
  • transitions de cycle de vie
  • exigences de déploiement / migration
  • attentes en cas d'échec et de reprise

Ce sont les choses qui vivent souvent uniquement dans la mémoire des ingénieurs seniors.

3. Définir le contrat orienté implémentation

Produisez un plan de capacité de type SRS avec :

  • résumé de la capacité
  • non-objectifs explicites
  • acteurs et surfaces
  • états et transitions requis
  • interfaces / entrées / sorties
  • implications sur le modèle de données
  • contraintes de sécurité / facturation / politique
  • exigences d'observabilité et d'opérateur
  • questions ouvertes bloquant l'implémentation

4. Traduire en exécution

Terminez avec le transfert exact :

  • prêt pour l'implémentation directe
  • nécessite d'abord une revue architecturale
  • nécessite d'abord une clarification produit

Si utile, indiquez la prochaine voie ECC-native :

  • project-flow-ops
  • workspace-surface-audit
  • api-connector-builder
  • dashboard-builder
  • tdd-workflow
  • verification-loop

Format de Sortie

Retournez le résultat dans cet ordre :

CAPACITÉ
- reformulation d'un paragraphe

CONTRAINTES
- règles fixes, invariants et limites

CONTRAT D'IMPLÉMENTATION
- acteurs
- surfaces
- états et transitions
- implications d'interface / données

NON-OBJECTIFS
- ce que cette voie ne possède pas explicitement

QUESTIONS OUVERTES
- blocages ou décisions produit encore nécessaires

TRANSFERT
- ce qui devrait se passer ensuite et quelle voie ECC devrait le prendre

Résultats Attendus

  • L'intention produit est maintenant suffisamment concrète pour être implémentée sans redécouvrir des contraintes cachées en cours de PR.
  • La revue d'ingénierie dispose d'un artefact durable au lieu de se fier à la mémoire ou au contexte Slack.
  • Le plan résultant est réutilisable sur les surfaces de planification Claude Code, Codex, Cursor, OpenCode et ECC 2.0.

Individual skills in this repo

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

accessibility

Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA. Use when building or auditing UI that must meet WCAG 2.2 Level AA, or when reviewing a change for keyboard, contrast, or screen-reader support.

affaan-m/claude-api

Anthropic Claude API patterns for Python and TypeScript. Covers Messages API, streaming, tool use, vision, extended thinking, batches, prompt caching, and Claude Agent SDK. Use when building applications with the Claude API or Anthropic SDKs.

affaan-m/everything-claude-code

End-to-end marketing campaign planning and execution. Covers audience research, positioning, campaign angle definition, landing page copy, email sequences, social posts, ad copy, short-form video scripts, and content calendars. Use as the orchestration layer for multi-channel product launches. Use when planning or executing a multi-channel product launch, or producing landing page, email, social, or ad copy.

affaan-m/everything-claude-code

Development conventions and patterns for everything-claude-code. JavaScript project with conventional commits.

affaan-m/everything-claude-code-conventions

Development conventions and patterns for everything-claude-code. JavaScript project with conventional commits.

affaan-m/frontend-design

Create distinctive, production-grade frontend interfaces with high design quality. Use when the user asks to build web components, pages, or applications and the visual direction matters as much as the code quality.

affaan-m/gget

gget CLI and Python workflow for quick genomic database queries, sequence lookup, BLAST-style searches, enrichment checks, and reproducible bioinformatics evidence logs.

affaan-m/literature-review

Systematic literature-review workflow for academic, biomedical, technical, and scientific topics, including search planning, source screening, synthesis, citation checks, and evidence logging.

affaan-m/motion-ui

Production-ready UI motion system for React/Next.js. Use when implementing animations, transitions, or motion patterns.

affaan-m/project-guidelines-example

Example project-specific skill template based on a real production application.

affaan-m/pubmed-database

Direct PubMed and NCBI E-utilities search workflows for biomedical literature, MeSH queries, PMID lookup, citation retrieval, and API-backed literature monitoring.

affaan-m/scholar-evaluation

Structured scholarly-work evaluation for papers, proposals, literature reviews, methods sections, evidence quality, citation support, and research-writing feedback.

affaan-m/uspto-database

USPTO patent and trademark data workflow for official record lookup, PatentSearch queries, TSDR checks, assignment data, and reproducible IP research logs.

agent-architecture-audit

Full-stack diagnostic for agent and LLM applications. Audits the 12-layer agent stack for wrapper regression, memory pollution, tool discipline failures, hidden repair loops, and rendering corruption. Produces severity-ranked findings with code-first fixes. Essential for developers building agent applications, autonomous loops, or any LLM-powered feature. Use when an agent or LLM feature misbehaves and the failing layer is unknown, or before shipping an agent stack.

agent-eval

Head-to-head comparison of coding agents (Claude Code, Aider, Codex, etc.) on custom tasks with pass rate, cost, time, and consistency metrics. Use when choosing between coding agents, or when a change to an agent setup needs measured pass rate, cost, and time rather than an impression.

agent-harness-construction

Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates. Use when defining or revising an agent

agentic-engineering

Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. Use when planning or executing engineering work that agents will carry out end to end.

agentic-os

Build persistent multi-agent operating systems on Claude Code. Covers kernel architecture, specialist agents, slash commands, file-based memory, scheduled automation, and state management without external databases. Use when building a persistent multi-agent system on Claude Code with its own memory, commands, and scheduling.

agent-introspection-debugging

Structured self-debugging workflow for AI agent failures using capture, diagnosis, contained recovery, and introspection reports. Use when an agent run fails and you need a reproducible diagnosis instead of a retry.

agent-payment-x402

Add x402 payment execution to AI agents with per-task budgets, spending controls, and non-custodial wallets. Supports Base through agentwallet-sdk and X Layer through OKX Payments / OKX Agent Payments Protocol. Use when an agent must pay for something itself and needs per-task budgets, spending controls, and a non-custodial wallet.

Skills associés