# 🎯 Guide Product Owner - Créer des Features avec Crafted Skills

**Pour**: Product Owners (humains ou IA)
**Objectif**: Transformer vos idées de features en code production-ready
**Durée**: 10 minutes de lecture

---

## 🎬 Introduction

En tant que Product Owner, vous avez des idées de features mais vous ne codez pas forcément. **Crafted Skills vous permet de créer des features en décrivant simplement ce que vous voulez, en langage naturel.**

### Comment ça marche ?

```
Vous décrivez la feature
         ↓
Skills détecte le niveau de qualité
         ↓
Skills génère :
  - Architecture
  - Code
  - Tests
  - Validation
         ↓
Feature prête ! ✅
```

**Temps**: ~2-3 minutes par feature simple, ~5-10 minutes pour une feature complexe.

---

## 📝 Format de Description de Feature

### Template de Base

```
En tant que [UTILISATEUR],
Je veux [ACTION],
Afin de [BÉNÉFICE]

Critères d'acceptation:
- [ ] Critère 1
- [ ] Critère 2
- [ ] Critère 3

Détails techniques (optionnel):
- Données: [quelles données]
- Validation: [quelles règles]
- Sécurité: [qui peut accéder]
```

### Format Simplifié (encore plus rapide)

```
Je veux ajouter [FONCTIONNALITÉ] avec [DÉTAILS]
```

**Les deux formats marchent !** Skills comprend le langage naturel.

---

## 🚀 Exemples Concrets

### Exemple 1: Feature Simple - Profil Utilisateur

**Description PO**:
```
Je veux ajouter un profil utilisateur avec :
- Nom complet
- Bio (texte court)
- Photo de profil (optionnel)

L'utilisateur doit pouvoir :
- Voir son profil
- Modifier ses informations
- Upload une photo

Validation:
- Le nom est obligatoire
- La bio max 500 caractères
```

**Ce que Skills va générer** (automatiquement):
```
✅ Architecture détectée: Balanced (3-layer)

Files créés:
  📁 packages/api/routers/profile.ts
  📁 packages/services/profile.service.ts
  📁 packages/database/repositories/profile.repository.ts
  📁 packages/validators/profile.validator.ts

Tests générés:
  🧪 profile.service.test.ts (15 tests)
  🧪 profile.router.test.ts (8 tests)

Coverage: 76% ✅

Validation:
  ✅ Code quality OK
  ✅ Architecture OK
  ✅ Tests OK
```

**Temps**: ~2 minutes

---

### Exemple 2: Feature Complexe - Système de Paiement

**Description PO**:
```
En tant qu'utilisateur,
Je veux pouvoir payer par carte bancaire,
Afin de souscrire à un abonnement mensuel.

Critères d'acceptation:
- [ ] L'utilisateur peut entrer ses informations de CB
- [ ] Le paiement est sécurisé (Stripe)
- [ ] L'utilisateur reçoit un email de confirmation
- [ ] L'abonnement est activé immédiatement
- [ ] En cas d'échec, l'utilisateur voit un message clair

Plans disponibles:
- Starter: 19€/mois
- Pro: 49€/mois
- Enterprise: 99€/mois

Règles métier:
- Un utilisateur ne peut avoir qu'un seul abonnement actif
- L'essai gratuit dure 14 jours
- Le paiement se renouvelle automatiquement
```

