Exécuteur de Tâches Parallèles

VérifiéPrudence

Orchestrateur de sous-agents pour exécuter des plans de développement en parallèle avec gestion des dépendances. Coordonne les tâches par vagues, valide leur complétude et met à jour la documentation.

Spar Skills Guide Bot
DeveloppementAvancé
04/03/2026
Claude Code
#parallel-agents#orchestration#task-dependencies#plan-execution#subagents

Recommandé pour

Synthèse automatique

Ce skill agit comme orchestrateur : il lit un fichier de plan markdown, regroupe les tâches par vagues selon leurs dépendances et délègue chaque tâche débloquée à un sous-agent parallèle jusqu'à ce que tout le plan soit terminé et validé.

Points forts

  • Ordonnancement par vagues basé sur les listes `depends_on` de chaque tâche, ce qui évite de lancer des tâches dont les prérequis ne sont pas finis
  • Modèle de prompt de sous-agent complet : contexte, critères d'acceptation, validation, journal dans le fichier plan et commit atomique
  • Boucle de contrôle après chaque vague (inspection, validation, nouvelle tentative ou escalade) avant de passer à la suite
  • Prise en charge d'un sous-ensemble de tâches (T1 T2 T4) avec récupération automatique des dépendances nécessaires

Limites

  • Ne se déclenche que sur une commande explicite `/parallel-task`, jamais automatiquement
  • Suppose un format de plan précis (`### T1:`, `- **depends_on**: [...]`) ; un plan mal structuré fait échouer le parsing
  • Ne gère pas les conflits entre agents parallèles au-delà de la consigne de ne committer que ses propres fichiers, et interdit tout push
Quand l'utiliser

À utiliser lorsqu'un plan de développement déjà découpé en tâches avec dépendances doit être exécuté en parallèle par plusieurs sous-agents.

Quand l'éviter

À éviter sur un plan non structuré ou des tâches fortement couplées qui ne peuvent pas être exécutées atomiquement et indépendamment.

Analyse de sécurité

Prudence
Score qualité78/100

There is no obfuscation, no curl|sh, no credential or secret exfiltration, and no destructive filesystem commands. The risk is operational rather than malicious: the skill spawns parallel subagents that autonomously edit code, run validation, and make git commits, with only a weak 'NEVER PUSH' guardrail and an ambiguous instruction about committing 'to github'. That is a legitimate but powerful workflow deserving a caution rating and human oversight, not a risky one.

Points d'attention
  • •Orchestrates autonomous subagents that edit files and create git commits without human review between waves
  • •Inconsistent git guidance: instructs agents to 'ensure that wave of work has been committed to github' while also saying 'NEVER PUSH' — ambiguous scope of repository operations
  • •No declared allowed-tools, yet the workflow implicitly requires file writes, shell/git execution, and subagent spawning
  • •Prompt template instructs agents to run validation/tests of unknown provenance and to modify arbitrary plan/files referenced by user input
Comment cette analyse est faite

Exemples

Run a full plan
/parallel-task ./plans/auth-plan.md
Run selected tasks only
/parallel-task ./plans/auth-plan.md T1 T2 T4
Flag-based task selection
/parallel-task user-profile-plan.md --tasks T3 T7

name: parallel-task description: > Only to be triggered by explicit /parallel-task commands.

Parallel Task Executor

You are an Orchestrator for subagents. Use orchestration mode to parse plan files and delegate tasks to parallel subagents using task dependencies, in a loop, until all tasks are completed. Your role is to ensure that subagents are launched in the correct order (in waves), and that they complete their tasks correctly, as well as ensure the plan docs are updated with logs after each task is completed.

Process

Step 1: Parse Request

Extract from user request:

  1. Plan file: The markdown plan to read
  2. Task subset (optional): Specific task IDs to run

If no subset provided, run the full plan.

