atomic-tasks
atomic-tasks equips Claude Code teams with a structured framework for decomposing large projects into focused, verifiable units of work. Built around sprint workflows and continuous integration patterns, it streamlines how teams coordinate development across multiple technology stacks while maintaining code quality through integrated review and testing cycles.
atomic-tasks provides a structured framework for decomposing large projects into focused, verifiable units of work. The skill emphasizes breaking down complex work into smaller, independently testable atomic tasks—each designed to be completed and verified in isolation. This approach ensures that each task has clear completion criteria and can be tested independently before integration, reducing the risk of cascading failures and making progress measurable.
AI-generated summary based on this skill's SKILL.md
Install
TheBeardedBearSAS/claude-craft/atomic-tasks · repository language: Shell
git clone https://github.com/TheBeardedBearSAS/claude-craft
cp -r claude-craft/.claude/skills/atomic-tasks ~/.claude/skills/atomic-tasksFrequently asked questions
AI-generated answers based on this skill's SKILL.md and metadata
How does atomic-tasks help break down complex projects into smaller tasks?
atomic-tasks provides a structured framework for decomposing large projects into focused, verifiable units of work. The skill emphasizes breaking down complex work into smaller, independently testable atomic tasks—each designed to be completed and verified in isolation. This approach ensures that each task has clear completion criteria and can be tested independently before integration, reducing the risk of cascading failures and making progress measurable.
What is context rot prevention in atomic-tasks, and why does it matter?
atomic-tasks addresses context rot—quality degradation that occurs when AI agents work in long, unfocused sessions—by implementing fresh subagent contexts for each task. Rather than maintaining a single sprawling conversation, the skill uses a pattern where each atomic task spawns a clean context window. This prevents context pollution between tasks and ensures that each subagent begins with optimal focus, directly supporting the intent to prevent context rot and quality degradation by using fresh subagent contexts.
How can I implement atomic git commits and verifiable task completion criteria with this skill?
atomic-tasks guides teams in implementing atomic git commits and verifiable task completion criteria by structuring work so that each task maps to a single, reviewable commit. The skill teaches how to define clear completion criteria upfront—such as passing tests, code review gates, or integration checkpoints—before work begins. This approach ensures that every commit represents a complete, testable unit of work that can be independently verified and rolled back if needed.
What anti-patterns should I avoid when using the GSD get shit done pattern?
atomic-tasks identifies key anti-patterns to avoid, including the 'kitchen sink session' where multiple unrelated tasks are bundled together, causing context pollution and quality degradation. The skill teaches learners to recognize when sessions are becoming unfocused and to split work accordingly. By learning GSD pattern best practices and anti-patterns, teams avoid common pitfalls like mixing concerns, skipping verification steps, or allowing context to degrade across unrelated work streams.
How does atomic-tasks optimize token usage and enable parallel task execution?
atomic-tasks optimizes token usage by decomposing work into focused, time-boxed tasks—typically 30 minutes or less—that fit within fresh context windows without waste. This modular approach enables parallel execution across multiple subagents, each working on independent atomic tasks simultaneously. By keeping individual task scopes tight and verifiable, the skill reduces redundant context overhead and allows teams to coordinate development across multiple technology stacks while maintaining efficiency.
What is the fresh context subagent workflow pattern that atomic-tasks teaches?
atomic-tasks teaches a workflow where each atomic task receives a fresh, clean subagent context rather than continuing within a degraded or polluted session. This pattern involves defining task boundaries upfront, spinning up a focused subagent for each unit of work with only the necessary context, and ensuring completion before the context is discarded. This approach directly combats context degradation in long sessions and ensures that each task benefits from optimal focus and clarity, supporting sprint workflows and continuous integration patterns.
SKILL.md
rendered from the published skill — quoted content, verbatim
Atomic Tasks — Pattern GSD (Get Shit Done)
Pattern inspiré de 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
(truncated - see the full file via the links below)
Read as markdown · JSON record · Browse the source repository
File tree — 1 file
.claude/skills/atomic-tasks/SKILL.md