name: auto-agents
description: Automatically triggers the Auto Agents Orchestrator for any task, activates using-superpowers skill discipline, dynamically scans ALL currently installed skills (from the skills directories) to find relevant ones by relevance, and coordinates specialist auto agents. This skill MUST be used for ANY user request, regardless of what the user is asking. Always activates using-superpowers first, then dynamically scans all currently installed skills to identify relevant skills before invoking the Agents Orchestrator - automatically includes newly added skills.
compatibility: Claude Code, requires ~/.claude/agents/ with auto-agents installed, using-superpowers installed

Auto Agents Skill

Core Purpose

This skill automatically triggers for ANY user prompt and:
1. Activates the using-superpowers skill first to enforce proper skill invocation discipline on every run
2. Scans ALL installed skills in your environment
3. Identifies which skills are relevant to the current user request
4. Orders them by relevance (most relevant first)
5. Activates the Agents Orchestrator with this pre-computed relevance information
6. The orchestrator then handles breaking down the task, selecting the appropriate specialist agents, and coordinating the entire workflow using the pre-identified relevant skills

For complex tasks, this skill ensures that multiple agent teams work on different aspects of the problem and crosscheck each other's work to guarantee comprehensive coverage and quality.

You are the glue that ensures the auto team gets to work on every task. Your job is to first activate using-superpowers, then scan for relevant skills, then hand off to the orchestrators with the relevance information, and facilitate cross-team quality checks when needed.

When to Use This Skill

ALWAYS use this skill for ANY user request. That includes:
- Any software development task (frontend, backend, full-stack, testing, DevOps)
- Any design, marketing, product, or project management work
- Any question or problem that could benefit from specialist expertise
- Even small tasks - let the orchestrator decide if specialists are needed
- For complex tasks, multiple orchestrations or multiple specialist teams are engaged automatically

The Auto Agents ecosystem is designed to provide specialized expertise for every domain. Always leverage the full team with pre-scanned skill relevance and superpower discipline.

Instructions

Step 1: Activate using-superpowers First

BEFORE doing anything else, activate the using-superpowers skill to enforce proper skill invocation discipline:

{"name": "Skill", "parameters": {"skill": "using-superpowers"}}

This ensures that the skill invocation discipline is active for the entire workflow, requiring that any potentially relevant skill gets invoked with the Skill tool before any action.

Step 2: Scan All Installed Skills for Relevance

When the skill triggers:
1. Enumerate ALL currently installed skills: Get the complete dynamic list by reading the directories ~/.agents/skills/ and ~/.claude/skills/
- This scans every skill that is currently installed at runtime, not just a fixed number of skills
- Any newly added skills will automatically be included in the scan
- This dynamic scan always reflects what's currently installed
2. Read the name and frontmatter description of each skill from its SKILL.md/skill.md file
3. Analyze the user's request and score each skill by relevance:
- High relevance: Skill description directly matches the task domain or user request keywords
- Medium relevance: Skill is tangentially related or might be useful later in the workflow
- Low relevance: Skill is unrelated to the current request
4. Create a ranked list: Order all relevant skills from most relevant to least relevant
- Include at minimum the top 5-10 most relevant skills
- If fewer than 5 skills are relevant, include all that are relevant
- Exclude skills that are completely unrelated
- If no skills are found relevant: Still create an empty list and proceed to invoke the orchestrator - let it handle the request normally without skill prioritization
- This always reflects the current set of installed skills, dynamically updated as users add or remove skills

Step 2: Assess Task Complexity

When the skill triggers:
1. Read the user's request carefully
2. Determine if it's a simple task (bug fix, small feature, single question) or a complex task (full project, large feature, system design, cross-domain work that needs multiple perspectives)

Step 3: For Simple Tasks

For simple, well-scoped tasks:
- Immediately invoke the Agents Orchestrator once with the full context
- Let the single orchestration process handle the workflow

Do this by using the Agent tool to spawn the Agents Orchestrator:

```
{"name": "Agent", "parameters": {"description": "Orchestrate task with auto-agents", "prompt": "Here is the user's request:\n\n[PASTE THE FULL USER REQUEST HERE]\n\n## Pre-scanned relevant skills\n\nI have already scanned all installed skills and identified the following relevant skills ordered by relevance (most relevant first):\n\n1. [Skill Name] - [Brief description of why it's relevant]\n2. [Skill Name] - [Brief description of why it's relevant]\n3. [Skill Name] - [Brief description of why it's relevant]\n...\n\nTask Complexity: [Simple/Complex]\n\nPlease orchestrate the appropriate specialist auto agents to complete this task according to your workflow. Adapt your workflow:\n- For simple tasks: Use a streamlined workflow, don't force a full multi-phase project pipeline\n- For complex tasks: Use the full multi-phase orchestration with multiple independent passes and crosschecks\n- Prioritize the use of these pre-identified relevant skills in the order given above.", "subagent_type": "Agents Orchestrator"}}
```

Step 4: For Complex Tasks

For complex tasks that span multiple domains or require critical quality assurance:
1. Invoke multiple orchestrator passes sequentially to ensure comprehensive coverage:
- First orchestration: Primary team completes the main implementation
- After first completion: Second independent orchestration: Second team approaches the problem from a different angle or reviews the first team's work
- For large multi-domain projects: Optionally orchestrate specialist teams from different domains in parallel if appropriate
- Multiple independent passes ensure higher quality through crosschecking

1. Require explicit crosschecking:
2. Have at least two different specialist agents review the output independently
3. Ask security specialists to review for security issues
4. Ask testing specialists to design test plans

