> ## Documentation Index
> Fetch the complete documentation index at: https://hubify.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Skills Overview

> Hubify Skills are bring-your-own-agent recipes that turn Claude Code, Codex, or Cursor into a Hubify-aware research IDE, without ever installing the dedicated Hubify CLI.

# Skills Overview

A **Skill** is a single markdown file that teaches your local AI agent (Claude Code, Codex, Cursor, anything that reads system prompts or MCP servers) how to do one specific thing inside a Hubify lab. Drop it into your agent's skills directory, type `/skill-name`, and the agent runs the recipe end-to-end against your live Convex data.

Skills are the answer to the question Captain (the researcher) actually asks: "I already use Claude Code / Cursor / Codex every day. Why do I need a separate Hubify CLI?" Short answer: you don't. Skills give your existing agent the same powers the dedicated `hubify` CLI has, just packaged as `/slash-commands` your agent already understands.

## Why skills exist

The dedicated `hubify` CLI is great when you want a deterministic, scriptable surface (`hubify experiment run --pod h100`, `hubify paper publish`, `hubify status`). But most research work is conversational, exploratory, and already happens inside an AI coding session. Skills meet you where you are:

* **No new tool to install.** If you have Claude Code, Cursor, or Codex working today, you're 60 seconds from `/hubify-status` returning real data.
* **Git-tracked, reviewable, forkable.** Skills are markdown. Commit them to your lab repo. Share with collaborators. Fork to override behavior for your domain.
* **Composable with existing skills.** Run `/hubify-experiment-queue` then `/review` (your normal code-review skill) on the experiment script before it dispatches to a GPU.

Skills wrap the **MCP server** (which already exposes raw tools like `experiment_list`, `knowledge_search`) with opinionated, Captain-friendly prompts. The MCP server is the "API layer"; skills are the "user interface."

<Note>
  **Hat-tip:** the skills format and authoring workflow here is heavily inspired by [gstack](https://garryslist.org/posts/gstack), Garry Tan's open-source skills library for Claude Code. If you've used `/qa`, `/review`, or `/ship` from gstack, the Hubify skills will feel identical.
</Note>

## What ships today

| Skill                      | What it does                                                                  | Agents            |
| -------------------------- | ----------------------------------------------------------------------------- | ----------------- |
| `/hubify-status`           | Lists labs, shows active lab, last 5 agentEvents (read-only, safe everywhere) | CC, Cursor, Codex |
| `/hubify-experiment-queue` | Wraps `experiments.queue` mutation with hypothesis prompt + priority picker   | CC, Cursor, Codex |
| `/hubify-runpod`           | Starts/stops a GPU pod with cost confirmation gate                            | CC, Cursor, Codex |
| `/hubify-knowledge-add`    | Captures a finding into the lab knowledge base with auto-tag suggestions      | CC, Cursor, Codex |
| `/hubify-paper-readiness`  | Checks paper draft against the 5-round publish-ready loop                     | CC, Cursor, Codex |

More are queued in the [polish loop](https://github.com/houstongolden/hubify/blob/main/project-context/POLISH_LOOP.md). If you want one we don't ship, it's a 30-line markdown file, see [Authoring a skill](/skills/authoring).

## Install path

The fastest path is the MCP server (gives all skills access to your lab data) plus dropping the skill files into your agent's skills directory.

<CardGroup cols={3}>
  <Card title="Claude Code" icon="terminal" href="/integrations/claude-code">
    `claude mcp add hubify ...` then drop skills in `~/.claude/skills/`
  </Card>

  <Card title="Cursor" icon="code" href="/integrations/cursor">
    `.cursor/mcp.json` for tools, `.cursor/rules/*.mdc` for skills
  </Card>

  <Card title="Codex / others" icon="robot" href="/skills/bring-your-own-agent">
    Any agent that reads MCP servers + system prompts works
  </Card>
</CardGroup>

## Skill anatomy

Every Hubify skill is a single `SKILL.md` with frontmatter and a body. The body is a prompt the agent reads and executes step by step.

```markdown theme={null}
---
name: hubify-status
description: List labs, show active lab, last 5 agentEvents
---

# /hubify-status

1. Call `lab_list` (MCP tool). Print the labs as a numbered list. Mark the active one (matches `--lab` flag).
2. Call `experiment_list --lab <active>` and `agent_event_list --lab <active> --limit 5`.
3. Render in a single table: lab name, # experiments running, last 5 events with relative timestamps.
4. If any lab returns 0 experiments AND 0 events in the last 24h, suggest `/hubify-experiment-queue`.
```

That's the entire skill. The agent does the rest. No SDK, no Python, no JSON schemas. Just a recipe written for the agent the same way you'd write one for a junior researcher.

## See also

* [Bring your own agent](/skills/bring-your-own-agent), make this work with Codex, Cline, or anything else
* [Authoring a skill](/skills/authoring), write your own
* [MCP Server overview](/mcp/overview), the tool layer skills build on
* [Claude Code integration](/integrations/claude-code), fastest path
* [Cursor integration](/integrations/cursor), IDE-native