**Ce que Skills va générer**:
```
🔍 Détection: Balanced level, Web platform

🏗️  ARCHITECTURE (Phase 1/4):
  Router Layer:
    - subscriptionRouter.subscribe()
    - subscriptionRouter.cancel()
    - subscriptionRouter.getCurrent()

  Service Layer:
    - subscriptionService.create()
    - subscriptionService.processPayment()
    - subscriptionService.sendConfirmationEmail()

  Repository Layer:
    - subscriptionRepository (Prisma)

  ADR créé: ADR-042-subscription-model.md

👨‍💻 IMPLÉMENTATION (Phase 2/4):
  Files créés:
    ✅ packages/api/routers/subscription.ts (18 lines)
    ✅ packages/services/subscription.service.ts (45 lines)
    ✅ packages/database/repositories/subscription.repository.ts (32 lines)
    ✅ packages/validators/subscription.validator.ts (25 lines)
    ✅ packages/payments/stripe-client.ts (38 lines)
    ✅ packages/emails/templates/SubscriptionConfirmation.tsx

🧪 TESTS (Phase 3/4):
  Tests créés:
    ✅ Paiement réussi
    ✅ Paiement échoué (carte refusée)
    ✅ Email envoyé
    ✅ Abonnement activé
    ✅ Renouvellement automatique
    ✅ Annulation
    ✅ Un seul abonnement actif

  Coverage: 78% (required: 70%)

👀 VALIDATION (Phase 4/4):
  ✅ Code quality OK
  ✅ Architecture OK (3-layer)
  ✅ Tests OK (78% coverage)
  ✅ Security OK (Stripe secure)

Feature ready! 🎉
```

**Temps**: ~5 minutes

---

### Exemple 3: Feature avec Permissions

**Description PO**:
```
Je veux un système de permissions pour les équipes :

Rôles:
- Admin: Peut tout faire
- Manager: Peut inviter/retirer des membres
- Member: Peut voir l'équipe

Fonctionnalités:
- Créer une équipe (Admin seulement)
- Inviter des membres (Admin + Manager)
- Retirer des membres (Admin + Manager)
- Voir les membres (Tous)
- Changer de rôle (Admin seulement)

Règles:
- Il doit toujours y avoir au moins 1 Admin
- L'Admin ne peut pas se retirer lui-même
- Les invitations expirent après 7 jours
```

**Résultat**:
```
✅ Architecture: 3-layer avec RBAC (Role-Based Access Control)

Files:
  📁 routers/team.ts
  📁 services/team.service.ts
  📁 services/team-permissions.service.ts
  📁 repositories/team.repository.ts
  📁 middleware/check-team-role.ts

Tests:
  🧪 28 tests (tous les cas de permissions)

Coverage: 82%
```

---

## 📋 Checklist avant de Décrire une Feature

Avant de demander à Skills de créer une feature, assurez-vous d'avoir:

- [ ] **Qui**: Quel utilisateur utilise cette feature ?
- [ ] **Quoi**: Quelle action l'utilisateur veut faire ?
- [ ] **Pourquoi**: Quel problème ça résout ?
- [ ] **Données**: Quelles données sont nécessaires ?
- [ ] **Validation**: Quelles règles de validation ?
- [ ] **Sécurité**: Qui peut accéder à quoi ?
- [ ] **Edge cases**: Qu'est-ce qui peut mal se passer ?

**Plus vous êtes précis, meilleur sera le code généré.**

---

## 🎯 Niveau de Qualité : Rapid vs Balanced vs Crafted

Skills s'adapte automatiquement au niveau de votre projet :

### Rapid (MVP, 0-100 utilisateurs)

**Quand**: Vous testez une idée, vous voulez shipper vite

**Exemple**:
```
"Je veux un système de likes sur les posts"
```

**Résultat**:
- Code simple, direct
- Logique dans les routers
- Pas de tests obligatoires
- **Temps**: ~1 minute

### Balanced (Produit en croissance, 100-10K utilisateurs)

**Quand**: Vous avez des clients payants, vous voulez de la qualité

**Exemple**:
```
"Je veux un système de likes avec compteur et historique"
```

**Résultat**:
- Architecture 3-layer
- Business logic séparée
- Tests 70% coverage
- **Temps**: ~3 minutes

### Crafted (Entreprise, 10K+ utilisateurs)

**Quand**: Vous construisez pour 10+ ans, qualité maximale

**Exemple**:
```
"Je veux un système de likes thread-safe avec analytics"
```

