Compétences writing-plans
📋

writing-plans

Sûr

Générer des plans de mise en œuvre détaillés pour les tâches de codage multi-étapes

Également disponible depuis: Cycleaddict,obra,ZhanlinCui,DYAI2025,davila7,DMJGilbert,Cygnusfear,CodingCossack

Transformer les spécifications en plans de mise en œuvre exploitables avec des tâches granulaires. Cette compétence comble le fossé entre les exigences et le code en créant une documentation complète qui suppose qu'aucun contexte préalable n'existe.

Prend en charge: Claude Codex Code(CC)
🥉 75 Bronze
1

Télécharger le ZIP du skill

2

Importer dans Claude

Allez dans Paramètres → Capacités → Skills → Importer un skill

3

Activez et commencez à utiliser

Tester

Utilisation de "writing-plans". Créer un plan pour ajouter la fonctionnalité de réinitialisation de mot de passe

Résultat attendu:

  • # Plan de mise en œuvre de la réinitialisation du mot de passe
  •  
  • **Objectif :** Permettre aux utilisateurs de réinitialiser leur mot de passe via un lien e-mail
  •  
  • **Architecture :** Flux de réinitialisation basé sur des jetons avec expiration, utilisant le service e-mail existant
  •  
  • **Stack technique :** Node.js, PostgreSQL, Nodemailer
  •  
  • ---
  •  
  • ### Tâche 1 : Schéma de base de données
  •  
  • **Fichiers :**
  • - Modifier : `migrations/001_add_password_reset.sql`
  •  
  • **Étape 1 : Créer le fichier de migration**
  •  
  • ```sql
  • ALTER TABLE users ADD COLUMN password_reset_token TEXT;
  • ALTER TABLE users ADD COLUMN password_reset_expires TIMESTAMP;
  • ```
  •  
  • **Étape 2 : Exécuter la migration**
  •  
  • Exécuter : `npm run migrate`
  • Attendu : 'Migration successful'

Utilisation de "writing-plans". Planifier la mise en œuvre d'un point de terminaison d'API REST

Résultat attendu:

  • ### Tâche 3 : Créer le point de terminaison API
  •  
  • **Fichiers :**
  • - Créer : `src/api/users.ts`
  • - Tester : `tests/api/users.test.ts`
  •  
  • **Étape 1 : Écrire le test qui échoue**
  •  
  • ```typescript
  • describe('GET /api/users/:id', () => {
  • it('returns user by id', async () => {
  • const response = await request(app).get('/api/users/1');
  • expect(response.status).toBe(200);
  • expect(response.body.name).toBe('Test User');
  • });
  • });
  • ```
  •  
  • **Étape 2 : Exécuter le test pour vérifier qu'il échoue**
  •  
  • Exécuter : `npm test -- tests/api/users.test.ts`
  • Attendu : FAIL avec 'Cannot GET /api/users/1'

Audit de sécurité

Sûr
v1 • 2/25/2026

Static analysis detected 20 potential issues (16 external command patterns, 4 weak cryptography flags). All are false positives from markdown code spans and code blocks in documentation. This is a documentation-only skill with no executable code, network operations, or security risks. Safe to publish.

1
Fichiers analysés
122
Lignes analysées
0
résultats
1
Total des audits
Aucun problème de sécurité trouvé
Audité par: claude

Score de qualité

38
Architecture
100
Maintenabilité
87
Contenu
50
Communauté
100
Sécurité
100
Conformité aux spécifications

Ce que vous pouvez construire

Intégration de nouveaux développeurs

Créer des plans détaillés qui aident les développeurs non familiarisés avec votre base de code à implémenter correctement les fonctionnalités sans nécessiter une supervision constante

Implémentation de fonctionnalités complexes

Décomposer les fonctionnalités multi-étapes en tâches gérables avec des étapes claires de test et de vérification pour un développement systématique

Flux de travail de développement piloté par les tests

Générer des séquences de tâches TDD qui guident les développeurs à travers l'écriture des tests en premier, l'implémentation du code et la vérification des fonctionnalités

Essayez ces prompts

Plan de mise en œuvre basique
Créez un plan de mise en œuvre pour ajouter l'authentification utilisateur à notre application web. Utilisez la compétence writing-plans pour décomposer cela en tâches de taille manageable.
Plan de refactorisation
Utilisez writing-plans pour créer un plan détaillé pour refactoriser le module de traitement des paiements. Incluez les tests, les modifications de fichiers et les étapes de migration.
Plan d'intégration d'API
J'ai besoin d'intégrer l'API Stripe pour la gestion des abonnements. Utilisez writing-plans pour créer un plan de mise en œuvre complet avec toutes les étapes nécessaires.
Fonctionnalité multi-composants
Créez un plan de mise en œuvre pour notre système de notifications en temps réel qui inclut les modifications de base de données, les points de terminaison API, les workers d'arrière-plan et les composants frontend.

Bonnes pratiques

  • Toujours commencer par l'en-tête de plan requis incluant l'objectif, l'architecture et la stack technique pour fournir un contexte complet
  • Décomposer les tâches en unités les plus petites possible (2 à 5 minutes chacune) afin que les développeurs puissent progresser de manière constante avec des commits fréquents
  • Inclure les chemins de fichiers exacts et les exemples de code complets dans les plans pour éliminer l'ambiguïté et la prise de décision pendant la mise en œuvre
  • Spécifier la sortie de test attendue à chaque étape afin que les développeurs puissent vérifier leur travail avant de continuer

Éviter

  • Écrire des instructions vagues comme 'ajouter une validation' ou 'mettre à jour le handler' sans spécifier le code exact et les emplacements de fichiers
  • Créer de grandes tâches qui combinent plusieurs étapes, ce qui rend difficile le suivi des progrès et l'isolement des erreurs
  • Ignorer les cas de test ou les sorties attendues, ce qui oblige les développeurs à deviner à quoi ressemble le succès
  • Omettre l'en-tête du plan ou les sections de contexte, en supposant que l'implémenteur a des connaissances préalables

Foire aux questions

Quand dois-je utiliser cette compétence ?
Utilisez cette compétence lorsque vous avez une spécification ou un document d'exigences pour une fonctionnalité multi-étapes et que vous devez créer un plan de mise en œuvre détaillé avant d'écrire du code.
Qu'est-ce qui rend une tâche de taille manageable ?
Une tâche de taille manageable prend 2 à 5 minutes à compléter et représente une action unique comme écrire un test, l'exécuter, implémenter un code minimal ou faire un commit.
Dois-je suivre TDD avec cette compétence ?
La compétence encourage les pratiques TDD (écrire le test, vérifier l'échec, implémenter, vérifier le succès, valider) mais vous pouvez adapter la structure des tâches à votre flux de travail.
Que se passe-t-il après la création du plan ?
Après avoir enregistré le plan, vous pouvez choisir l'exécution pilotée par un sous-agent dans la même session ou une session parallèle en utilisant la compétence executing-plans pour l'exécution par lots.
Où les plans sont-ils enregistrés ?
Les plans sont enregistrés dans `docs/plans/AAAA-MM-JJ-<nom-de-la-fonctionnalité>.md` avec un format de nom de fichier standardisé pour une référence facile.
Puis-je modifier les plans après leur création ?
Oui, les plans sont des documents markdown vivants. Mettez-les à jour si les exigences changent ou si l'implémentation révèle des étapes manquantes.

Détails du développeur

Structure de fichiers

📄 SKILL.md