spawn

Overview of spawn skill

What spawn does

spawn is an AgentHub skill for launching multiple parallel coding agents against the same session task. Instead of asking one assistant to solve a problem sequentially, the spawn skill creates N subagents in isolated git worktrees so they can compete with different strategies without overwriting each other’s changes.

Use it when you have an initialized AgentHub session and want parallel exploration for implementation, refactoring, testing, optimization, or bug-fixing work.

Best fit for Agent Orchestration

spawn for Agent Orchestration is most useful when the task has more than one plausible solution path. It fits teams or solo developers who want agents to explore alternatives, compare outputs, and reduce the risk of anchoring on the first implementation.

Good candidates include performance tuning, large refactors, flaky bug investigations, missing test coverage, and code changes where independent approaches can reveal tradeoffs.

What makes this spawn skill different

The key differentiator is isolation plus structured competition. Each agent works in its own git worktree, which keeps parallel edits separate and makes later comparison safer. The skill also supports templates such as optimizer, refactorer, test-writer, and bug-fixer, so dispatch prompts can match the kind of engineering task instead of using a generic “solve this” instruction.

Adoption considerations

This skill assumes you are already using the surrounding AgentHub workflow. It is not a standalone package that simply runs from any repository with no setup. The repository path only contains SKILL.md, so users should expect the skill definition to depend on adjacent AgentHub conventions and references, including session configuration and template files outside the skill folder.

How to Use spawn skill

spawn install context

Install the skill from the source repository with:

npx skills add alirezarezvani/claude-skills --skill spawn

After installation, confirm that your environment supports AgentHub commands and that a session has already been initialized. The command exposed by the skill is:

/hub:spawn

The spawn install decision should be based on whether you need coordinated parallel agents, not just another prompt shortcut. If your workflow does not use git worktrees or session-based orchestration, review the broader AgentHub setup before relying on this skill.

Basic spawn usage

Common command forms are:

/hub:spawn
/hub:spawn 20260317-143022
/hub:spawn --template optimizer
/hub:spawn --template refactorer

Use /hub:spawn for the latest session. Pass a session ID when you need to target a specific AgentHub session. Add --template <name> when the task benefits from a specialized operating pattern.

Supported template intent from the skill includes:

• optimizer: repeated edit/evaluate/keep-or-discard cycles
• refactorer: restructure, test, and iterate until green
• test-writer: add tests and measure coverage improvement
• bug-fixer: reproduce, diagnose, fix, and verify

Inputs that improve agent output

A strong spawn usage prompt starts before the command: the session task should be specific enough for multiple agents to act independently and compare results. Include the target files, acceptance criteria, test commands, constraints, and what “better” means.

Weak session goal:

Improve the API code.

Stronger session goal:

Refactor the user lookup API to reduce duplicate database calls without changing response shape.
Focus on src/api/users.ts and src/services/user-cache.ts.
Run npm test -- users and npm run lint.
Preserve public types. Prefer minimal changes unless an agent can prove a cleaner design with tests.

This gives spawned agents a shared target while leaving room for different strategies.

Files to read before running

Start with SKILL.md in engineering/agenthub/skills/spawn. Then inspect the neighboring AgentHub materials referenced by the skill, especially any session setup docs and agent-templates.md if available in the installed repository. The most important details to verify are how sessions are named, how N agents are chosen, where worktrees are created, and how final comparison or merge selection is handled.

spawn skill FAQ

When should I use spawn instead of a normal prompt?

Use spawn when parallel exploration has real value. A normal prompt is usually enough for small edits, documentation changes, or tasks with one obvious answer. The spawn skill is better when different implementation strategies, test designs, or debugging hypotheses could lead to meaningfully different outcomes.

Is spawn beginner-friendly?

It is beginner-friendly only if you already understand the surrounding AgentHub workflow and basic git worktree behavior. The command itself is simple, but the operational model is more advanced: multiple agents will produce separate changes that need review, testing, and selection.

What can block successful spawn usage?

The main blockers are an uninitialized AgentHub session, unclear task definition, missing test commands, and repositories that are not safe for parallel worktree changes. Another limitation is that the skill folder is minimal; the useful orchestration context lives in the broader AgentHub system, so do not evaluate it as a fully self-contained tool.

When is spawn the wrong choice?

Avoid spawn for secrets handling, irreversible production operations, tiny one-line fixes, or tasks where duplicated agent effort creates noise rather than insight. It is also a poor fit when you cannot run tests or compare outputs, because the value of parallel agents depends on evidence-based selection.

How to Improve spawn skill

Make spawn prompts more comparable

To get better results from spawn, define success metrics that every agent can optimize against. Good comparison criteria include passing tests, reduced runtime, smaller diff size, clearer API boundaries, improved coverage, or reproduced bug evidence. Without shared criteria, parallel outputs become hard to judge.

Assign diverse strategies intentionally

The skill’s template guidance is strongest when each agent receives a different strategy. For a bug fix, one agent might start from reproduction, another from recent git history, and another from boundary-condition tests. For optimization, one might reduce allocations, another might cache, and another might change algorithmic complexity. Diversity is the point of the spawn skill.

Avoid common failure modes

Common failures include spawning agents on vague goals, letting all agents follow the same plan, skipping verification, and merging the largest-looking solution instead of the best-supported one. Keep the task bounded, require test commands, and ask agents to summarize their approach, tradeoffs, files changed, and verification results.

Iterate after the first spawn run

After the first run, compare worktrees before merging. Keep the strongest candidate, discard weak branches, or run a second spawn round using what you learned. A useful follow-up instruction is:

Use the best result from agent 2 as the baseline.
Spawn new agents to improve reliability and reduce diff size.
All agents must preserve the public API and run the same test command.

That turns spawn from a one-shot competition into a practical agent orchestration loop.