**Résultat**:
- Architecture hexagonale
- Domain-Driven Design
- Tests 100% coverage
- ADRs pour chaque décision
- **Temps**: ~10 minutes

**Skills détecte automatiquement le niveau dans `.craftedrc.json`**

---

## 🎨 Templates de Features Prêts à l'Emploi

### Template: Authentification

```
Je veux ajouter l'authentification utilisateur avec :

Méthodes:
- Email + Password
- Google OAuth (optionnel)

Features:
- Inscription (email, password, nom)
- Connexion
- Déconnexion
- Mot de passe oublié
- Vérification email

Validation:
- Email valide
- Password min 8 caractères
- Password doit contenir: 1 majuscule, 1 chiffre

Sécurité:
- Hash passwords (bcrypt)
- JWT tokens
- Refresh tokens
```

---

### Template: CRUD Simple

```
Je veux gérer [ENTITÉ] avec :

Champs:
- [champ1]: [type]
- [champ2]: [type]
- [champ3]: [type]

Actions:
- Créer [ENTITÉ]
- Lire [ENTITÉ] (liste + détail)
- Modifier [ENTITÉ]
- Supprimer [ENTITÉ]

Validation:
- [règles de validation]

Permissions:
- Qui peut faire quoi
```

**Exemple concret**:
```
Je veux gérer des Produits avec :

Champs:
- Nom: string (obligatoire)
- Description: text
- Prix: number (en centimes)
- Stock: number
- Catégorie: enum (Electronics, Clothing, Food)
- Image: url (optionnel)

Actions:
- Créer produit (Admin seulement)
- Lire produits (Tous)
- Modifier produit (Admin seulement)
- Supprimer produit (Admin seulement)

Validation:
- Nom entre 3 et 100 caractères
- Prix > 0
- Stock >= 0
```

---

### Template: Feature avec Workflow

```
Je veux un workflow pour [PROCESSUS] :

États possibles:
- État 1
- État 2
- État 3

Transitions:
- État 1 → État 2 (quand: [condition], qui: [rôle])
- État 2 → État 3 (quand: [condition], qui: [rôle])

Règles métier:
- [règle 1]
- [règle 2]

Notifications:
- Email quand [événement]
```

**Exemple concret**:
```
Je veux un workflow pour les Commandes :

États possibles:
- Pending (en attente)
- Paid (payée)
- Shipped (expédiée)
- Delivered (livrée)
- Cancelled (annulée)

Transitions:
- Pending → Paid (quand: paiement validé, automatique)
- Paid → Shipped (quand: colis envoyé, admin)
- Shipped → Delivered (quand: livraison confirmée, admin)
- Pending → Cancelled (quand: utilisateur annule, user)
- Paid → Cancelled (quand: admin rembourse, admin)

Règles métier:
- Une commande Shipped ne peut pas être annulée
- Une commande Delivered est définitive
- L'annulation < 24h est automatique, > 24h nécessite validation admin

Notifications:
- Email quand commande Paid
- Email quand commande Shipped (avec tracking)
- Email quand commande Delivered
```

---

### Template: Feature avec Relations

```
Je veux gérer [ENTITÉ A] et [ENTITÉ B] avec :

Relations:
- [ENTITÉ A] [relation] [ENTITÉ B]
  (ex: Un User a plusieurs Posts)

[ENTITÉ A]:
- [champs]

[ENTITÉ B]:
- [champs]

Actions:
- CRUD [ENTITÉ A]
- CRUD [ENTITÉ B]
- Lier A à B
- Délier A de B

Règles:
- [contraintes de relation]
```

