Interactive map · updated 2026-09-08
AI Coding Agent Tech Tree
A capability map for agentic coding: 30 skills across 5 tiers — from Claude Code fundamentals through hooks, agent skills, MCP servers, memory systems and subagents, up to CI/CD integration and agent swarms. Each node explains what the capability is, why it matters, how to implement it, and the pitfalls that catch teams. Click any node to expand it; “Requires” and “Unlocks” links walk the dependency graph.
What is an agentic-coding skill?
A discrete capability — like hooks, MCP servers or subagents — that extends what an AI coding agent can do reliably. Skills stack: each tier builds on the one below.
What order should I learn them in?
Follow the tiers. Foundation and Fundamentals make everything else safer; jumping straight to swarms without testing, memory and permissions discipline is how agent projects fail.
Where do the claims come from?
This map describes capabilities and implementation patterns. Unmeasured “X% faster” claims were deliberately removed; the one cost figure kept (prompt caching) restates Anthropic's published pricing.
Foundation
1 skills🤖AI Coding Assistant›Your starting point. An AI coding assistant that lives in your terminal, understands your codebase, and helps you code faster through natural conversation.
What it is
A terminal-based AI assistant that understands your entire codebase and helps you write, debug, and refactor code through natural conversation.
Why it matters
Automates repetitive engineering work, navigates complex codebases instantly, and turns natural-language intent into working code — shifting developer time from boilerplate to judgement.
Use cases
- Onboard new developers faster by having the AI explain existing code and conventions
- Accelerate bug fixes by letting AI analyze error traces and suggest solutions
- Prototype features rapidly by describing requirements in plain language
Getting started
- Install the CLI tool and authenticate
- Run the assistant in your project directory
- Start coding naturally—describe what you want to build
Do
Provide context about your project structure and goals
Don't
Rely solely on AI for security-critical code without review
Common pitfalls
- Starting without understanding your codebase structure
- Ignoring AI suggestions without understanding the reasoning
- Not using version control while experimenting
Fundamentals
6 skills🪝Agent Hooks›Event-driven automation that triggers shell commands in response to AI assistant events. Create pre/post hooks for tool calls, notifications, and custom workflows.
What it is
Event triggers that run custom commands when the AI assistant performs actions—like running tests after code changes or sending notifications on completion.
Why it matters
Enables fully automated workflows without manual oversight. Teams save hours per day on repetitive tasks like running tests, deploying, and status updates.
Use cases
- Auto-run tests after every code change to catch bugs instantly
- Send Slack notifications when long tasks complete
- Trigger deployments automatically after successful builds
Getting started
- Configure hooks in your project settings
- Define trigger events (pre-tool, post-tool, on-complete)
- Write shell scripts for each trigger
Do
Keep hooks fast (under 10 seconds) to avoid blocking
Don't
Create complex workflows in hooks—use separate automation tools
Common pitfalls
- Hooks that block indefinitely
- Not handling hook failures gracefully
- Over-automation that hides important issues
📚Agent Skills›Extend your AI assistant with custom skills—specialized knowledge, workflows, and tool integrations that can be invoked via slash commands.
What it is
Custom commands and knowledge bases that make your AI assistant an expert in your specific domain, stack, or company processes.
Why it matters
Transforms a general-purpose assistant into a specialized team member that knows your codebase, conventions, and workflows intimately.
Use cases
- Create a skill for your company's coding standards and PR templates
- Build domain expertise for niche technologies (legal, medical, finance)
- Share team-specific workflows across all developers
Getting started
- Identify repetitive tasks or knowledge gaps
- Write skill definition with triggers and actions
- Test skill with various inputs
Do
Keep skills focused on single, well-defined tasks
Don't
Over-engineer skills—start simple and iterate
Common pitfalls
- Skills that conflict with each other
- Skills that become outdated as processes change
- Creating skills for one-off tasks
🔌MCP Tool Use›Model Context Protocol tool use extends your AI assistant with external tools and data sources. Connect to databases, APIs, and custom services.
What it is
A standard protocol that lets AI assistants connect to external tools—databases, APIs, services—extending their capabilities beyond text processing.
Why it matters
Breaks down data silos. Your AI can now work with your entire tech stack: query databases, call APIs, manage cloud resources.
Use cases
- Connect AI to your database for instant data queries and analysis
- Integrate with CRM to pull customer data during support tasks
- Automate cloud resource management through natural language
Getting started
- Identify external tools your team uses daily
- Find or build MCP server for those tools
- Configure authentication and permissions
Do
Start with read-only connections for security
Don't
Connect to production systems without proper safeguards
Common pitfalls
- Over-permissive API access
- Not rate-limiting AI tool usage
- Failing to cache expensive API calls
🧹Prompt Hygiene›Disciplined prompt management to prevent docs drift and maintain consistent agent behavior. Version control your instructions, keep system prompts clean, and audit instructions regularly.
What it is
Disciplined management of AI instructions—keeping prompts clear, versioned, and consistent to prevent behavior drift.
Why it matters
Prevents subtle behavior degradation over time. Clean prompts = predictable, reliable AI behavior.
Use cases
- Version control AI instructions alongside code
- Audit prompts for contradictions
- Maintain consistent team conventions
Getting started
- Create an instructions file with clear guidance
- Version control prompt files
- Set up regular prompt reviews
Do
Keep prompts simple and explicit
Don't
Accumulate contradictory instructions over time
Common pitfalls
- Prompts contradicting each other
- Stale instructions being followed
- Overly complex prompt hierarchies
⚖️OpenClaw Assistant›Legal document analysis and contract review powered by AI. Parse agreements, identify risks, and generate legal summaries.
What it is
Specialized AI skill for legal document analysis—reviewing contracts, identifying risks, and extracting key clauses.
Why it matters
Dramatically speeds up legal review. What took days now takes hours, enabling faster business deals.
Use cases
- Review vendor contracts for risk clauses
- Extract key terms from NDAs
- Compare agreement terms across vendors
Getting started
- Install OpenClaw skill
- Configure document types to analyze
- Define risk criteria for your organization
Do
Use AI as first-pass filter, not final review
Don't
Rely solely on AI for legally binding decisions
Common pitfalls
- Missing context AI cannot understand
- Over-reliance on AI for edge cases
- Not updating risk criteria as case law evolves
🤝AI Cowork›Collaborative AI pairing where multiple developers share an AI session. Real-time collaboration, shared context, and coordinated workflows for team-based development.
What it is
Real-time collaborative AI sessions where multiple developers work with the same AI assistant simultaneously.
Why it matters
Enables pair programming with AI. Two developers + AI = accelerated learning and faster problem solving.
Use cases
- Onboarding sessions with senior and junior devs
- Mob programming with AI
- Real-time code review and pair editing
Getting started
- Configure shared session settings
- Establish collaboration protocols
- Set up role assignments
Do
Designate moderator for session focus
Don't
Have multiple people giving conflicting instructions
Common pitfalls
- Conflicting instructions causing confusion
- Session chaos without clear lead
- Lost context from rapid turns
Integration
8 skills🧪Unit Testing›Let your AI assistant write and run tests for your code. Integrates with popular testing frameworks to ensure code quality and catch regressions.
What it is
AI-powered test creation that automatically generates comprehensive test suites, maintaining quality without requiring developers to write boilerplate.
Why it matters
Drastically reduces the time to create tests while increasing coverage. Catches bugs before they reach production, saving costly emergency fixes.
Use cases
- Generate tests for legacy code that lacks coverage
- Quickly add regression tests after bug fixes
- Implement TDD by having AI write tests before implementation
Getting started
- Install testing framework (Jest, pytest, etc.)
- Configure AI to use your test framework
- Start with high-value test files
Do
Review AI-generated tests for edge cases
Don't
Accept all tests without understanding coverage gaps
Common pitfalls
- Testing implementation details instead of behavior
- Not maintaining tests as code evolves
- Over-relying on AI for test design
🧠Memory Systems›Persistent memory across sessions. The AI remembers your preferences, past decisions, project context, and learns from mistakes.
What it is
Long-term memory that lets AI assistants remember project context, team conventions, and past interactions across sessions.
Why it matters
Eliminates repetitive context-setting. Every conversation builds on previous knowledge—no starting from scratch each time.
Use cases
- Remember team coding standards across all projects
- Track ongoing refactoring across multiple sessions
- Maintain project-specific conventions without prompts
Getting started
- Enable memory features in your AI configuration
- Create memory entries for key project info
- Review and curate memory periodically
Do
Periodically review and clean up memories
Don't
Store sensitive data in AI memory
Common pitfalls
- Memories becoming outdated
- Conflicting memories from different contexts
- Over-reliance on memory instead of documentation
✅Testing Hooks›Automatically run tests before commits, after file changes, or on specific events. Ensure code quality with automated testing gates.
What it is
Automated test execution triggered by code changes—gates that prevent bad code from being committed or deployed.
Why it matters
Enforces quality standards without manual oversight. Every change gets tested, catching regressions before they reach teammates or customers.
Use cases
- Block commits that break tests
- Run full test suite on PR creation
- Validate changes in staging before deployment
Getting started
- Configure testing framework
- Set up hook triggers for your workflow
- Define pass/fail criteria
Do
Keep tests fast (under 2 minutes for pre-commit)
Don't
Block all work with overly strict gates
Common pitfalls
- Flaky tests breaking trust
- Too-slow gates discouraging commits
- Not running same tests locally as in CI
🔗3rd Party API Enrichment›Connect to external APIs for data enrichment. Pull in market data, user profiles, company info, and other third-party data sources.
What it is
Connecting AI assistants to external data sources—enriching your internal data with third-party insights in real-time.
Why it matters
Transforms AI from a coding assistant into a business intelligence tool. Access real-time market data, company info, and user insights.
Use cases
- Auto-enrich leads with company data during outreach
- Pull market data for financial analysis
- Integrate real-time pricing into applications
Getting started
- Identify valuable external APIs
- Set up API keys and authentication
- Configure data transformation rules
Do
Cache responses to reduce costs and latency
Don't
Expose API keys in client-side code
Common pitfalls
- Rate limit violations
- API changes breaking integrations
- Not handling API failures gracefully
⏳Long Run Tasks›Handle tasks that take hours or days. Background processing, progress tracking, and resumable workflows for complex operations.
What it is
AI workflows designed to run for extended periods—hours or days—handling complex, multi-stage operations with progress tracking.
Why it matters
Enables AI to handle real-world complexity: large refactors, comprehensive testing, data migrations that exceed normal session limits.
Use cases
- Large-scale code refactoring across thousands of files
- Comprehensive security audits of entire codebases
- Data processing pipelines that run overnight
Getting started
- Break task into checkpointable stages
- Set up progress tracking and logging
- Implement resume capability from checkpoints
Do
Design for failure at every checkpoint
Don't
Assume task will complete in single session
Common pitfalls
- Losing progress on failure
- Checkpoints too large to resume
- Not handling partial state correctly
🖥️VM + VSCode›Run AI in isolated VMs with full VSCode integration. Sandboxed environments for untrusted code, experiments, and parallel workstreams.
What it is
Running AI assistant within virtual machines—completely isolated environments that can be spun up, cloned, and destroyed on demand.
Why it matters
Enables safe experimentation and untrusted code handling. Can run multiple isolated AI sessions in parallel.
Use cases
- Experiment with radical refactoring safely
- Analyze untrusted code in sandbox
- Parallel development streams without interference
Getting started
- Set up VM infrastructure (local or cloud)
- Configure VSCode Remote access
- Define VM templates
Do
Use lightweight VMs for quick tasks
Don't
Run expensive VMs unnecessarily
Common pitfalls
- VM sprawl consuming resources
- Network latency in remote VMs
- Environment drift between VMs
⚠️Dangerously Skip Permissions›Bypass permission prompts for trusted workflows. Use with caution—enables fully autonomous operation without confirmation dialogs.
What it is
Configuration to bypass interactive permission prompts—enabling fully autonomous AI operation without human-in-the-loop.
Why it matters
Essential for CI/CD and unattended workflows. Eliminates the blocker that prevents AI from running in automated pipelines.
Use cases
- CI/CD pipelines that run without supervision
- Automated code review on schedule
- Unattended maintenance scripts
Getting started
- Audit all tools AI will use
- Configure permission bypass for specific commands
- Set up monitoring and rollback
Do
Start with read-only operations, expand gradually
Don't
Enable for untrusted or experimental AI prompts
Common pitfalls
- AI making unintended destructive changes
- Security gaps from overly broad permissions
- No audit trail of bypassed actions
📝Git Version Control›Let AI manage your git workflow. Commits, branches, merges, rebases, and conflict resolution with intelligent commit messages.
What it is
AI-assisted git operations—automatic commits, intelligent merge conflict resolution, and streamlined branch management.
Why it matters
Removes git friction. Developers spend less time on version control mechanics and more on actual development.
Use cases
- Auto-commit with descriptive messages
- Intelligent conflict resolution assistance
- Automated PR description generation
Getting started
- Configure AI git tools
- Define commit conventions
- Set up branch protection rules
Do
Review AI commits before pushing to shared branches
Don't
Let AI force push to protected branches
Common pitfalls
- Poor commit messages from AI
- Accidental commits to wrong branches
- Merge conflicts not properly understood
Advanced
8 skills🌳Git Worktrees›Work on multiple branches simultaneously with git worktrees. Each worktree gets its own AI instance for parallel development.
What it is
Git feature allowing multiple working trees linked to the same repository, enabling parallel work on multiple branches simultaneously.
Why it matters
Eliminates context-switching overhead. Developers can work on features, bugs, and experiments in parallel without stashing or merging.
Use cases
- Run AI agents in parallel on different features
- Quickly switch context without losing work
- Test multi-branch integration before merging
Getting started
- Ensure git version supports worktrees
- Create worktree for new branch
- Open separate terminal session for each worktree
Do
Use descriptive branch names for worktree organization
Don't
Create too many worktrees and lose track
Common pitfalls
- File conflicts between worktrees
- Not cleaning up merged worktrees
- Resource exhaustion from too many sessions
👥Subagents›Spawn specialized child agents for specific tasks. Delegate work, parallelize operations, and coordinate complex multi-step workflows.
What it is
AI agents that can spawn and coordinate smaller, specialized AI workers to handle complex tasks in parallel.
Why it matters
Scales AI capability beyond single-threaded conversation. One prompt can spawn dozens of workers tackling different aspects simultaneously.
Use cases
- Parallel code review across multiple files
- Generate tests, docs, and implementation simultaneously
- Coordinate research across multiple topics
Getting started
- Identify tasks that can be parallelized
- Define subagent roles and capabilities
- Set up result aggregation
Do
Design clear interfaces between parent and subagents
Don't
Over-parallelize causing coordination overhead
Common pitfalls
- Subagents diverging from parent goals
- Result conflicts not handled
- Resource exhaustion from too many agents
💾Prompt Caching›Optimize costs and latency with intelligent prompt caching. Reuse context across calls and minimize redundant API usage.
What it is
Technique to store and reuse prompt context between AI interactions, reducing redundant processing and API costs.
Why it matters
Cached input tokens are billed at a fraction of the base rate (per Anthropic’s published pricing, cached reads cost roughly a tenth of standard input), which makes long system prompts and high-volume agent loops dramatically cheaper and faster.
Use cases
- Long conversations that reference earlier context
- Batch processing similar queries
- Multi-turn workflows with shared context
Getting started
- Identify stable context across requests
- Configure cache storage (Redis, database)
- Set cache invalidation rules
Do
Set appropriate TTL based on data freshness needs
Don't
Cache sensitive data without encryption
Common pitfalls
- Stale cached data causing wrong responses
- Cache misses causing slowdowns
- Over-caching leading to memory issues
⏰Cron Jobs›Schedule AI to run automated tasks on a schedule. Daily reports, maintenance scripts, and recurring workflows.
What it is
Time-based triggers that run AI workflows on schedules—daily, weekly, or custom intervals without manual invocation.
Why it matters
Transforms AI from on-demand tool to continuous team member. Automates routine tasks that would otherwise consume hours weekly.
Use cases
- Daily code health reports
- Automated dependency updates
- Weekly security scans
- Nightly test suite runs
Getting started
- Identify recurring tasks suitable for automation
- Define task inputs and expected outputs
- Set up scheduling (cron, systemd timers)
Do
Log all executions for debugging
Don't
Schedule tasks that require human judgment
Common pitfalls
- Tasks running at wrong times due to timezone issues
- Notification fatigue from too-frequent runs
- Not handling scheduled task failures
🌐Headless Cloud Browsers›Spin up headless browsers in the cloud for web automation at scale. Scraping, testing, and interaction without local browser dependencies.
What it is
Browser automation running in cloud environments—enabling web scraping, testing, and interaction at scale without local resources.
Why it matters
Unlocks the web as a data source and automation target. Scale operations from single browser to hundreds in parallel.
Use cases
- Automated end-to-end testing at scale
- Web scraping for competitive intelligence
- Form submission and data entry automation
Getting started
- Choose browser automation service (Puppeteer, Playwright cloud)
- Define browser tasks as scripts
- Set up scaling and concurrency
Do
Implement retry logic for flaky pages
Don't
Scrape sites violating terms of service
Common pitfalls
- IP blocking from cloud IPs
- Page changes breaking selectors
- Resource costs spiraling without limits
⚡Parallel Agents›Run multiple AI agents simultaneously on independent tasks. Maximize throughput by parallelizing work across isolated agent instances.
What it is
Capability to run multiple AI agents concurrently—each handling independent tasks while coordinating through a parent agent.
Why it matters
Linear scaling for AI capability. 10 agents = ~10x throughput on parallelizable workloads.
Use cases
- Parallel code review across entire PR
- Concurrent data processing pipelines
- Multiple research streams simultaneously
Getting started
- Identify fully independent subtasks
- Configure agent worker pool
- Set up result aggregation
Do
Design tasks to be truly independent
Don't
Add coordination overhead exceeding parallel gains
Common pitfalls
- API rate limit exhaustion
- Inconsistent results across agents
- Resource costs scaling linearly
📋Dependency Plans›Create execution plans with task dependencies. Define DAGs of work where agents automatically respect ordering constraints and parallelize where possible.
What it is
Task orchestration based on dependencies—defining what must happen before what, enabling intelligent parallelization.
Why it matters
Optimizes complex workflows automatically. Tasks run in parallel when possible, sequentially when required, with zero manual ordering.
Use cases
- Build systems that optimize compilation order
- Data pipelines with stage dependencies
- Multi-service deployments with ordering constraints
Getting started
- Map out task dependencies
- Define input/output contracts
- Configure execution engine
Do
Keep dependencies simple and explicit
Don't
Create overly complex dependency graphs
Common pitfalls
- Circular dependencies
- Hidden coupling between tasks
- Single point of failure in critical path
🛡️Security Hardening›Secure your agentic workflows with hardened configurations. Input validation, secret management, sandboxed execution, and audit trails for production-grade agent deployments.
What it is
Security practices for AI agent deployments—protecting secrets, validating inputs, and maintaining audit trails.
Why it matters
Essential for production deployments. Without security hardening, agents become attack vectors.
Use cases
- Protect API keys and credentials
- Validate all inputs to prevent injection
- Maintain compliance with audit requirements
Getting started
- Audit all data access points
- Implement secret management (vault, env)
- Set up comprehensive logging
Do
Defense in depth—multiple security layers
Don't
Assume AI agents are inherently secure
Common pitfalls
- Secrets in logs or context
- Input validation gaps
- Insufficient monitoring
Expert
7 skills☁️Declarative Infrastructure›Use AI to write and deploy infrastructure as code. CDK, Terraform, and Pulumi patterns for serverless and cloud-native apps.
What it is
Infrastructure defined in code (not manual procedures)—enabling AI to provision, modify, and manage cloud resources programmatically.
Why it matters
Eliminates manual infrastructure work. Teams can spin up entire environments with a single command, reducing setup time from days to minutes.
Use cases
- Spin up staging environments on demand
- Automate infrastructure changes through PRs
- Implement infrastructure testing in CI
Getting started
- Choose infrastructure tool (Terraform, CDK, Pulumi)
- Define base infrastructure templates
- Set up state management
Do
Use modules for reusable infrastructure patterns
Don't
Commit secrets to infrastructure code
Common pitfalls
- State drift between environments
- Destructive changes without review
- Overly complex infrastructure definitions
🔄CI/CD Integration›Integrate AI assistants into your continuous integration and deployment pipelines. Automated code review, testing, and deployment assistance.
What it is
Embedding AI capabilities directly into your delivery pipelines—automating review, testing, and deployment decisions.
Why it matters
Creates a self-driving deployment pipeline. Code gets reviewed, tested, and deployed with minimal human intervention.
Use cases
- AI-powered code review in every PR
- Automated dependency updates
- Self-healing deployments that roll back on failure
Getting started
- Identify CI/CD platform (GitHub Actions, GitLab, etc.)
- Create AI integration points in pipeline
- Define quality gates and rollbacks
Do
Start with non-blocking AI feedback, then add enforcement
Don't
Let AI block deployments without human override
Common pitfalls
- AI false positives causing alert fatigue
- Pipeline slowdowns from AI processing
- Over-reliance on AI instead of human review
🔁Bug Resolution Loops›Self-healing agents that detect, diagnose, and fix bugs autonomously. The agent watches CI pipelines, error logs, and user reports, then enters an iterative loop: reproduce the bug, identify root cause via code analysis, generate a fix, run tests to verify, and deploy the patch.
What it is
Autonomous agents that find, diagnose, and fix bugs without human intervention—continuous self-healing code.
Why it matters
Transforms bug fixing from reactive to proactive. Bugs are fixed before you even know they exist.
Use cases
- Auto-fix CI failures before notification
- Respond to production errors in real-time
- Continuously improve code quality
Getting started
- Set up comprehensive error tracking
- Define bug severity thresholds
- Configure auto-fix approval workflows
Do
Start with non-critical fixes, expand gradually
Don't
Auto-fix security bugs without human review
Common pitfalls
- Fixes introducing new bugs
- Infinite fix loops
- Missing edge cases in auto-generated patches
♾️Always On Loops›Persistent agent loops that run continuously, monitoring systems, responding to events, and maintaining state across restarts. True 24/7 autonomous operation.
What it is
AI agents designed to run 24/7—continuously monitoring, responding, and acting without session boundaries.
Why it matters
True autonomous operation. AI that never sleeps, always watching, always ready to act.
Use cases
- Real-time security monitoring and response
- Continuous customer support
- Ongoing data processing pipelines
Getting started
- Design for stateless execution
- Set up persistent state storage
- Configure health monitoring
Do
Implement graceful degradation
Don't
Run critical operations without fallback
Common pitfalls
- Resource leaks over time
- State corruption in long-running processes
- Alert fatigue from excessive monitoring
📡Cloud Log Tracers›Agents that tail cloud logs in real-time, correlate events across services, and trace issues through distributed systems. Observability meets AI.
What it is
AI-powered observability—continuously analyzing logs, traces, and metrics to detect and diagnose issues automatically.
Why it matters
Transforms debugging from manual detective work to automated diagnosis. Issues are identified and traced instantly.
Use cases
- Real-time production issue detection
- Correlation across microservices
- Performance anomaly alerting
Getting started
- Set up log aggregation (ELK, Datadog, etc.)
- Configure trace instrumentation
- Define anomaly detection rules
Do
Start with critical services, expand coverage
Don't
Create noise with excessive alerting
Common pitfalls
- Log explosion overwhelming systems
- False positives causing alert fatigue
- Missing context in distributed traces
🔬Autonomous Integration Tests›Self-writing integration tests that evolve with your codebase. Agents analyze system interactions, generate comprehensive test suites, and automatically update tests when APIs change.
What it is
AI systems that automatically generate and maintain integration tests—adapting as code changes.
Why it matters
Eliminates the maintenance burden of integration tests. Coverage improves automatically as systems evolve.
Use cases
- Auto-generate tests for new API endpoints
- Detect breaking changes before deployment
- Comprehensive API contract testing
Getting started
- Define API contracts and schemas
- Set up test generation triggers
- Configure change detection
Do
Review auto-generated tests for business logic
Don't
Trust tests blindly without understanding coverage
Common pitfalls
- Tests testing implementation not behavior
- Over-generation causing test suite bloat
- Missing non-API interactions
🐝Agent Swarms›Orchestrate multiple AI agents working together. Distributed problem solving, consensus mechanisms, and emergent collaboration.
What it is
Coordinated systems of multiple AI agents working together—emergent intelligence from agent collaboration.
Why it matters
Solves problems beyond single-agent capability. Complex challenges are distributed across specialized agents that collaborate.
Use cases
- Enterprise-scale codebases with specialized reviewers
- Comprehensive system audits
- Autonomous software development teams
Getting started
- Define agent roles and responsibilities
- Set up communication protocols
- Configure coordination mechanisms
Do
Start with small, well-defined swarms
Don't
Over-complicate coordination without need
Common pitfalls
- Swarm consensus failures
- Resource exhaustion
- Coordination overhead exceeding benefits