product-capability
affaan-m/ECC
Traduire les objectifs produit, les spécifications fonctionnelles (PRD) ou les discussions relatives à la feuille de route en plans de fonctionnalités explicites et prêts à être mis en œuvre, comprenant les contraintes, les invariants, les interfaces et les questions en suspens, avant le début des travaux impliquant plusieurs services.
...Développer toutCapacités du produit
Cette compétence permet de traduire l'intention du produit en contraintes techniques explicites.
Utilisez-la lorsque la question n’est pas « que devons-nous construire ? », mais « quelles conditions doivent être remplies avant de commencer la mise en œuvre ? ».
Quand l'utiliser
- Un PRD, un élément de la feuille de route, une discussion ou une note du fondateur existe, mais les contraintes de mise en œuvre restent implicites
- Une fonctionnalité concerne plusieurs services, dépôts ou équipes et nécessite un contrat de capacités avant le codage
- L’intention produit est claire, mais les implications en matière d’architecture, de données, de cycle de vie ou de politique restent floues
- Les ingénieurs seniors ne cessent de réitérer les mêmes hypothèses sous-jacentes lors des revues
- Vous avez besoin d’un artefact réutilisable capable de perdurer d’un test à l’autre et d’une session à l’autre
Artefact canonique
Si le dépôt dispose d’un fichier de contexte produit durable, tel que PRODUCT.md, docs/product/ ou un répertoire program-spec, mettez-le à jour à cet endroit.
Si aucun manifeste de capacités n’existe encore, créez-en un à l’aide du modèle disponible à l’adresse :
docs/examples/product-capability-template.md
L’objectif n’est pas de créer une nouvelle pile de planification. L’objectif est de rendre les contraintes de capacités cachées durables et réutilisables.
Règles non négociables
- N’inventez pas la vérité du produit. Signalez explicitement les questions en suspens.
- Séparez les promesses visibles par l’utilisateur des détails de mise en œuvre.
- Précisez clairement ce qui relève d’une politique fixe, ce qui relève d’une préférence architecturale et ce qui reste encore en suspens.
- Si la demande entre en conflit avec les contraintes existantes du dépôt, signalez-le clairement au lieu de passer cela sous silence.
- Privilégiez un artefact de fonctionnalité réutilisable plutôt que des notes ad hoc éparpillées.
Données d'entrée
Ne lisez que ce qui est nécessaire :
- Objectif du produit
- tique, discussion, PRD, note de feuille de route, message du fondateur
- Architecture actuelle
- documentation pertinente du dépôt, contrats, schémas, routes, workflows existants
- Contexte des capacités existantes
PRODUCT.md, documents de conception, RFC, notes de migration, documents relatifs au modèle opérationnel
- Contraintes de mise en œuvre
- authentification, facturation, conformité, déploiement, rétrocompatibilité, performances, politique de révision
Workflow principal
1. Reformuler la fonctionnalité
Résumer la demande en une seule phrase précise :
- qui est l’utilisateur ou l’opérateur
- quelle nouvelle fonctionnalité sera disponible une fois le produit lancé
- quels résultats en découlent
Si cette formulation n'est pas suffisamment claire, la mise en œuvre risque de s'écarter de l'objectif initial.
2. Résoudre les contraintes liées aux fonctionnalités
Identifier les contraintes qui doivent être respectées avant la mise en œuvre :
- règles métier
- limites de portée
- invariants
- limites de confiance
- propriété des données
- transitions du cycle de vie
- exigences de déploiement / de migration
- scénarios de défaillance et de reprise
Ce sont là des éléments qui ne figurent souvent que dans la mémoire des ingénieurs seniors.
3. Définir le contrat relatif à la mise en œuvre
Élaborer un plan des capacités de type SRS comprenant :
- un résumé des capacités
- les non-objectifs explicites
- les acteurs et les interfaces
- les états et transitions requis
- des interfaces / entrées / sorties
- Implications sur le modèle de données
- contraintes de sécurité / de facturation / de politique
- exigences en matière d’observabilité et d’exploitation
- questions en suspens bloquant la mise en œuvre
4. Passer à la mise en œuvre
Terminer par le transfert précis :
- prêt pour une mise en œuvre immédiate
- nécessite d’abord une révision de l’architecture
- nécessite au préalable une clarification du produit
Si utile, indiquez la prochaine voie native ECC :
project-flow-opsworkspace-surface-auditgénérateur-de-connecteurs-APIdashboard-buildertdd-workflowboucle-de-vérification
Format de sortie
Renvoyer le résultat dans cet ordre :
CAPACITÉ
- reformulation en un paragraphe
CONTRAINTES
- règles fixes, invariants et limites
CONTRAT DE MISE EN ŒUVRE
- acteurs
- surfaces
- états et transitions
- implications en matière d’interface et de données
NON-OBJECTIFS
- ce dont cette piste ne s'occupe explicitement pas
QUESTIONS EN SUSPENS
- obstacles ou décisions relatives au produit encore à prendre
TRANSFERT
- ce qui doit se passer ensuite et quelle piste ECC doit prendre le relais
Résultats positifs
- L’intention du produit est désormais suffisamment concrète pour être mise en œuvre sans redécouvrir de contraintes cachées en cours de PR.
- La revue d’ingénierie dispose d’un artefact durable au lieu de s’appuyer sur la mémoire ou le contexte Slack.
- Le plan qui en résulte est réutilisable sur les surfaces de planification de Claude Code, Codex, Cursor, OpenCode et ECC 2.0.
---
name: product-capability
description: Translate product intent, PRDs, or roadmap discussions into explicit, implementation-ready capability plans with constraints, invariants, interfaces, and open questions before multi-service work begins.
---
# Product Capability
This skill turns product intent into explicit engineering constraints.
Use it when the gap is not "what should we build?" but "what exactly must be true before implementation starts?"
## When to Use
- A PRD, roadmap item, discussion, or founder note exists, but the implementation constraints are still implicit
- A feature crosses multiple services, repos, or teams and needs a capability contract before coding
- Product intent is clear, but architecture, data, lifecycle, or policy implications are still fuzzy
- Senior engineers keep restating the same hidden assumptions during review
- You need a reusable artifact that can survive across harnesses and sessions
## Canonical Artifact
If the repo has a durable product-context file such as `PRODUCT.md`, `docs/product/`, or a program-spec directory, update it there.
If no capability manifest exists yet, create one using the template at:
- `docs/examples/product-capability-template.md`
The goal is not to create another planning stack. The goal is to make hidden capability constraints durable and reusable.
## Non-Negotiable Rules
- Do not invent product truth. Mark unresolved questions explicitly.
- Separate user-visible promises from implementation details.
- Call out what is fixed policy, what is architecture preference, and what is still open.
- If the request conflicts with existing repo constraints, say so clearly instead of smoothing it over.
- Prefer one reusable capability artifact over scattered ad hoc notes.
## Inputs
Read only what is needed:
1. Product intent
- issue, discussion, PRD, roadmap note, founder message
2. Current architecture
- relevant repo docs, contracts, schemas, routes, existing workflows
3. Existing capability context
- `PRODUCT.md`, design docs, RFCs, migration notes, operating-model docs
4. Delivery constraints
- auth, billing, compliance, rollout, backwards compatibility, performance, review policy
## Core Workflow
### 1. Restate the capability
Compress the ask into one precise statement:
- who the user or operator is
- what new capability exists after this ships
- what outcome changes because of it
If this statement is weak, the implementation will drift.
### 2. Resolve capability constraints
Extract the constraints that must hold before implementation:
- business rules
- scope boundaries
- invariants
- trust boundaries
- data ownership
- lifecycle transitions
- rollout / migration requirements
- failure and recovery expectations
These are the things that often live only in senior-engineer memory.
### 3. Define the implementation-facing contract
Produce an SRS-style capability plan with:
- capability summary
- explicit non-goals
- actors and surfaces
- required states and transitions
- interfaces / inputs / outputs
- data model implications
- security / billing / policy constraints
- observability and operator requirements
- open questions blocking implementation
### 4. Translate into execution
End with the exact handoff:
- ready for direct implementation
- needs architecture review first
- needs product clarification first
If useful, point to the next ECC-native lane:
- `project-flow-ops`
- `workspace-surface-audit`
- `api-connector-builder`
- `dashboard-builder`
- `tdd-workflow`
- `verification-loop`
## Output Format
Return the result in this order:
```text
CAPABILITY
- one-paragraph restatement
CONSTRAINTS
- fixed rules, invariants, and boundaries
IMPLEMENTATION CONTRACT
- actors
- surfaces
- states and transitions
- interface/data implications
NON-GOALS
- what this lane explicitly does not own
OPEN QUESTIONS
- blockers or product decisions still required
HANDOFF
- what should happen next and which ECC lane should take it
```
## Good Outcomes
- Product intent is now concrete enough to implement without rediscovering hidden constraints mid-PR.
- Engineering review has a durable artifact instead of relying on memory or Slack context.
- The resulting plan is reusable across Claude Code, Codex, Cursor, OpenCode, and ECC 2.0 planning surfaces.
Tous les fichiers
1 fichiersInstaller product-capability
Téléchargez et décompressez les fichiers de compétences dans votre répertoire .claude/skills/.
Télécharger le ZIPClonez le dépôt et copiez les fichiers de compétence dans votre projet.
git clone https://github.com/affaan-m/ECC/tree/main/skills/product-capability # Copy SKILL.md to your .claude/skills/ directory
Copier





Maison