**Exemple concret**:
```
Je veux gérer des Équipes et des Membres avec :

Relations:
- Un Membre peut appartenir à plusieurs Équipes
- Une Équipe a plusieurs Membres
- Un Membre a un rôle par Équipe (Admin, Manager, Member)

Équipe:
- Nom (unique)
- Description
- CreatedAt

Membre:
- User (relation vers User)
- Team (relation vers Team)
- Role (enum: Admin, Manager, Member)
- JoinedAt

Actions:
- Créer équipe
- Inviter membre (par email)
- Accepter invitation
- Retirer membre
- Changer rôle

Règles:
- Il doit y avoir au moins 1 Admin par équipe
- Un Admin ne peut pas se retirer si c'est le seul Admin
- Les invitations expirent après 7 jours
```

---

## 🔄 Workflow Complet : De l'Idée au Code

### Étape 1: Préparer la Feature

**Exemple**: Système de notifications

```markdown
# Feature: Système de Notifications

## User Story
En tant qu'utilisateur,
Je veux recevoir des notifications,
Afin d'être informé des événements importants.

## Critères d'acceptation
- [ ] L'utilisateur peut voir ses notifications
- [ ] Les notifications peuvent être lues/non lues
- [ ] L'utilisateur peut marquer comme lu
- [ ] L'utilisateur voit le nombre de non lues
- [ ] Les notifications sont temps réel

## Types de notifications
- Nouveau follower
- Nouveau commentaire
- Nouveau like
- Mention
- Message privé

## Détails
- Stockage: Base de données
- Temps réel: WebSocket (optionnel pour Rapid)
- Rétention: 30 jours
```

---

### Étape 2: Demander à Skills

**Dans Claude Code**, tapez simplement:

```
Je veux créer un système de notifications avec :

Types:
- Nouveau follower
- Nouveau commentaire
- Nouveau like
- Mention
- Message privé

Fonctionnalités:
- Voir toutes les notifications (avec pagination)
- Marquer comme lu
- Marquer tout comme lu
- Supprimer une notification
- Compteur de non lues

Données:
- Type de notification
- Message
- Lien vers la ressource concernée
- Lu/Non lu
- Date de création

Règles:
- Les notifications > 30 jours sont supprimées automatiquement
- Max 100 notifications par utilisateur
- Temps réel avec WebSocket (si Balanced+)
```

---

### Étape 3: Skills Génère le Code

**Vous verrez en temps réel**:

```
🔍 Auto-détection...
  Niveau: balanced
  Platform: web

🏗️  Phase 1/4: Architecture

Designing 3-layer architecture for notifications...

Router Layer:
  - notificationRouter.list()
  - notificationRouter.markAsRead()
  - notificationRouter.markAllAsRead()
  - notificationRouter.delete()
  - notificationRouter.getUnreadCount()

Service Layer:
  - notificationService.create()
  - notificationService.list()
  - notificationService.markAsRead()
  - notificationService.cleanup()

Repository Layer:
  - notificationRepository (Prisma)

WebSocket:
  - notificationEmitter (real-time)

Creating ADR-043: Notification System Architecture

✅ Architecture complete

---

👨‍💻 Phase 2/4: Implementation

Creating files...
  ✅ packages/api/routers/notification.ts (22 lines)
  ✅ packages/services/notification.service.ts (48 lines)
  ✅ packages/database/repositories/notification.repository.ts (35 lines)
  ✅ packages/validators/notification.validator.ts (15 lines)
  ✅ packages/websocket/notification-emitter.ts (28 lines)

Validating code quality...
  ✅ Function length: All < 50 lines
  ✅ Parameters: All ≤ 3
  ✅ No violations

✅ Implementation complete

---

🧪 Phase 3/4: Testing

Writing tests...
  ✅ notificationService.create() - 5 tests
  ✅ notificationService.list() - 8 tests
  ✅ notificationService.markAsRead() - 3 tests
  ✅ notificationRouter tests - 10 tests

Running tests...
  ✅ 26 tests passing

Coverage: 74% (required: 70%)

✅ Tests complete

---

👀 Phase 4/4: Review

Validating...
  ✅ Code quality (all rules respected)
  ✅ Architecture (clean 3-layer separation)
  ✅ Tests (74% coverage)
  ✅ Type safety (all typed)
  ✅ Security (user isolation OK)

✅ Feature ready! 🎉

Summary:
  📊 5 files created
  📝 1 ADR documented
  🧪 26 tests written
  ✅ All validations passed

Time: ~4 minutes
```

