run is an AgentHub orchestration skill for Claude that triggers /hub:run to initialize a task, spawn agents, evaluate results, and merge the winner. Use it for measurable code improvements or judged creative comparisons with clear task, agent, eval, metric, direction, and template parameters.
This skill scores 70/100, which means it is acceptable for listing but best suited to users already adopting the AgentHub workflow. Directory users get a clear command trigger, examples, and the intended end-to-end lifecycle value, but the repository evidence is thin beyond `SKILL.md` and does not fully document dependencies, installation, or operational edge cases.
- Clear triggerability: frontmatter defines `command: /hub:run` and the description says to use it for `/hub:run` or full AgentHub competition execution.
- Provides concrete usage examples for optimization, refactoring, test coverage, and LLM judge scenarios.
- Gives a meaningful lifecycle workflow by chaining initialization, baseline capture, agent spawning, evaluation, and winner merge into one agent-invokable command.
- Depends on the broader AgentHub command set (`/hub:init`, baseline, spawn, eval, merge), but this skill directory entry only includes `SKILL.md` and no supporting references or install guidance.
- Parameter behavior is documented at a high level, but edge cases, failure handling, metric extraction format, and judge-mode details are not evident from the repository evidence.
Overview of run skill
What the run skill does
run is an AgentHub orchestration skill for Claude that exposes the /hub:run command. It executes a full competition-style lifecycle in one request: initialize the task, capture a baseline, spawn multiple agents, evaluate their outputs, and merge the winning result. Use it when you want an agentic workflow to compare several solution attempts instead of asking for one direct answer.
Best fit for AgentHub users
The run skill is best for teams already using the AgentHub command pattern and wanting a single high-level entry point for multi-agent execution. It fits engineering tasks such as performance optimization, refactoring, test generation, bug fixing, and measurable code improvements. It can also support non-code creative selection when you use judge mode, such as choosing the best marketing copy from several candidates.
Main decision point before install
Install run if you want a repeatable command that chains the AgentHub lifecycle without manually calling /hub:init, baseline capture, agent spawning, evaluation, and merge steps. Do not treat it as a general automation runner: its value depends on having a task that can be evaluated or judged, plus an AgentHub environment where the related commands are available.
Key differentiator
Unlike an ordinary prompt that asks Claude to “try several approaches,” /hub:run gives the agent a structured lifecycle with explicit parameters: task, number of agents, optional eval command, metric, optimization direction, and template. That structure makes the result easier to compare, audit, and merge.
How to Use run skill
run install and repository check
Install the skill from the repository with your skill manager, for example:
npx skills add alirezarezvani/claude-skills --skill run
Then inspect the upstream file first:
engineering/agenthub/skills/run/SKILL.md
This repository path contains the core behavior and examples. There are no visible companion scripts/, resources/, references/, or rules/ folders for this skill in the provided tree, so adoption depends mainly on understanding the command contract in SKILL.md and having the wider AgentHub command set available.
Basic run usage pattern
The command format is:
/hub:run --task "..." --agents 3 --eval "..." --metric metric_name --direction lower --template optimizer
Important parameters:
--task: required; the exact job agents should compete on.--agents: optional; defaults to 3 in the source examples.--eval: optional; command used to measure results.--metric: required when using--eval; the value to compare.--direction: required when comparing a metric; uselowerorhigher.--template: optional; examples includeoptimizer,refactorer,test-writer, andbug-fixer.--judge: useful when there is no deterministic metric and an LLM judge should compare outputs.
Turn a rough goal into a strong command
A weak request is:
/hub:run --task "make it faster"
A stronger run usage prompt is:
/hub:run --task "Reduce p50 latency in the product search endpoint without changing response schema" --agents 3 --eval "pytest bench.py --json" --metric p50_ms --direction lower --template optimizer
This version improves output quality because it defines the target area, preserves a constraint, gives the agents a measurable benchmark, names the metric, and states which direction wins. For coverage work, use a higher-is-better metric:
/hub:run --task "Add tests for untested utils without modifying production behavior" --agents 3 --eval "pytest --cov=utils --cov-report=json" --metric coverage_pct --direction higher --template test-writer
Suggested workflow before merging
Before using the run skill on important code, make sure the repository is clean, tests are reproducible, and the eval command returns machine-readable or consistently parseable output. Start with 2–3 agents for cost and speed control. Use deterministic evals for code whenever possible, and reserve --judge for subjective outputs such as copywriting or design alternatives. After the winner is merged, still review the diff manually; the skill orchestrates selection, but it does not replace code ownership.
run skill FAQ
Is run for Agent Orchestration or simple prompting?
run is for Agent Orchestration. It is designed to coordinate multiple agents through a lifecycle and select a winner. If you only need one explanation, one refactor suggestion, or one draft, a normal prompt is simpler. Use the run skill when comparison, evaluation, and merge discipline matter.
What must already exist for run to work well?
You need an AgentHub-compatible setup where /hub:run and the related lifecycle commands can be recognized. For measurable software tasks, you also need a reliable eval command, a clear metric name, and a known optimization direction. Without those, the command may still run in judge mode, but the outcome is less objective.
When should I avoid this skill?
Avoid run for vague tasks with no acceptance criteria, destructive changes without a rollback plan, or projects where tests and benchmarks are flaky. Also avoid using too many agents by default; more agents can increase cost and review burden without improving quality if the task definition is weak.
Is the run skill beginner-friendly?
It is approachable if you already understand command-style Claude skills and basic AgentHub concepts. Beginners may struggle with the eval parameters, especially --metric and --direction. Start with judge mode for low-risk creative tasks or use a simple test command before attempting performance, refactoring, or merge-heavy workflows.
How to Improve run skill
Improve run results with better task boundaries
The run skill performs best when the task is narrow enough for agents to complete independently. Include the target files, expected behavior, constraints, and what must not change. For example, “Refactor auth module” is acceptable, but “Refactor src/auth/session.ts to reduce duplication while preserving public function signatures and existing tests” gives agents a safer operating box.
Strengthen evals and metrics
For code tasks, the eval command is the most important quality lever. Prefer commands that fail clearly and produce a stable metric. Pair the metric with the correct direction: latency and error count usually use lower; coverage, throughput, or score usually use higher. If the eval output is ambiguous, the merge decision can become unreliable even when the agents produced useful work.
Watch common failure modes
Common failure modes include overbroad tasks, missing metrics, flaky test suites, judge-mode decisions on tasks that should be measured, and templates that do not match the job. Use optimizer for measurable performance improvement, test-writer for coverage, refactorer for structure-preserving cleanup, and bug-fixer for defect repair. A mismatched template can push agents toward the wrong kind of solution.
Iterate after the first output
After the first /hub:run, inspect the winning diff and the losing approaches. If none are acceptable, do not simply rerun the same command. Tighten the task, add constraints, improve the eval, or reduce scope. If the winner is close but incomplete, run a follow-up command focused only on the missing issue instead of restarting the full lifecycle.