Communitygithub.com

wshobson/stratégies-de-coordination-de-tâches

Décomposer des tâches complexes, concevoir des graphes de dépendances et coordonner le travail multi-agents avec des descriptions de tâches appropriées et un équilibrage de la charge de travail. Utilisez cette compétence lors de la répartition du travail pour des équipes d'agents, de la gestion des dépendances de tâches ou du suivi de l'avancement de l'équipe.

Qu'est-ce que stratégies-de-coordination-de-tâches ?

Cette compétence permet de structurer et de coordonner le travail d'équipes d'agents IA en décomposant des tâches complexes en sous-tâches gérables, en concevant des graphes de dépendances pour visualiser les relations entre les tâches, et en équilibrant la charge de travail entre les agents. Elle est particulièrement utile pour les projets multi-agents, par exemple avec Claude Code, Cursor ou Codex, où plusieurs agents travaillent simultanément sur différentes parties d'un même problème. En utilisant des descriptions de tâches précises et en définissant clairement les dépendances, l'utilisateur évite les conflits et les retards, tout en optimisant l'utilisation des ressources. La compétence fonctionne en analysant le travail à accomplir, en le divisant en unités indépendantes ou séquentielles, et en assignant chaque unité à un agent avec des instructions claires et des critères de succès.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/wshobson/agents/tree/main/skills/task-coordination-strategies

Demander à votre IA préférée

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

Documentation

Que fait stratégies-de-coordination-de-tâches ?

Décomposer des tâches complexes, concevoir des graphes de dépendances et coordonner le travail multi-agents avec des descriptions de tâches appropriées et un équilibrage de la charge de travail. Utilisez cette compétence lors de la répartition du travail pour des équipes d'agents, de la gestion des dépendances de tâches ou du suivi de l'avancement de l'équipe.

Description étendue

Cette compétence fournit des stratégies et des modèles pour décomposer des projets volumineux en tâches atomiques, visualiser leurs dépendances et attribuer du travail à des agents multiples de manière à équilibrer la charge et minimiser les temps d'attente. Elle inclut des heuristiques pour déterminer la granularité des tâches, des formats de description standardisés et des techniques de suivi de l'avancement en temps réel.

Utilisation typique

  1. Décomposition d'une tâche complexe : L'utilisateur fournit une description de haut niveau du travail. Cette compétence guide le processus de décomposition en questions : "Quels sont les sous-objectifs ?", "Y a-t-il des dépendances entre eux ?", "Quel est l'ordre optimal d'exécution ?"
  2. Conception d'un graphe de dépendances : Créez un graphe orienté où chaque nœud est une tâche et chaque arête est une dépendance. Par exemple, la tâche A doit être terminée avant la tâche B.
  3. Attribution et équilibrage : Assignez les tâches aux agents disponibles en fonction de leurs compétences et de leur charge de travail actuelle, en évitant les goulots d'étranglement.
  4. Suivi et ajustement : Surveillez l'avancement, identifiez les blocages et réaffectez ou restructurez les tâches si nécessaire.

Exemple de workflow

Tâche racine : "Développer une fonctionnalité de recherche full-text"
Tâche 1 : "Concevoir le schéma de base de données pour l'index inversé"
Tâche 2 : "Implémenter le module de parsing de documents"
Tâche 3 : "Implémenter le module de recherche avec TF-IDF" (dépend de Tâche 1 et Tâche 2)
Tâche 4 : "Créer une API REST pour la recherche" (dépend de Tâche 3)
Tâche 5 : "Rédiger les tests unitaires pour Tâches 1-4"

Bonnes pratiques

  • Spécificité : Chaque description de tâche doit être auto-suffisante et inclure les critères d'acceptation.
  • Granularité : Les tâches doivent durer entre 30 minutes et 2 heures pour permettre une coordination fine sans micro-gestion.
  • Communication : Lorsqu'une tâche est terminée, l'agent doit en informer le coordinateur pour déclencher les tâches dépendantes.
  • Itération : Revoyez régulièrement le graphe de dépendances et les attributions pour vous adapter aux imprévus.

Limitations

  • La compétence ne gère pas automatiquement l'exécution parallèle ; elle fournit le plan et les descriptions.
  • Elle suppose que tous les agents ont accès au même contexte (dépôt de code, documentation).
  • Pour les tâches hautement interdépendantes, une approche séquentielle peut être plus efficace qu'une parallélisation.

Références

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

wshobson/accessibility-compliance

Implement WCAG 2.2 compliant interfaces with mobile accessibility, inclusive design patterns, and assistive technology support. Use when auditing accessibility, implementing ARIA patterns, building for screen readers, or ensuring inclusive user experiences.

