Skip to main content
skill CX Codex

help · yonatangross — Claude Code skill: what it does, how to install

This skill scans the installed OrchestKit skills and sorts them into categories. It helps you find the workflow or skill that matches a task.

MIT 166 installs ★ 305 updated 2026-11-07

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add yonatangross/orchestkit --skill help -a claude-code
Open on GitHub

What help does

help builds a live directory of the OrchestKit skills available in the current installation. It reads each matched file’s frontmatter, then collects its name, description, version, complexity, argument hint, and tags. The results are grouped into areas such as build, git, plan, quality, memory, config, explore, design, and ops.

With no argument, the skill asks you to choose a broad task group through AskUserQuestion. Passing build, git, or all selects a listing mode directly. Discovery uses Grep, Read, and Glob; the installed plugin is checked through ${CLAUDE_PLUGIN_ROOT}/skills, with src/skills used as the repository fallback. Claude Code 2.1.277+ is required.

Each entry includes its command, version, complexity, description, and an argument example. The all mode prints every user-invocable skill and derives the final count from the files it found.

What it helps with

  • find a skill by task category
  • list the OrchestKit commands available in the installation
  • filter skills for build or git work
  • show every user-invocable skill
  • compare a task with a skill description and example

Example prompts for the agent

  • Run /ork:help and show the available skill categories.
  • Run /ork:help build and list skills for implementation work.
  • Run /ork:help all and print every user-invocable skill.

How to install help

1Skills CLI (Vercel)

npx skills add yonatangross/orchestkit --skill help -a claude-code

2Manually: put the files in place

~/.claude/skills/help/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/help/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about help

How do I install help in Claude Code?

Run npx skills add yonatangross/orchestkit --skill help -a claude-code, then use ~/.claude/skills/help/SKILL.md.

What does the help skill do?

It discovers the installed OrchestKit skills at runtime, groups them by category, and displays their descriptions, versions, complexity, and invocation examples.

Which Claude Code versions support help?

The skill supports Claude Code 2.1.277+.

Source text

SKILL.md · MIT
---
name: help
license: MIT
compatibility: "Claude Code 2.1.277+."
description: "OrchestKit skill directory by category. Use when looking for the right skill or workflow."
argument-hint: "[category]"
context: inherit
user-invocable: true
allowed-tools: "AskUserQuestion Read Grep Glob"
effort: low
model: haiku
metadata:
  category: document-asset-creation
  version: "2.1.0"
  author: "OrchestKit"
  complexity: "low"
  tags: "help, documentation, skills, discovery, meta"
triggers:
  keywords: [help, "what skills", "skills can i", "available commands", "which skill", "show me skills", "ork commands", "what can", "whats ork", "skill for"]
  examples:
    - "what orchestkit skills can i use"
    - "show me the available ork commands"
    - "help me find the right skill for code review"
  anti-triggers: [fix, implement, doctor, setup, explore, assess]
---

# OrchestKit Skill Directory

Dynamic skill discovery: enumerates the installed plugin at runtime so listings are never stale.

> **CC 2.1.121+ tip:** if you just want to find one skill quickly, the native `/skills` command now has type-to-filter — open it and start typing the skill name. Use `help` when you want categorized browsing or rationale for *why* a skill applies.

## Quick Start

```bash
help           # Show all categories
help build     # Show BUILD skills only
help git       # Show GIT skills only
help all       # List every user-invocable skill
```

## Argument Resolution

```python
CATEGORY = "$ARGUMENTS[0]"  # Optional: build, git, plan, quality, memory, config, explore, design, ops, all
# If provided, skip AskUserQuestion and show that category directly.
# $ARGUMENTS is the full string (CC 2.1.59 indexed access)
```

---

## STEP 0: Dynamic Skill Discovery

**ALWAYS run this first** to get accurate, up-to-date skill data:

```python
# ${CLAUDE_PLUGIN_ROOT} is set by the plugin runtime and points at the INSTALLED
# plugin. That is the normal case: a marketplace user has no src/ directory.
SKILLS_ROOT = "${CLAUDE_PLUGIN_ROOT}/skills"
matches = Grep(pattern="user-invocable:\\s*true", path=SKILLS_ROOT, output_mode="files_with_matches")

# Dogfooding fallback: inside the OrchestKit repo itself the skills live in the
# source tree. Retry there if the env var was unset or the probe found nothing.
if not matches:
    SKILLS_ROOT = "src/skills"
    matches = Grep(pattern="user-invocable:\\s*true", path=SKILLS_ROOT, output_mode="files_with_matches")
```