---

### Étape 4: Vérifier et Tester

**Commandes utiles**:

```bash
# Vérifier la qualité du code
/validate

# Vérifier l'architecture
/guard

# Vérifier la coverage
/coverage

# Lancer les tests
pnpm test

# Lancer l'app
pnpm dev
```

---

## 💡 Tips pour de Meilleures Features

### ✅ DO: Bonnes Pratiques

1. **Soyez spécifique sur les données**
```
✅ "Prix en centimes (integer), min 0, max 1000000"
❌ "Un prix"
```

2. **Décrivez les règles métier**
```
✅ "Un utilisateur ne peut liker qu'une fois par post"
❌ "Système de likes"
```

3. **Mentionnez les cas d'erreur**
```
✅ "Si l'email existe déjà, retourner une erreur claire"
❌ "Créer un utilisateur"
```

4. **Précisez les permissions**
```
✅ "Seul l'auteur ou un admin peut supprimer"
❌ "Supprimer un post"
```

5. **Donnez des exemples de données**
```
✅ "Statut: draft | published | archived"
❌ "Un statut"
```

---

### ❌ DON'T: À Éviter

1. **Descriptions trop vagues**
```
❌ "Je veux un blog"
✅ "Je veux un système de blog avec posts, catégories, tags et commentaires"
```

2. **Oublier les validations**
```
❌ "Un champ email"
✅ "Un champ email (validé, unique, obligatoire)"
```

3. **Ignorer la sécurité**
```
❌ "Liste des utilisateurs"
✅ "Liste des utilisateurs (admins seulement)"
```

4. **Ne pas mentionner les relations**
```
❌ "Posts et commentaires"
✅ "Un post a plusieurs commentaires, un commentaire appartient à un post"
```

---

## 🚨 Résolution de Problèmes

### Problème: "La feature n'est pas comme je veux"

**Solution**: Soyez plus précis dans votre description

```
Avant:
"Je veux un système de recherche"

Après:
"Je veux une recherche de produits par:
- Nom (partial match, case insensitive)
- Catégorie (exact match)
- Prix (range: min-max)
- En stock seulement (checkbox)

Résultats:
- Pagination (20 par page)
- Tri par: pertinence, prix croissant, prix décroissant
- Afficher: nom, image, prix, stock"
```

---

### Problème: "Le code généré a un bug"

**Solution**: Utilisez le workflow `/bugfix`

```
Bug: Les utilisateurs peuvent voir les posts des autres utilisateurs supprimés

Skills va:
1. Écrire un test qui reproduit le bug
2. Trouver la cause
3. Fixer le code
4. Ajouter un test de régression
```

---

### Problème: "Je veux modifier une feature existante"

**Solution**: Utilisez le workflow `/refactor`

```
Cette feature fonctionne mais le code est devenu compliqué.
Je veux la refactorer en gardant le même comportement.
```

---

## 📊 Exemples de Features par Domaine

### E-Commerce

```
1. Catalogue de Produits
"Je veux gérer des produits avec nom, description, prix, images, stock, catégories"

2. Panier d'Achat
"Je veux un panier avec ajout/retrait de produits, quantité, calcul total, persistance session"

3. Checkout
"Je veux un processus de paiement avec adresse livraison, paiement Stripe, confirmation email"

4. Commandes
"Je veux gérer les commandes avec états (pending, paid, shipped, delivered), historique"

5. Wishlist
"Je veux une liste de souhaits où les utilisateurs peuvent sauvegarder des produits"
```

---

### SaaS B2B