wshobson/airflow-dag-patterns

Build production Apache Airflow DAGs with best practices for operators, sensors, testing, and deployment. Use when creating data pipelines, orchestrating workflows, or scheduling batch jobs.

wshobson/angular-migration

Migrate from AngularJS to Angular using hybrid mode, incremental component rewriting, and dependency injection updates. Use when upgrading AngularJS applications, planning framework migrations, or modernizing legacy Angular code.

wshobson/anti-reversing-techniques

Understand anti-reversing, obfuscation, and protection techniques encountered during software analysis. Use this skill when analyzing malware evasion techniques, when implementing anti-debugging protections for CTF challenges, when reverse engineering packed binaries, or when building security research tools that need to detect virtualized environments.

wshobson/api-design-principles

Master REST and GraphQL API design principles to build intuitive, scalable, and maintainable APIs that delight developers. Use when designing new APIs, reviewing API specifications, or establishing API design standards.

wshobson/architecture-decision-records

Write and maintain Architecture Decision Records (ADRs) following best practices for technical decision documentation. Use when documenting significant technical decisions, reviewing past architectural choices, or establishing decision processes.

wshobson/architecture-patterns

Implement proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. Use this skill when designing clean architecture for a new microservice, when refactoring a monolith to use bounded contexts, when implementing hexagonal or onion architecture patterns, or when debugging dependency cycles between application layers.

wshobson/async-python-patterns

Master Python asyncio, concurrent programming, and async/await patterns for high-performance applications. Use when building async APIs, concurrent systems, or I/O-bound applications requiring non-blocking operations.

wshobson/attack-tree-construction

Build comprehensive attack trees to visualize threat paths. Use when mapping attack scenarios, identifying defense gaps, or communicating security risks to stakeholders.

wshobson/auth-implementation-patterns

Master authentication and authorization patterns including JWT, OAuth2, session management, and RBAC to build secure, scalable access control systems. Use when implementing auth systems, securing APIs, or debugging security issues.

wshobson/avoid-ai-writing

Audit and rewrite prose so it stops reading as machine-generated. Use this skill when asked to remove AI-isms, clean up AI writing, edit a draft for AI tells, audit a README, changelog, release note, PR description, or blog post for machine-sounding prose, or make text sound less like AI. Supports a detect-only mode, a rewrite mode, and an edit-in-place mode, with optional voice and context profiles.

wshobson/backtesting-frameworks

Build robust backtesting systems for trading strategies with proper handling of look-ahead bias, survivorship bias, and transaction costs. Use when developing trading algorithms, validating strategies, or building backtesting infrastructure.

wshobson/bash-defensive-patterns

Master defensive Bash programming techniques for production-grade scripts. Use when writing robust shell scripts, CI/CD pipelines, or system utilities requiring fault tolerance and safety.

wshobson/bats-testing-patterns

Master Bash Automated Testing System (Bats) for comprehensive shell script testing. Use when writing tests for shell scripts, CI/CD pipelines, or requiring test-driven development of shell utilities.

wshobson/bazel-build-optimization

Optimize Bazel builds for large-scale monorepos. Use when configuring Bazel, implementing remote execution, or optimizing build performance for enterprise codebases.

wshobson/before-you-build

Pre-build product and feature risk review for founders, product managers, and AI-assisted builders. Use this skill when the user is about to build a landing page, MVP, SaaS product, internal tool, agent workflow, or major feature and needs to check demand, positioning, monetization, retention, trust, distribution, and adoption risk before implementation starts.

wshobson/billing-automation

Build automated billing systems for recurring payments, invoicing, subscription lifecycle, and dunning management. Use when implementing subscription billing, automating invoicing, or managing recurring payment systems.

wshobson/binary-analysis-patterns

Master binary analysis patterns including disassembly, decompilation, control flow analysis, and code pattern recognition. Use when analyzing executables, understanding compiled code, or performing static analysis on binaries.

wshobson/block-no-verify-hook

Configure a PreToolUse hook to prevent AI agents from skipping git pre-commit hooks with --no-verify and other bypass flags. Use when setting up Claude Code projects that enforce commit quality gates.

wshobson/brand-landingpage

Brand-first landing page designer — runs a brand-identity interview (colors, typography, shape language), then generates and iterates on a polished landing page via Stitch with deployment-ready HTML. Use when the user asks to create, design, or build a landing page, homepage, or marketing page and has no established visual direction. Skip when they have a design mockup, need a dashboard or app UI, are working at component level, building a multi-page app, or restyling with known design tokens — use frontend-design instead.

Skills associés