If BOTH probes return zero files, say so plainly ("could not locate the OrchestKit
skills directory, checked `${CLAUDE_PLUGIN_ROOT}/skills` and `src/skills`") and stop.
Do NOT substitute a remembered list of skill names. Any such list is stale by
construction and a confident wrong answer is worse than no answer.

For each matched file, read the frontmatter to get name, description, version,
complexity, `argument-hint` and tags:

```python
Read(file_path=f"{SKILLS_ROOT}/{skill_dir}/SKILL.md", limit=25)
```

Every number rendered later is derived from this scan, never typed as a literal:

```python
TOTAL = len(matches)   # user-invocable skill count
```

Build the skill list dynamically. **Never hardcode counts or skill names.**

---

## STEP 1: Category Selection

If CATEGORY argument provided, skip to STEP 2 with that category.

Otherwise, present categories interactively:

```python
AskUserQuestion(
  questions=[{
    "question": "What type of task are you working on?",
    "header": "Category",
    # 4-option cap (CC schema): every category from STEP 2 is grouped into one of
    # 3 buckets + "Show all". STEP 2 renders the constituent categories for the
    # picked bucket. Descriptions name intents, never skills, so they cannot drift.
    "options": [
      {"label": "Build & ship", "description": "Writing code, tests, git and PRs, UI and design work"},
      {"label": "Plan & assess", "description": "Requirements, planning, quality assessment, review"},
      {"label": "Explore & operate", "description": "Codebase exploration, memory, setup, diagnostics, CI"},
      {"label": "Show all", "description": "List every user-invocable skill"}
    ],
    "multiSelect": false
  }]
)
```

---

## STEP 2: Render Category

For the selected category, render the skill table from the data gathered in STEP 0.

### Category Definitions

Categories are defined by **tag predicates**, never by a list of skill names, so a
newly shipped skill lands in the right bucket without editing this file. Match each
discovered skill's frontmatter `tags` against the sets below (case-insensitive, one
hit is enough):

| Category | CLI arg | Matches any of these tags |
|----------|---------|---------------------------|
| BUILD | `build` | implementation, feature, testing, coverage, test-generation, verification, e2e |
| GIT | `git` | git, github, commit, pull-request, pr, issue, bug-fix |
| PLAN | `plan` | planning, ideation, prd, requirements, visualization |
| QUALITY | `quality` | quality, assessment, evaluation, code-review, validation, grading |
| MEMORY | `memory` | memory, decisions, graph-memory, consolidation |
| CONFIG | `config` | setup, configuration, onboarding, diagnostics, health-check, dev-loop |
| EXPLORE | `explore` | exploration, codebase, code-search, architecture, discovery |
| DESIGN | `design` | design, design-context, design-tokens, design-to-code, frontend, ui, components, stylecards |
| OPS | `ops` | ci, automation, telemetry, observability, release, migration |
| OTHER | (none) | anything the rows above did not match |

A skill matching two categories is listed under both. That is expected, not a bug.
OTHER is what makes the totals reconcile: every skill found in STEP 0 must appear
somewhere in a full listing, so a skill nobody has categorized yet still shows up.

The STEP 1 picker only offers **3 buckets** (the AskUserQuestion schema caps a
question at 4 options). Each bucket renders the union of its categories:

| Picker bucket | Renders categories |
|---------------|--------------------|
| Build & ship | BUILD + GIT + DESIGN |
| Plan & assess | PLAN + QUALITY |
| Explore & operate | MEMORY + CONFIG + EXPLORE + OPS + OTHER |

For each skill in the category, render:

```
/ork:{name}  v{version}  {complexity}
  {description}
  Example: /ork:{name} {argument-hint example}
```

### "Show all" — Full Listing

If user picks "Show all", render ALL user-invocable skills grouped by category from
STEP 0 data, then close with the derived total: `{TOTAL} user-invocable skills`.
Print `TOTAL` from `len(matches)`. Never type a number you did not just count.

---

## CC Built-in Commands (2.1.72+)

Not OrchestKit skills — these are Claude Code built-ins:

| Command | Description | Since |
|---------|-------------|-------|
| `/code-review` | Review changed code for correctness bugs at a chosen effort level; `--comment` posts inline PR comments (renamed from `/simplify` in 2.1.146; the old cleanup-and-fix behavior was removed) | CC 2.1.146 |
| `/help` | Claude Code built-in help | CC 2.1.0+ |
| `/config` | Claude Code configuration | CC 2.1.0+ |
| `/clear` | Clear conversation (preserves background agents) | CC 2.1.72 |
| `/fast` | Toggle fast mode (same model, faster output) | CC 2.1.59+ |
| `/loop` | Recurring interval (e.g. `/loop 5m /foo`) | CC 2.1.71 |
| `/plan` | Enter plan mode (CC 2.1.222 removed the ultraplan feature, so `/ultraplan` and the "Refine with Ultraplan" hand-off no longer exist) | CC 2.1.72 |
| `/team-onboarding` | Generate teammate ramp-up guide | CC 2.1.101 |
| `/recap` | Session context restoration after idle | CC 2.1.108 |
| `/undo` | Alias for `/rewind` | CC 2.1.108 |
| `/skills` | Native skill picker — type to filter | CC 2.1.121 |
| `/effort` | Reasoning effort — sets `$CLAUDE_EFFORT` env for skills | CC 2.1.72 (env var since 2.1.120) |
| `/cd` | Move session to a new working directory without breaking the prompt cache | CC 2.1.169 |
| `--safe-mode` | Start with ALL customizations disabled (troubleshooting bisect) | CC 2.1.169 (flag/env, not a slash command) |