```
1. Organisations/Teams
"Je veux des organisations avec membres, rôles (owner, admin, member), invitations"

2. Abonnements
"Je veux des plans (starter, pro, enterprise) avec limites par plan, billing Stripe"

3. Usage Tracking
"Je veux tracker l'usage par organisation (API calls, storage, users) avec quotas"

4. Facturation
"Je veux gérer les factures avec génération PDF, historique, download"

5. SSO/SAML
"Je veux l'authentification SSO pour les entreprises (Google Workspace, Microsoft 365)"
```

---

### Réseau Social

```
1. Profils
"Je veux des profils utilisateur avec photo, bio, followers/following"

2. Posts
"Je veux publier des posts avec texte, images, likes, commentaires, partages"

3. Feed
"Je veux un feed personnalisé avec posts des personnes suivies, pagination infinie"

4. Notifications
"Je veux des notifications temps réel pour likes, commentaires, follows, mentions"

5. Messages Privés
"Je veux un système de messagerie 1-to-1 avec temps réel, historique, lu/non lu"
```

---

### Marketplace

```
1. Vendeurs
"Je veux enregistrer des vendeurs avec profil, produits, évaluations"

2. Listings
"Je veux créer des annonces avec titre, description, prix, photos, catégorie"

3. Reviews
"Je veux un système d'avis avec note 1-5 étoiles, commentaire, vérification achat"

4. Transactions
"Je veux gérer les transactions vendeur-acheteur avec escrow, release paiement"

5. Disputes
"Je veux gérer les litiges avec messages, statuts, résolution admin"
```

---

## 🎓 Exercices Pratiques

### Exercice 1: Feature Basique (5 min)

**Objectif**: Créer un système de tags

**Description**:
```
Je veux gérer des tags pour les articles avec :

Tag:
- Nom (unique, obligatoire, 3-30 caractères)
- Couleur (hex color, optionnel)
- Slug (auto-généré depuis nom)

Actions:
- Créer tag
- Lister tags
- Modifier tag
- Supprimer tag (si pas utilisé)

Validation:
- Nom unique
- Pas de caractères spéciaux
- Slug auto-généré (lowercase, hyphens)

Relations:
- Un article peut avoir plusieurs tags
- Un tag peut être sur plusieurs articles
```

**Lancez et observez**: Skills va générer l'architecture, le code et les tests.

---

### Exercice 2: Feature Moyenne (10 min)

**Objectif**: Système de commentaires

**Description**:
```
Je veux un système de commentaires sur les posts avec :

Comment:
- Contenu (text, obligatoire, max 1000 chars)
- Auteur (relation User)
- Post (relation Post)
- Parent (optionnel, pour réponses)
- CreatedAt, UpdatedAt

Features:
- Ajouter commentaire
- Répondre à un commentaire (nested)
- Modifier son commentaire (< 15 min après création)
- Supprimer son commentaire (soft delete)
- Lister commentaires (threaded, pagination)

Permissions:
- Tout le monde peut commenter (si authentifié)
- Seul l'auteur peut modifier/supprimer
- L'auteur du post peut supprimer tout commentaire
- Les admins peuvent tout supprimer

Validation:
- Contenu non vide
- Max 1000 caractères
- Pas de spam (max 10 comments/hour par user)

Règles:
- Les réponses sont limitées à 3 niveaux de profondeur
- Un commentaire supprimé affiche "[deleted]"
- Le compteur de commentaires inclut les réponses
```

---

### Exercice 3: Feature Complexe (15 min)

**Objectif**: Système de réservation