Step 2: Read & Parse Plan

  1. Find task subsections (e.g., ### T1: or ### Task 1.1:)
  2. For each task, extract:
    • Task ID and name
    • depends_on list (from - **depends_on**: [...])
    • Full content (description, location, acceptance criteria, validation)
  3. Build task list
  4. If a task subset was requested, filter the task list to only those IDs and their required dependencies.

Step 3: Launch Subagents

For each unblocked task, launch subagent with:

  • description: "Implement task [ID]: [name]"
  • prompt: Use template below

Launch all unblocked tasks in parallel. A task is unblocked if all IDs in its depends_on list are complete.

Task Prompt Template

You are implementing a specific task from a development plan.

## Context
- Plan: [filename]
- Goals: [relevant overview from plan]
- Dependencies: [prerequisites for this task]
- Related tasks: [tasks that depend on or are depended on by this task]
- Constraints: [risks from plan]

## Your Task
**Task [ID]: [Name]**

Location: [File paths]
Description: [Full description]

Acceptance Criteria:
[List from plan]

Validation:
[Tests or verification from plan]

## Instructions
1. Examine working plan and any relevant or dependent files
2. Implement changes for all acceptance criteria
3. Keep work **atomic and committable**
4. For each file: read first, edit carefully, preserve formatting
5. Run validation if feasible
6. **ALWAYS mark completed tasks IN THE *-plan.md file AS SOON AS YOU COMPLETE IT!** and update with:
    - Concise work log
    - Files modified/created
    - Errors or gotchas encountered
7. Commit your work
   - Note: There are other agents working in parallel to you, so only stage and commit the files you worked on. NEVER PUSH. ONLY COMMIT.
8. Double Check that you updated the *-plan.md file and committed your work before yielding
9. Return summary of:
   - Files modified/created
   - Changes made
   - How criteria are satisfied
   - Validation performed or deferred

## Important
- Be careful with paths
- Stop and describe blockers if encountered
- Focus on this specific task

Ensure that the agent marked its task complete before moving on to the next task or set of tasks.

Step 4: Check and Validate.

After a wave of subagents complete their work:

  1. Inspect their outputs for correctness and completeness.
  2. Validate the results against the expected outcomes.
  3. If the task is truly completed correctly, ENSURE THAT TASK WAS MARKED COMPLETE WITH LOGS.
  4. If a task was not successful, have the agent retry or escalate the issue.
  5. Ensure that that wave of work has been committed to github before moving on to the next wave of tasks.

Step 5: Repeat

  1. Review the plan again to see what new set of unblocked tasks are available.
  2. Continue launching unblocked tasks in parallel until plan is done.
  3. Repeat the process until all* tasks are both complete, validated, and working without errors.

Error Handling

  • Task subset not found: List available task IDs
  • Parse failure: Show what was tried, ask for clarification

Example Usage

/parallel-task plan.md
/parallel-task ./plans/auth-plan.md T1 T2 T4
/parallel-task user-profile-plan.md --tasks T3 T7

Execution Summary Template

# Execution Summary

## Tasks Assigned: [N]

### Completed
- Task [ID]: [Name] - [Brief summary]

### Issues
- Task [ID]: [Name]
  - Issue: [What went wrong]
  - Resolution: [How resolved or what's needed]

### Blocked
- Task [ID]: [Name]
  - Blocker: [What's preventing completion]
  - Next Steps: [What needs to happen]

## Overall Status
[Completion summary]

## Files Modified
[List of changed files]

## Next Steps
[Recommendations]

Du fichier au premier essai

Le téléchargement contient exactement le contenu affiché sur cette fiche. Cette copie peut différer de la dernière version du dépôt source.

Consulter la source et ses fichiers annexes

Ce téléchargement contient uniquement SKILL.md. Les scripts, références, modèles et dépendances éventuels ne sont pas inclus. Récupérez les fichiers nécessaires depuis la source en conservant leur arborescence avant de poursuivre.

1. Télécharger le fichier

Télécharger SKILL.md

Depuis la racine d’un projet de test, enregistrez le fichier sous .skill-downloads/parallel-task-executor-mmbizkv2/SKILL.md, ou utilisez la commande suivante. Ce dossier sert à examiner la skill avant son installation.

Commande pour macOS/Linux ou WSL : un shell POSIX et curl sont nécessaires. Sous Windows sans WSL, utilisez le bouton de téléchargement et créez le dossier manuellement.

mkdir -p '.skill-downloads/parallel-task-executor-mmbizkv2' && curl --fail --show-error --location 'https://skills-guides.com/api/skills/parallel-task-executor-mmbizkv2/download' --output '.skill-downloads/parallel-task-executor-mmbizkv2/SKILL.md.part' && mv '.skill-downloads/parallel-task-executor-mmbizkv2/SKILL.md.part' '.skill-downloads/parallel-task-executor-mmbizkv2/SKILL.md'

2. Vérifier les prérequis

Lisez SKILL.md avant de l’utiliser. Si le fichier cite des scripts ou services externes, examinez-les et préparez les accès nécessaires dans votre environnement de test.

Aucune section de prérequis reconnue dans ce fichier. Cela ne signifie pas qu’il est autonome : les bibliothèques, outils et accès peuvent être cités ailleurs dans le contenu ou dans le dépôt source.

Les plateformes de la fiche sont des indications du catalogue. Les chemins ci-dessous suivent la documentation des outils ; ils ne prouvent pas que cette skill y a été exécutée. Aucune version minimale de ces outils n’est attestée pour cette fiche.

3. Charger la skill

Après vérification, copiez le dossier complet dans le projet avec l’une des commandes ci-dessous, puis ouvrez une nouvelle session de l’outil. La commande s’arrête si un dossier du même nom existe déjà : comparez les fichiers avant de le remplacer.

Claude Code
test -f '.skill-downloads/parallel-task-executor-mmbizkv2/SKILL.md' && test -s '.skill-downloads/parallel-task-executor-mmbizkv2/SKILL.md' && mkdir -p '.claude/skills' && test ! -e '.claude/skills/parallel-task' && cp -R '.skill-downloads/parallel-task-executor-mmbizkv2' '.claude/skills/parallel-task'

OpenSkills

OpenSkills doit déjà être installé. La procédure locale install/read est contrôlée avec OpenSkills 1.5.0, qui exige Node.js ≥ 20.6.0. Aucun slug du catalogue n’est résolu automatiquement.

Installation officielle d’OpenSkills
openskills install './.skill-downloads/parallel-task-executor-mmbizkv2'

openskills read 'parallel-task-executor-mmbizkv2'

La lecture doit afficher le contenu du fichier installé et son dossier de base. Elle ne lance ni la skill ni ses dépendances.

Pour un agent qui lit AGENTS.md, synchronisez ensuite l’index. Cette commande modifie AGENTS.md : relisez le diff avant de l’utiliser.

openskills sync

Mode manuel ou autre outil : joignez SKILL.md à une conversation, ou ouvrez-le dans un agent capable de lire les fichiers. Ajoutez les ressources annexes nécessaires. Il n’existe pas de dossier universel reconnu par tous les outils.

4. Faire un premier essai

Utilisez une entrée courte et fictive : un endpoint d’API, un petit document ou un brief d’interface. Dans une nouvelle conversation, joignez le fichier ou donnez son chemin à l’agent, puis adaptez cette demande :

Lis .skill-downloads/parallel-task-executor-mmbizkv2/SKILL.md et applique ses instructions à cet exemple : [décrire une entrée de test]. Indique les fichiers, dépendances ou accès qui manquent. Produis le résultat demandé par la skill sans inventer de données ni exécuter de script non examiné.

Résultat attendu : une sortie correspondant aux instructions de la skill, ou une liste précise des prérequis manquants. Une simple confirmation de lecture ne valide pas le premier usage. Si une ressource externe est indisponible, ce parcours reste à tester.

Skills similaires