## Performance Tips

- **`ENABLE_PROMPT_CACHING_1H=1`** — Extends prompt cache TTL from 5 min to 1 hour. Set this for long sessions with multi-phase skills (brainstorm, implement, cover). Available on API key, Bedrock, Vertex, Foundry.
- **`/recap`** — Restores session context after stepping away. Complements OrchestKit's checkpoint-resume for chain recovery.

## Keyboard Shortcuts

| Shortcut | Action |
|----------|--------|
| `Ctrl+F` | Find in session output |
| `Esc` | Cancel / dismiss |
| `Shift+Enter` | Newline in input |
| `Ctrl+C` | Cancel operation |

---

## Pro Tip

You don't need to memorize skills. Just describe your task naturally:

```
"I need to implement user login"     → implement
"Show me the payment architecture"   → explore
"Review PR 123"                      → review-pr
"Is this code good?"                 → assess
"Plan out the billing redesign"      → visualize-plan
```

## Related Skills

- `/help` — Claude Code built-in help
- `doctor` — OrchestKit health check
- `setup` — Full onboarding wizard

© OrchestKit · MIT · yonatangross/orchestkit

Similar skills

All skills for Agent setup: memory, context, orchestration →

help by other authors comes first.

help Donchitos help pinpoints your current game development stage and suggests the next action. Useful when you finish a task or do not know what to do next. CX Codex +1 633installs help parcadei help is a Claude Code skill that interactively maps Continuous-Claude-v3 workflows, agents, hooks, and CLI tools to your current task. CX Codex +1 495installs help bitwize-music-studio help is a Claude Code skill that lists bitwize-music commands and workflows; call it to find a command or check what a tool does. CX Codex +1 253installs parallel-tasks-help qdhenry parallel-tasks-help is a Claude Code command that explains how to run /parallel-tasks, with its options, agent types, and examples. It also covers task systems and coordination stages. CX Codex +1 ★ 1,357repo stars glab-help vince-winkintel This skill explains glab help syntax and guides you through command and subcommand help in the GitLab CLI. CX Codex +1 122installs janitor-discover Krzysztof Hendzel janitor-discover is a Claude Code skill that searches GitHub for skills, compares candidates with local ones, and checks security before installation. CX Codex +1 ★ 140repo stars railway-docs Railway Feeds the agent fresh Railway docs instead of letting it answer from memory. Comes in handy when you ask about deployments, variables or pricing and need accurate details. CX Codex +1 74installs fa-help FortAwesome fa-help — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode that answers Font Awesome questions by fetching the official documentation. Answers come from the live docs, not from the model's training data. CX Codex +1 710installs ae-kb-discovery ThinkingAIAgenticEngine ae-kb-discovery evaluates accessible Agentic Engine knowledge bases and picks relevant sources for business context. Hands off retrieval to the companion skill. CX Codex +1 729installs

From the same set86

The whole set →
mcp-patterns mcp-patterns — a skill for Claude Code and Codex that guides Model Context Protocol server design. Activates when configuring transports, adding OAuth, wiring tool handlers, or hardening MCP security. CX Codex +1 191installs browser-tools browser-tools is a Claude Code skill that adds safety rules for browser automation with agent-browser, including scraping ethics, request pacing, local URLs, and authentication. It runs automatically during browser automation. CX Codex +1 191installs scope-appropriate-architecture scope-appropriate-architecture classifies projects into six tiers and picks patterns that fit their scope, preventing microservices for MVPs. Activates during design and complexity checks. CX Codex +1 179installs storybook-mcp-integration The storybook-mcp-integration Claude Code skill connects Storybook MCP tools to work with existing components. The agent can find component docs, open story previews, and run story tests. CX Codex +1 166installs business-case business-case is a Claude Code skill that calculates ROI, NPV, IRR, payback period and TCO. It runs when an agent builds a financial case or compares build vs buy. CX Codex +1 162installs testing-e2e testing-e2e provides Playwright E2E standards, page object patterns, and axe-core accessibility checks. Activates when editing tests or playwright.config.*. CX Codex +1 160installs interaction-patterns interaction-patterns — a skill for Claude Code supplies UI interaction rules for loading, pagination, overlays and notifications. It comes into play while building these interface behaviors. CX Codex +1 160installs documentation-patterns The documentation-patterns skill provides patterns for READMEs, ADRs, OpenAPI docs, changelogs, and technical writing. Use it when drafting project docs or recording an architecture choice. CX Codex +1 150installs

Project sponsors

Companies that keep this analytics open