**Description**:
```
Je veux un système de réservation pour des salles de réunion avec :

Salle:
- Nom
- Capacité (nombre de personnes)
- Équipements (array: projecteur, wifi, tableau)
- Photo
- Localisation (building, floor)

Réservation:
- Salle (relation)
- Utilisateur (relation)
- DateDébut (datetime)
- DateFin (datetime)
- Titre
- Description
- Participants (array d'emails)
- Statut (pending, confirmed, cancelled)

Features:
- Voir disponibilité d'une salle (par jour/semaine)
- Créer réservation
- Modifier réservation
- Annuler réservation
- Voir mes réservations
- Calendrier (vue semaine/mois)

Règles métier:
- Une salle ne peut pas être réservée 2 fois en même temps
- Réservation min 30 min, max 4 heures
- Créneaux par 30 min (9:00, 9:30, 10:00...)
- Horaires: 8h-20h en semaine, fermé weekend
- Réservation max 30 jours à l'avance
- Annulation min 2h avant le début
- Auto-annulation si salle vide après 15 min

Notifications:
- Email confirmation
- Email rappel 1h avant
- Email si annulée
- Email aux participants

Permissions:
- Tout utilisateur peut réserver
- Admins peuvent tout voir/modifier
- Managers peuvent voir leur département
```

---

## 📚 Ressources et Next Steps

### Documentation

- **QUICKSTART.md**: Guide rapide 5 minutes
- **TUTORIAL.md**: 6 tutoriels détaillés
- **README.md**: Référence complète des skills
- **TESTING-GUIDE.md**: Comment tester
- **VIDEO-DEMO-SCRIPT.md**: Script vidéo de démo

### Commandes Utiles

```bash
# Créer un nouveau projet
crafted clone

# Installer les skills (si projet existant)
crafted install-skills

# Valider le code
/validate

# Vérifier l'architecture
/guard

# Vérifier les tests
/coverage

# Aide
/help
```

### Skills Disponibles

**Workflows** (pour créer des features):
- `/feature` - Créer une feature complète
- `/bugfix` - Corriger un bug
- `/refactor` - Refactorer du code
- `/security` - Revue de sécurité

**Agents** (pour des tâches spécifiques):
- `/architect` - Design seulement
- `/developer` - Code seulement
- `/tester` - Tests seulement
- `/reviewer` - Review seulement

**Utilitaires** (validations rapides):
- `/validate` - Qualité du code
- `/guard` - Architecture
- `/coverage` - Tests

---

## 🎯 Checklist Finale: Êtes-vous Prêt ?

Avant de créer votre première feature, vérifiez:

- [ ] Vous avez un projet Crafted avec skills installés
- [ ] Vous connaissez le niveau du projet (rapid/balanced/crafted)
- [ ] Vous avez lu au moins un exemple complet
- [ ] Vous avez préparé votre description de feature
- [ ] Vous savez quelles données sont nécessaires
- [ ] Vous avez défini les règles de validation
- [ ] Vous avez pensé aux permissions
- [ ] Vous êtes prêt à lancer `/feature` !

---

## 🚀 À Vous de Jouer !

**Votre première feature**:

1. Ouvrez Claude Code dans votre projet
2. Pensez à une feature simple (ex: système de likes)
3. Décrivez-la en suivant les templates
4. Tapez votre description
5. Regardez Skills travailler !

**Exemple ultra-simple pour commencer**:
```
Je veux ajouter un système de likes sur les posts.

Un utilisateur peut:
- Liker un post (une fois seulement)
- Unliker un post
- Voir le nombre de likes

Règles:
- Un utilisateur ne peut liker qu'une fois par post
- Le compteur de likes est mis à jour en temps réel
```

**C'est tout !** Skills va générer l'architecture, le code, les tests et tout valider.

---

## 💪 Vous Êtes Maintenant un PO Augmenté par l'IA

Avec Crafted Skills, vous pouvez:

✅ Créer des features en quelques minutes
✅ Garantir la qualité du code (tests, architecture)
✅ Adapter le niveau de qualité à vos besoins
✅ Itérer rapidement
✅ Livrer du code production-ready

**Skills transforme vos idées en code. Vous gardez le contrôle.**

---

**Questions ?**
- Problèmes: `.claude/skills/TESTING-GUIDE.md`
- Exemples: `.claude/skills/TUTORIAL.md`
- Référence: `.claude/skills/README.md`
- Issues: https://github.com/crafted-saas/issues

**Bon développement ! 🚀**
