sametcelikbicak/task-decomposer

Une compétence d'agent IA qui aide les développeurs à décomposer des demandes complexes en séquences de tâches structurées, optimisées pour l'IA. Optimise l'utilisation de la fenêtre de contexte, gère les workflows multi-sessions et produit de meilleurs résultats avec moins de prompts ciblés. Compatible avec opencode, Claude Code, Cursor, Windsurf et GitHub Copilot.

Qu'est-ce que task-decomposer ?

Cette compétence fournit un cadre systématique pour décomposer des demandes de développement vagues ou trop larges en séquences de tâches atomiques, vérifiables et ordonnées par dépendances. Elle s'appuie sur un modèle en cinq étapes (Planifier → Découper → Prompter → Vérifier → Suivant) qui guide à la fois l'utilisateur et l'assistant IA. L'objectif principal est de maximiser l'efficacité de la fenêtre de contexte en évitant les dépassements et les changements de contexte intempestifs, tout en assurant une progression mesurable. La compétence génère automatiquement des fiches de prompt structurées, des plans de budget de contexte avec des fichiers `CONTEXT.md` de passation entre sessions, et des plans d'exécution détaillés. Elle est compatible avec plusieurs agents populaires (Claude Code, Cursor, Windsurf, GitHub Copilot, opencode) et propose des comportements spécifiques pour détecter les demandes trop larges, les sessions saturées en contexte, ou les utilisateurs perdus, ainsi que des anti-patrons à éviter (ex: « construire toute l'application » d'un coup, absence de critères d'acceptation).

Compatible avec✓Claude Code~Codex CLI✓Cursor✓OpenCode✓Windsurf
npx skills add sametcelikbicak/task-decomposer

Installed? Explore more Recherche et analyse de données skills: affaan-m/uspto-database, affaan-m/scholar-evaluation, affaan-m/literature-review · View all 6 →

Demander à votre IA préférée

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

Documentation

Task Decomposer (Décomposeur de tâches)

Aide les utilisateurs à décomposer des demandes complexes en séquences de tâches structurées et adaptées à l'IA. Optimise l'efficacité de la fenêtre de contexte, un ordre clair des dépendances et une progression mesurable — afin que l'utilisateur obtienne de meilleurs résultats avec des interactions plus ciblées et moins nombreuses.

Philosophie

La plupart des frustrations liées à l'IA proviennent d'une seule cause racine : demander trop de choses à la fois. Un seul prompt vague produit un résultat superficiel. La décomposition de tâches inverse cette tendance — elle apprend aux utilisateurs (et guide l'assistant) à penser en unités atomiques ordonnées par dépendances.

Le modèle : Planifier → Découper → Prompter → Vérifier → Suivant


Cadre orienté utilisateur

Lorsqu'un utilisateur exprime une demande vaste ou vague, guidez-le à travers ce cadre de décomposition :

Étape 1 : Articulation de l'objectif

Posez des questions de clarification à l'utilisateur pour définir le véritable objectif :

  • « Quel est le résultat unique que vous souhaitez lorsque ce sera terminé ? »
  • « Quelles sont les contraintes importantes ? (délais, stack technique, normes) »
  • « À quoi ressemble la réussite ? Comment allez-vous la vérifier ? »
  • « Qu'essayez-vous de ne pas faire ? (anti-objectifs) »

Résultat : Un paragraphe décrivant l'objectif. S'il fait plus de 3 phrases, continuez à affiner.

Étape 2 : Cartographie des dépendances

Aidez l'utilisateur à identifier l'ordre naturel du travail :

Niveau 1 — Fondations   (configuration, paramétrage, modèle de données)
Niveau 2 — Logique cœur   (logique métier, API, fonctionnalité principale)
Niveau 3 — Polissage       (UI, gestion d'erreurs, cas limites)
Niveau 4 — Vérification    (tests, relecture, déploiement)

Demandez : « Quels éléments doivent exister avant que le suivant puisse commencer ? »

Résultat : Une liste numérotée de 3 à 7 phases avec les dépendances marquées.

Étape 3 : Découpage en prompts atomiques

Chaque prompt que l'utilisateur donnera à l'IA doit être :

PropriétéDescription
AtomiqueUn seul changement logique — un fichier, une préoccupation
AutonomeContient assez de contexte pour être exécuté sans historique
VérifiableCritères d'acceptation / de rejet clairs
Adapté à la fenêtreTient confortablement dans la fenêtre de contexte (moins de ~40K tokens d'instructions)

Modèle pour chaque découpe :

## Tâche : [nom court]
## Contexte
[2-3 phrases : ce qui existe, ce qui n'existe pas, fichiers pertinents]
## Exigences
- [liste à puces de ce que l'IA doit faire]
- [fichiers spécifiques à créer/modifier]
## Critères d'acceptation
- [comment vérifier que cela est fait correctement]
## Contraintes
- [règles à suivre, choses à éviter]

Résultat : 3 à 7 fiches de prompt que l'utilisateur peut copier-coller une par une.

Étape 4 : Planification du budget de contexte

Avertissez l'utilisateur des limites de la fenêtre de contexte et planifiez en conséquence :

  • Session 1 (Fondations + Cœur) : ~3 prompts, démarrage à neuf
  • Session 2 (Polissage + Vérification) : ~3 prompts, démarrage à neuf
  • Passation entre sessions : terminez chaque session par un résumé CONTEXT.md

Générez un CONTEXT.md à chaque jalon :

# Passation de contexte — [Nom du jalon]

## Terminé
- [x] Élément terminé 1 — /chemin/vers/fichier
- [x] Élément terminé 2 — /chemin/vers/fichier

## Décisions
- Choix de X plutôt que Y car Z
- La réponse de l'API a la forme : { ... }

## Prochaine session
- Tâches restantes avec dépendances
- Fichiers que le prochain agent doit lire en premier

## État
- Branche : feature/xyz
- Migrations appliquées : 3
- Variables d'environnement ajoutées : DATABASE_URL, API_KEY

Étape 5 : Ordre d'exécution

Présentez le plan final à l'utilisateur :

## Plan d'exécution

Phase 1 — Fondations (Session 1)
  Prompt 1 : Mise en place du projet et configuration
  Prompt 2 : Création du schéma de base de données et des modèles
  Prompt 3 : Implémentation du middleware d'authentification
  └─ Vérifier : exécuter `npm run dev`, confirmer que la page de connexion se charge

Phase 2 — Logique cœur (Session 1 suite)
  Prompt 4 : Construction de l'API CRUD utilisateur
  Prompt 5 : Implémentation du service de logique métier
  └─ Vérifier : exécuter les tests, confirmer que l'API répond

Phase 3 — Polissage (Session 2)
  Prompt 6 : Ajout de la gestion d'erreurs et de la validation
  Prompt 7 : Mise en forme des composants UI
  └─ Vérifier : procédure de QA manuelle

Phase 4 — Vérification (Session 2 suite)
  Prompt 8 : Écrire les tests manquants
  └─ Vérifier : couverture >= 80 %, tous les tests passent

Comportement de l'assistant

Quand l'utilisateur demande quelque chose de vaste

  1. Ne PAS commencer à implémenter immédiatement
  2. Répondre plutôt avec les questions d'articulation de l'objectif (Étape 1)
  3. Une fois l'objectif clair, présenter une cartographie des dépendances pour confirmation
  4. Après approbation de l'utilisateur, générer le plan d'exécution avec les fiches de prompt
  5. Proposer d'exécuter le Prompt 1 immédiatement, ou laisser l'utilisateur conduire

Quand le contexte devient trop plein

Surveillez la taille de la conversation. Si les limites de contexte approchent :

  1. Résumez les décisions et l'état dans un CONTEXT.md
  2. Conseillez à l'utilisateur de démarrer une nouvelle session
  3. Demandez-lui d'inclure le CONTEXT.md dans le premier prompt de la nouvelle session

Quand l'utilisateur ne sait pas comment formuler son prompt

Proposez des modèles :

« J'ai besoin que tu [action] sur [fichier/zone]. 
Spécifiquement :
- [exigence 1]
- [exigence 2]
Ne fais pas : [ce qu'il faut éviter]
Vérifie par : [critère] »

Anti-patrons à éviter

Anti-patronPourquoi ça échoueÀ la place
« Construire toute l'application »Débordement de contexte, superficiel partoutDécomposer en 5 à 10 prompts atomiques
Changement de contexte en milieu de sessionLe contexte précédent gaspille des tokensTerminer le prompt → CONTEXT.md → nouvelle session
Pas de critères d'acceptationL'IA s'arrête trop tôt ou sur-ingénierieÉcrire 1 à 3 vérifications spécifiques par prompt
Dépendances implicitesL'IA fait de mauvaises suppositionsIndiquer explicitement « X doit exister avant Y »
Critères de succès vaguesImpossible de savoir quand c'est fini« L'API renvoie 200 avec { id } sur POST /users »

Exemples

Exemple 1 : Planification d'une fonctionnalité full-stack

Utilisateur : « J'ai besoin d'ajouter une page de paiement »

Réponse de l'agent utilisant le cadre :

  1. Clarification de l'objectif : « Quel fournisseur de paiement ? Produit unique ou montants variables ? Sauvegarder les moyens de paiement ? Des exigences de conformité ? »
  2. Cartographie des dépendances : Configuration Stripe → API Checkout → Formulaire de paiement UI → Pages succès/échec → Tests
  3. Fiches de prompt :
    • Prompt 1 : « Configurer le SDK Stripe, créer le point d'accès /api/create-payment-intent »
    • Prompt 2 : « Construire le formulaire de paiement React avec Stripe Elements »
    • Prompt 3 : « Ajouter les pages de succès/échec de paiement avec gestion d'erreurs »
    • Prompt 4 : « Écrire les tests pour les cas limites du flux de paiement »
  4. Budget de contexte : Session 1 (Prompts 1-2), Session 2 (Prompts 3-4)

Exemple 2 : Récupération de contexte

Utilisateur démarre une nouvelle session : « Je travaillais sur la page de paiement la dernière fois »

Agent : « Laissez-moi vérifier s'il existe un fichier CONTEXT.md à la racine du projet... »

S'il est trouvé : le lire et continuer là où il s'était arrêté. S'il n'est pas trouvé : demander « Quelle était la dernière chose qui fonctionnait ? Vous souvenez-vous des décisions clés ? »

Exemple 3 : Sauvetage d'un utilisateur bloqué

Utilisateur : « Mon prompt est ignoré, l'IA n'arrête pas de dévier »

Agent : « Votre prompt est peut-être trop large. Laissez-moi vous aider à le restructurer. Qu'essayez-vous d'accomplir ? »

Parcourez les Étapes 1 à 3 et produisez une fiche de prompt unique et ciblée.


Référence : Quand utiliser quelle approche

L'utilisateur ditApproche
« Ajouter une page de connexion »Petit → exécuter directement (pas de décomposition nécessaire)
« Construire un site e-commerce »Grand → utiliser le cadre complet
« Il oublie sans cesse ce qu'on a fait »Contexte plein → générer une passation CONTEXT.md
« Je ne sais pas par où commencer »Ambigu → d'abord l'Articulation de l'objectif
« J'ai cette PR, écris les tests »Spécifique → exécuter directement, pas de décomposition
« Mon prompt est trop long et l'IA ignore des parties »Gonflé → découper en prompts atomiques

Skills associés