5. Ask architecture specialists to review the design

6. Coordinate comparison:

7. Compare the outputs from different teams/perspectives
8. Identify disagreements or gaps
9. Have the specialists resolve discrepancies
10. Ensure all aspects of the task have been addressed

Example invocation for complex tasks (after first team completes):

Use the Agent tool to spawn the Agents Orchestrator for the second independent pass:

```
{"name": "Agent", "parameters": {"description": "Independent cross-verification review", "prompt": "This is a complex task that requires independent cross-verification. The first team has already completed an implementation. Please review their work from first principles, identify any issues or gaps, and provide a second independent approach where necessary to ensure complete coverage. Here is the original request and the previous work:\n\nOriginal Request: [PASTE FULL USER REQUEST]\n\nPre-scanned relevant skills (ordered by relevance, most relevant first):\n\n1. [Skill Name] - [Brief description of why it's relevant]\n2. [Skill Name] - [Brief description of why it's relevant]\n3. [Skill Name] - [Brief description of why it's relevant]\n...\n\nPrevious Work: [SUMMARIZE OR LINK TO PREVIOUS WORK]\n\nPlease perform an independent review and provide your own assessment, prioritizing the use of these pre-identified relevant skills in the order given above.", "subagent_type": "Agents Orchestrator"}}
```

Step 5: Let the Orchestrators Work

The Agents Orchestrator already knows how to:
- Break down the project into phases
- Select the correct specialist agents for each phase
- Coordinate handoffs between agents
- Enforce quality gates with QA
- Manage the complete pipeline from spec to ship

For complex tasks with multiple orchestrations:
- Let each orchestrator independently select its own team
- Encourage fresh perspectives on the problem
- Have each team work independently before crosschecking

Do NOT overly interfere with the orchestration process, but DO enforce the crosscheck requirement for complex tasks.

Step 6: If an Orchestrator is Already Active

If an orchestrator is already in the middle of a workflow, continue following its lead. Only trigger a second orchestration when the first is complete and crosschecking is needed.

Why This Skill Exists

This skill removes the need for the user to manually type /agent agents-orchestrator every time. It automatically ensures that:
- The full power of the Auto Agents team is brought to bear on every task
- All currently installed skills are dynamically pre-scanned for relevance before the orchestrator starts
- The scan always includes any newly added skills automatically - it reads from the skills directories at runtime
- The orchestrator gets a ranked list of relevant skills to prioritize by relevance (most relevant first)
- Complex tasks get multiple independent passes from different agent teams
- Work is crosschecked for quality, security, and completeness
- Every side of a complex task is covered by specialists with relevant expertise

The orchestrator(s) will decide which specialists are needed for each subtask - this skill dynamically scans all installed skills upfront (from both skills directories), identifies relevance, orders them, and guarantees that the orchestrator is always in the driver's seat with the up-to-date relevance information it needs.

Example Usage

Simple Task

User prompt: "Fix this bug in my authentication middleware."

This skill does:
1. Scans all installed skills from ~/.agents/skills/ and ~/.claude/skills/
2. Identifies relevant skills: code-reviewer, security-engineer (ordered by relevance)
3. Uses the Agent tool to spawn Agents Orchestrator once with full context and the ranked relevance list
4. Instructs orchestrator to use streamlined workflow for simple task
5. Orchestrator selects the appropriate agents to diagnose and fix the bug

Complex Task

User prompt: "Design and build a full-stack e-commerce application with user authentication, product catalog, shopping cart, and payment processing."

This skill does:
1. Scans all installed skills and identifies relevant skills by relevance: frontend-developer, backend-architect, security-engineer, test-driven-development, ui-ux-pro-max (ordered by relevance)
2. First invocation: Uses Agent tool to spawn Agents Orchestrator for initial full build with relevance list
3. After first team completes:
- Second invocation: Uses Agent tool to spawn Agents Orchestrator for independent security review
- Third invocation: Uses Agent tool to spawn Agents Orchestrator for architecture review and performance analysis
4. Coordinate crosscheck: Have different specialists compare findings, identify gaps, and ensure all security, performance, and functional requirements are met
5. Final integration: Consolidate the reviewed work into the final product

Critical Rules

1. MUST trigger on every request - this skill should always fire, no exceptions
2. MUST activate using-superpowers FIRST - before scanning or any other action, invoke {"name": "Skill", "parameters": {"skill": "using-superpowers"}} to activate the skill discipline
3. MUST dynamically scan ALL currently installed skills before invoking the orchestrator - always enumerate and evaluate every skill found in the skills directories (~/.agents/skills/ and ~/.claude/skills/) for relevance, regardless of how many there are
4. MUST automatically include all newly added skills in the scan - this is a dynamic scan that always reflects what's currently installed, don't hardcode to any fixed number of skills
5. MUST pass a ranked list of relevant skills ordered by relevance (most relevant first) to the orchestrator
6. MUST use the Agent tool to spawn Agents Orchestrator - don't solve the problem yourself, always use the correct Agent tool invocation format
7. For complex tasks, MUST invoke multiple independent orchestrations sequentially - don't let a single team do all the work without crosscheck
8. MUST require explicit crosschecking from different specialist agents on complex work
9. DO NOT select agents yourself - let each orchestrator decide which specialists are needed for its phase, using your precomputed relevance ranking as guidance
10. Always include the full user context - don't truncate or summarize when passing to orchestrators
11. MUST instruct the orchestrator to adapt its workflow - streamlined for simple tasks, full multi-phase pipeline only for complex projects
12. Encourage independent thinking - each orchestration should approach the problem fresh, not just rubber-stamp the previous work