Skip to content
Skills Library
AI & agents · Planning

atomic-tasks

/atomic-tasks

Pattern GSD (Get Shit Done) - découper en tâches atomiques avec contextes subagent frais pour combattre le context rot. Use when planning complex work or working past 50% context usage.

Licence
MIT
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
2
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Pattern GSD (Get Shit Done) - découper en tâches atomiques avec contextes subagent frais pour combattre le context rot. Use when planning complex work or working past 50% context usage.

Original author description

Pattern GSD (Get Shit Done) - découper en tâches atomiques avec contextes subagent frais pour combattre le context rot. Use when planning complex work or working past 50% context usage.

How it works

  1. Les 5 étapes du pattern GSD
  2. Signaux qu'il faut appliquer ce pattern
  3. Anti-patterns à éviter
  4. Intégration Claude Craft
  5. Ressources
Original SKILL.md headings · 116 lines, 627 words
SKILL.md preview
---
name: atomic-tasks
description: Pattern GSD (Get Shit Done) - découper en tâches atomiques avec contextes subagent frais pour combattre le context rot. Use when planning complex work or working past 50% context usage.
context: fork
---

# Atomic Tasks — Pattern GSD (Get Shit Done)

Pattern inspiré de [gsd-build/get-shit-done](https://github.com/gsd-build/get-shit-done) (Lex Christopherson, adopté par Amazon/Google/Shopify/Webflow).

**Objectif :** combattre le **context rot** (dégradation de la qualité au-delà de ~50% de contexte utilisé) en découpant le travail en tâches atomiques exécutées dans des subagents à contexte frais.

## Les 5 étapes du pattern GSD

### 1. Split work — Découper

Découper la feature en tâches **atomiques** :
- Chacune exprimable en 1-3 phrases
- Chacune réalisable en < 30 minutes
- Chacune testable indépendamment
- Chacune committable en un commit atomique

```
❌ MAUVAIS : "Ajouter le système d'authentification"
✅ BON :
  1. "Créer la table users avec migration"
  2. "Implémenter POST /auth/register avec validation email"
  3. "Implémenter POST /auth/login retournant JWT"
  4. "Ajouter middleware JWT verification"
  5. "Tests d'intégration du flow login"
```

### 2. Small plans — Plans courts par tâche

Pour chaque tâche atomique, un plan **court** :
- 1 objectif
- 3-5 étapes max
- Critères de succès explicites (test qui passe, endpoint qui répond, fichier qui existe)

### 3. Fresh subagent contexts — Contexte neuf à chaque tâche

**Règle fondamentale :** chaque tâche atomique s'exécute dans un **subagent à contexte frais** (via Task tool ou `/clear` entre tâches).

| Raison | Impact |
|--------|--------|
| Contexte < 30% au démarrage | Qualité réponses maximale |
| Pas de résidus de la tâche précédente | Zéro confusion cross-task |
| Coût tokens optimisé | Pas de relecture inutile du contexte accumulé |
| Parallélisable | Plusieurs subagents en simultané |

**Implémentation :**
- Utiliser `Agent` tool avec `subagent_type=general-purpose` ou spécialisé
- Passer UNIQUEMENT le contexte nécessaire (pas tout le projet)
- Demander un rapport concis à la fin (< 200 mots)

### 4. Atomic git commits — Commits atomiques

Chaque tâche = 1 commit. **Jamais** de commit qui mélange 2 tâches.

```
✅ BON :
  commit 1 : "feat(auth): add users table migration"
  commit 2 : "feat(auth): implement register endpoint"
  commit 3 : "feat(auth): implement login endpoint"

❌ MAUVAIS :
  commit 1 : "feat: auth system + bug fixes + refactor"
```

**Bénéfice :** `git bisect` efficace, reverts ciblés, review facilitée.

### 5. Verify goals — Vérifier chaque objectif

Avant de passer à la tâche suivante, **vérifier explicitement** que l'objectif est atteint :

- [ ] Le test écrit passe
- [ ] L'endpoint répond avec le bon code HTTP
- [ ] Le build compile
- [ ] Le linter passe
- [ ] Le comportement utilisateur est observable

**Règle :** pas de "je pense que ça marche". **Preuve ou pas fini.**

## Signaux qu'il faut appliquer ce pattern

- Contexte utilisé > 50%
- Tâche qui s'étale sur > 1h sans livrable intermédiaire
- Réponses de Claude qui deviennent moins précises
- Besoin de re-expliquer des choses déjà dites
- Multiple responsabilités dans une seule demande

## Anti-patterns à éviter

| Anti-pattern | Pourquoi mauvais |
|--------------|------------------|
| **Kitchen-sink session** | Tout faire dans 1 session = context rot garanti |
| **Tâche non testable** | Impossible à vérifier = jamais "done" |
| **Commit mélangé** | Review impossible, revert dangereux |
| **Pas de clear entre tâches** | Pollution inter-tâches |
| **Planification excessive** | 10 étapes pour changer 1 ligne = overhead |

## Intégration Claude Craft

- **`/workflow:analyze`** — phase d'analyse BMAD doit produire des tâches atomiques
- **`/common:ralph-run`** — Ralph doit itérer sur des tâches atomiques, une par boucle
- **Agent tool** — chaque tâche complexe déléguée à un subagent frais
- **Rule 12 (context-management)** — `/clear` obligatoire entre tâches non liées
- **Rule 23 (karpathy-principles)** — minimal code par tâche

## Ressources

- [gsd-build/get-shit-done](https://github.com/gsd-build/get-shit-done)
- Rule `.claude/rules/01-workflow-analysis.md`
- Rule `.claude/rules/12-context-management.md`
- Command `/common:sub-agents-patterns`

---

**Date de dernière mise à jour :** 2026-04-15
**Version :** 1.0.0

Versions

The database has no other skills named atomic-tasks.

Database snapshot: 13.11.2026 · package version 02dbe2c8ff98 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100gsd-ralph-context-loop
    Orchestrate coding work with GSD (Capture→Clarify→Organize→Execute→Review) and Ralph Loop (Observe→Act→Feedback→Promote→Enforce). Use parallel agents/workflows for multi-faceted tasks. Auto-invoke when user says GSD, Ralph Loop, get shit done, work in parallel agents, context…
  • 100iterative-retrieval
    Pattern for progressively refining context retrieval to solve the subagent context problem. Use when a subagent lacks the context it needs and retrieval must be refined across passes.
  • 100gsd-headless
    Orchestrate GSD (Get Shit Done) projects programmatically via headless CLI. Use when an agent needs to create milestones from specs, execute software development workflows, monitor task progress, check project status, or control GSD execution (pause/stop/skip/steer). Triggers on…
  • 100clear-context
    Manages context overflow by handing off to a fresh subagent at 80% usage. Use when context pressure is critical and work must continue uninterrupted.
  • 86handle-large-tasks
    Use this skill to split large plans into smaller chunks. This skill manages your context window for large tasks. Use it when a task will take a long time and cause context issues.
  • 96gsd-thread
    Use when work spans sessions and does not belong to any specific phase, or when the user wants to create, list or resume a context thread. Keeps lightweight threads under .planning/threads/.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.