Skip to main content
plugin CX Codex

oma — Claude Code plugin: specialist team for your agent

oma is a plugin for Claude Code and Codex that coordinates specialists to break down coding tasks, build in parallel, review results, and fix root causes.

MIT ★ 1,472 updated 2026-10-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add first-fluke/oh-my-agent
/plugin install oma@oh-my-agent
Open on GitHub

What oma does

Plugin provides 12 roles: PM, architect, backend, frontend, mobile, database and infra engineers, QA reviewer, debugger, refactorer, docs curator, researcher. Each role carries its own skills; the agent loads the rest when a task needs them.

21 slash commands start workflows from /brainstorm and /plan to /review, /debug and /scm. Most also start from plain requests: keyword banks in 11 languages. Long workflows check code through your test, lint or typecheck scripts — the agent cannot stop until they pass. Plugin writes plan files, ADRs, API contracts, bug notes, review reports and recaps to .agents/results.

33 skills load on demand: UI, APIs, schemas, Terraform, CI, security, git, observability. There is cited search, market research, slide deck assembly, MP4 videos, images, PDF and HWP to Markdown conversion. One .agents/ directory deploys into config files for 14 runtimes.

What it helps with

  • break a complex task into steps and distribute them among specialists
  • start code review with cited lines that might break
  • fix a failing test by finding the root cause and running checks
  • review system boundaries between an API and a worker
  • run a long workflow that stops only after tests pass

Example prompts for the agent

  • Use /oma:orchestrate to build a TODO app with login
  • Review this PR with /oma:review
  • Add a Terraform S3 bucket — the skill will load by itself

How to install oma

Plugin marketplace

/plugin marketplace add first-fluke/oh-my-agent
/plugin install oma@oh-my-agent

Step by step, with commands for each platform: Claude Code plugins: marketplaces, installing, and building your own

Questions about oma

How to install oma in Claude Code?

First /plugin marketplace add first-fluke/oh-my-agent, then /plugin install oma@oh-my-agent.

What does the oma plugin do?

It adds a team of 12 specialists, 21 workflows, 33 skills, and code checks through test or lint in long tasks.

Which roles are in the oma team?

PM, architect, backend, frontend, mobile, database and infra engineers, QA reviewer, debugger, refactorer, docs curator, researcher.

Source text

SKILL.md · MIT
# oh-my-agent: A Specialist Team for the Coding Agent You Already Use

[![npm version](https://img.shields.io/npm/v/oh-my-agent?color=cb3837&logo=npm)](https://www.npmjs.com/package/oh-my-agent) [![npm downloads](https://img.shields.io/npm/dm/oh-my-agent?color=cb3837&logo=npm)](https://www.npmjs.com/package/oh-my-agent) [![GitHub stars](https://img.shields.io/github/stars/first-fluke/oh-my-agent?style=flat&logo=github)](https://github.com/first-fluke/oh-my-agent) [![License](https://img.shields.io/github/license/first-fluke/oh-my-agent)](https://github.com/first-fluke/oh-my-agent/blob/main/LICENSE) [![Last Updated](https://img.shields.io/github/last-commit/first-fluke/oh-my-agent?label=updated&logo=git)](https://github.com/first-fluke/oh-my-agent/commits/main)

[한국어](./docs/README.ko.md) | [中文](./docs/README.zh.md) | [Português](./docs/README.pt.md) | [日本語](./docs/README.ja.md) | [Français](./docs/README.fr.md) | [Español](./docs/README.es.md) | [Nederlands](./docs/README.nl.md) | [Polski](./docs/README.pl.md) | [Русский](./docs/README.ru.md) | [Deutsch](./docs/README.de.md) | [Tiếng Việt](./docs/README.vi.md) | [ภาษาไทย](./docs/README.th.md)

**oh-my-agent (`oma`) is a vendor-agnostic harness that adds a team of specialists to the coding agent you already use: Claude Code, Codex CLI, Cursor, and 11 more.** A planner breaks the work down, engineers build in parallel, a reviewer checks the result, and a debugger fixes root causes. It also does cited research, slide decks, videos and images. Most steps leave a file you can open, and in the long-running workflows a gate can send the agent back to work until your own `test`, `lint` or `typecheck` script passes.

## Start with your task

Load one skill in your existing coding agent, or install the runtime for project hooks and team workflows.

| Your task | Start here | First request |
|---|---|---|
| [Review AI-written code](./web/docs/tasks/review-ai-code.md) | `bunx skills use first-fluke/oh-my-agent@oma-qa` | "Review this diff for bugs and missing checks. Cite the affected lines." |
| [Design an admin screen](./web/docs/tasks/design-admin-ui.md) | `bunx skills use first-fluke/oh-my-agent@oma-design` | "Review the hierarchy and table density of our admin page." |
| [Fix a failing test](./web/docs/tasks/debug-failing-tests.md) | `bunx skills use first-fluke/oh-my-agent@oma-debug` | "Reproduce this test failure, fix its cause, and run the affected checks." |
| Review system boundaries | `bunx skills use first-fluke/oh-my-agent@oma-architecture` | "Review the boundary between our API and worker." |
| Use project hooks, specialist agents, and workflows | [Install the runtime](#install) | "Use oma-scm to inspect this repository's branch and working tree without edits or remote access." |

Run a `skills use` command through your agent's terminal; it returns the selected instructions and their support directory. These commands load instructions. CLI operations, other skills, project rules, and external services declared by a skill remain separate dependencies. See [Choose a setup](./web/docs/getting-started/choose-setup.md) for the available install paths.

[See a real repair: plugin hooks calling missing files](./web/docs/examples/plugin-hook-repair.md). The example links the changed code, the failure cases, and the regression checks.

[![Oh-My-Agent: A 6+1-Layer Harness Architecture](./docs/assets/architecture/oh-my-agent-architecture.png)](./docs/assets/architecture/oh-my-agent-architecture.svg)

For runtime installation, run this from your project root:

```bash
curl -fsSL https://raw.githubusercontent.com/first-fluke/oh-my-agent/main/cli/install.sh | bash
```

For that runtime installation, run `oma doctor`. [Your first 5 minutes](#your-first-5-minutes) starts with a read-only task before team workflows.

## What you get

**Workflows** are what you type (or just say). They call in **roles**, the specialists. **Skills** are the know-how: each role carries its own, and your agent loads the rest whenever a task needs them.

| | What it gives you | Try it |
|---|---|---|
| **12 specialist roles** | PM, architect, backend, frontend, mobile, database and infra engineers, QA reviewer, debugger, refactorer, docs curator, researcher ([meet them](#meet-the-team)) | `/orchestrate build a TODO app with login` |
| **21 workflows** | Slash commands from `/brainstorm` and `/plan` to `/review`, `/debug` and `/scm`. Most also start from a plain request (keyword banks in up to 11 languages) | "review this PR" |
| **33 skills** | Domain know-how that loads only when a task needs it: UI, APIs, schemas, Terraform, CI, security, git, observability | loads by itself, e.g. "add a Terraform S3 bucket" |
| **Files you can open** | Plans, design docs, API contracts, ADRs, bug notes, per-agent results, security evidence, HTML explainers, recaps | `ls .agents/results` |
| **Workflow checks** | In a long-running workflow, your own `test`, `lint` or `typecheck` script must pass before the agent may stop; `oma ralph verify` checks that a `/ralph` run left its plan, QA and refactor files | `/ultrawork …`, then `oma goal set --gate test` |
| **Research and content** | Cited search, market research, papers, slide decks, MP4 videos, images, local voice, PDF/HWP to Markdown | `/video`, `/convert` |
| **One folder, 14 runtimes** | One portable `.agents/` directory, written into each runtime's own config files | `oma link cursor` |

**[Install](#install)** · **[First 5 minutes](#your-first-5-minutes)** · **[The team](#meet-the-team)** · **[Which workflow?](#how-the-team-works-together)** · **[Everything in the box](#everything-in-the-box)** · **[Works with](#works-with)** · **[Verification](#verification-not-narration)** · **[FAQ](#faq)** · **[Docs](https://firstfluke.com/oh-my-agent/)**

## Install

The script installs [bun](https://bun.sh) if it is missing, installs the `oma` command globally (`bun install --global oh-my-agent`, skipped when `oma` is already on your PATH), then starts the interactive setup. The hooks (keyword detection and the Stop gate) and several workflows call the globally installed `oma` command. The hooks silently do nothing if they cannot find it. If you skip the script, install it yourself with `bun install --global oh-my-agent` (`npm install --global oh-my-agent` or `brew install oh-my-agent` also work).

<details>
<summary>Windows, or without the install script</summary>

```powershell
# Windows (PowerShell)
irm https://raw.githubusercontent.com/first-fluke/oh-my-agent/main/cli/install.ps1 | iex
```

```bash
# Any OS with bun installed: the same setup, plus the global `oma` command
bun install --global oh-my-agent
oma
```

On Windows the installer hides Antigravity, Hermes, and Kimi, and the hook wrapper is a bash script. The default Aside browser MCP installs through `bash`, so deselect it if you have no bash.

</details>

The setup asks for your response language, which agent runtimes to wire up, capability providers, a browser MCP, a model preset, and a skill preset. **Choose `All` for the skill references used across every workflow**: domain presets omit some of those skills. Provider availability and task verification remain separate checks.

Choose a preset explicitly when you want a domain's skills:

```bash
oma install --preset frontend --yes
```

This selects the eight frontend-preset skills. The installer still configures the runtime, providers, and shared workflow files, and retains previously installed skills. Custom selection is available in the interactive installer. See [preset values](./web/docs/getting-started/installation.md#presets) and [workflow dependencies](./web/docs/getting-started/installation.md#workflows-that-need-skills-outside-a-preset).

<details>
<summary>What the installer also does by default</summary>

- Installs **bun** (required). Tries **uv**, **Serena** (`uv tool install`), and **CUE** (`brew install cue` or `winget`), and continues with a warning if any of them fails.
- Pre-selects the **Aside** browser MCP in the interactive setup, and installs it with `curl -fsSL https://releases.aside.com/install.sh | bash` only if you keep it selected. Deselect it in the browser MCP step, or change it later with `oma update mcp`.
- Uses **AgentMemory** for semantic memory, which runs `bun install -g @agentmemory/agentmemory` and registers it as a login service (launchd, systemd user unit, or Windows scheduled task). Choose provider `none` or set `OMA_NO_AGENTMEMORY=1` to skip it.
- Asks before linking skills into home-directory vendor folders (Antigravity, Hermes, Kimi). In `$HOME` without `--global` it asks for confirmation.
- Writes some files outside the project without asking: `~/.claude.json` (marks the project as a trusted Claude Code workspace), `~/.serena/` (OMA context, answer-size floor, project registration), `~/.cursor/cli-config.json` (turns off Cursor's commit attribution), `~/.grok/config.toml` (telemetry), and `~/.gemini/antigravity-cli/` (HUD), each only for a vendor you selected.
- Writes **telemetry opt-outs** into vendor settings (Claude `DISABLE_TELEMETRY=1`, which also turns off Claude Code Remote Control; Gemini, Qwen, Codex, and Grok usage stats). Set `telemetry: true` to keep vendor defaults.
- Disables **Qwen Code automatic memory saving** by adding `memory.enableManagedAutoMemory: false` when the setting is absent. Explicit `true` or `false` preferences and other memory settings are preserved.
- Adds unset Claude Code settings to `.claude/settings.json`, including `skipDangerousModePermissionPrompt: true`, `effortLevel: high`, `cleanupPeriodDays: 180`, and env flags that turn off auto memory, adaptive thinking, error reporting, and built-in git instructions. Values you already set are kept.
- Adds a **co-author trailer**: Claude Code's commit attribution becomes `Co-Authored-By: First Fluke <[email protected]>` and PRs get a "Generated with oh-my-agent" line. Set `scm.co_author.enabled: false` to turn this off.
- Installs a **commit-msg guard** in `.githooks/` that rejects unlisted `Co-authored-by` addresses, and sets `git config --local core.hooksPath .githooks` when no other hooks are active. Set `scm.co_author.enforce_hook: false` to opt out.
- `oma update` updates the `oma` CLI in the background (`auto_update_cli: false` or `OMA_SKIP_VERSION_CHECK=1` to stop it) and runs `uv tool upgrade serena-agent --prerelease=allow` (`serena.auto_update: false`).
- With Serena in the default `bridge` mode, the first agent session that starts a shared Serena server registers a **cleanup timer** that stops idle shared Serena servers every 5 minutes (launchd `dev.oma.serena-daemon-gc`, systemd user timer `oma-serena-daemon-gc.timer`, or Windows scheduled task `OMA Serena Daemon GC`). Set `serena.mode: stdio` to skip the shared server and its timer. `oma uninstall` does not remove the timer.
- Non-interactive runs (`-y`, `OMA_YES=1`, `CI=true`) use the `All` skill preset unless `--preset` selects another, plus `model_preset: auto` and Python as the backend language. They select no browser MCP (and skip the Aside install script) unless `mcp.devtools_browsers` already lists one.

</details>

<details>
<summary>Skill presets</summary>

| Preset | Skills |
|--------|--------|
| **All** | **All 33 skills** (recommended) |
| Fullstack | architecture, backend, brainstorm, db, debug, design, dev-workflow, frontend, mobile, pm, qa, scm, tf-infra |
| Fullstack Web | Fullstack without mobile and tf-infra |
| Fullstack Mobile | Fullstack without frontend and tf-infra |
| Frontend | architecture, brainstorm, debug, design, frontend, pm, qa, scm |
| Backend | architecture, backend, brainstorm, db, debug, dev-workflow, pm, qa, scm |
| Mobile | architecture, brainstorm, debug, mobile, pm, qa, scm |
| DevOps | architecture, brainstorm, debug, dev-workflow, observability, pm, qa, scm, tf-infra |
| Research | academic-writing, hwp, market, pdf, scholar, scm, search, translation |
| Content | academic-writing, design, image, scm, translation, voice |
| Custom | Pick skills one by one |

Of the named presets, only `All` includes coordination, orchestration, docs, security, refactor, explanation, recap, video, slide, and skill-creation (or pick them under `Custom`). Research and Content lack the skills behind `/plan`, `/review`, `/debug`, `/architecture`, and `/brainstorm`. See [Workflows that need skills outside a preset](./web/docs/getting-started/installation.md#workflows-that-need-skills-outside-a-preset).

</details>

## Your first 5 minutes

1. **Choose your setup.** For the task below, load `oma-scm` with `bunx skills use first-fluke/oh-my-agent@oma-scm`, or use the runtime install command above. [Choose a setup](./web/docs/getting-started/choose-setup.md) explains both paths.
2. **For a runtime installation, check the install:**

   ```bash
   oma doctor
   ```

   The report shows CLI and skill-file status. Its skill counts reflect the files present, including retained skills; they can differ from the current preset's selection. If `oma` is not found, open a new terminal or run `bun install --global oh-my-agent`.
3. **Open an existing Git repository and run one read-only task.** `oma-scm` is included in every named preset; include it when using Custom selection.

   ```text
   Use oma-scm to inspect this repository's current branch and working tree. Do not edit, stage, commit, or contact remotes. Report staged, unstaged, and untracked changes, with the Git commands and exit statuses actually observed.
   ```

4. **Check the result.** The reported branch and changes should match the Git output. Loading instructions or completing installation does not establish that this task ran.

For larger work, choose a workflow whose referenced skills are installed. Start with `/plan` when its planning skill is present, then continue with `/work` or `/orchestrate` when their dependencies are available.

## Meet the team

Your own agent leads the team. In `/work`, `/orchestrate` and `/ultrawork` it hands each job to the right specialist, which runs as its own subagent. `/plan`, `/architecture` and `/docs` run in your current session with that role's skill, and `/review` and `/debug` call in their specialist for large scopes. When a role is on another vendor's CLI, `oma agent spawn` runs it there.

| Your specialist | Carries | Call them with | Leaves behind |
|---|---|---|---|
| **Product manager** (`pm-planner`) | oma-pm | `/plan`, or "plan the payment feature" | A plan JSON and a tracker in `docs/plans/work/` for Medium and Complex work (Simple requests get a direct recommendation) |
| **Architect** (`architecture-reviewer`) | oma-architecture | `/architecture` | An ADR or recommendation in `.agents/results/architecture/` |
| **Backend, frontend, mobile, database and infra engineers** | oma-backend, oma-frontend + oma-design, oma-mobile, oma-db, oma-tf-infra | `/work`, `/orchestrate` | Code, tests, and a `result-<agent>` file per task |
| **QA reviewer** (`qa-reviewer`) | oma-qa | `/review`, or "review this PR" | Findings ranked CRITICAL to LOW, each with file:line and fix code |
| **Debugger** (`debug-investigator`) | oma-debug | `/debug`, or "fix this bug" | A minimal fix, a regression test, and a bug note in `.agents/results/bugs/` when one is warranted |

<details>
<summary>The other three roles, and the skills without a role</summary>

| Your specialist | Carries | Call them with | Leaves behind |
|---|---|---|---|
| **Refactorer** (`refactor-engineer`) | oma-refactor | `/ultrawork`'s REFINE phase | Behavior-preserving `refactor:` commits and a `result-refactor-<session>.md` report |
| **Docs curator** (`docs-curator`) | oma-docs | `/docs`, or "verify docs" | `docs/generated/doc-refs.json` and the doc patches you approve |
| **Researcher** (`research-explorer`) | oma-search, oma-market, oma-scholar | a research request | Cited sources with trust labels; market briefs in `.agents/results/market/` |

The infra engineer (`tf-infra-engineer`) is told to ask before any destructive or production `apply` or `destroy`. The remaining skills (brainstorm, security, scm, dev-workflow, observability, explanation, recap, translation, coordination, orchestration, skill-creation, content and media) have no dedicated role. Your agent loads them itself, and for most of them the skill injector suggests the right one from your prompt.

</details>

## How the team works together

```text
 THINK   /brainstorm ......................... docs/plans/designs/<NNN>-<feature>.md
 PLAN    /plan · /architecture ............... plan JSON, API contracts, ADR
 DESIGN  /design ............................. DESIGN.md + tokens
 BUILD   /work · /orchestrate · /ultrawork ... code + result-<agent> files, engineers in parallel
 CHECK   /review · /security · /debug ........ findings, security evidence, regression test
 SHIP    /scm · /docs ........................ Conventional Commits, doc fixes
```

Each step hands a file to the next. `/brainstorm` saves a design that `/plan` reads, and `/plan` writes a plan in which every task has an agent, dependencies, acceptance criteria and a check command. `/orchestrate` runs that plan (it loads the most recent `plan-*.json`, or writes one). `/work` and `/ultrawork` start by having the PM write their own plan. Skip any stage you don't need; every stage also works on its own.

**Which workflow should run the team?**

| You want | Run | How it ends |
|---|---|---|
| Just a plan | `/plan` | A plan file for multi-area work, or a direct recommendation for small work |
| A PM-led build you follow step by step | `/work` | PM, then engineers tier by tier, then QA. CRITICAL and HIGH findings go into a fix loop (up to 5 cycles) |
| A hands-off parallel build | `/orchestrate` | Only tasks whose checks pass count as done; each task gets up to 3 attempts, then is marked partial or failed |
| Five-phase workflow | `/ultrawork` | Five gated phases (PLAN, IMPL, VERIFY, REFINE, SHIP); every review runs in a fresh reviewer session |
| "Don't stop until it's really done" | `/ralph` | Repeats `/ultrawork` with a separately spawned, fresh-context judge until every criterion passes; stops with a partial report when criteria are blocked or after 5 iterations |
| The team on a timer | `oma schedule create qa-reviewer "review open PRs" --every 2h` | One Markdown log per run in `~/.oma/schedule/runs/<id>/` |

You don't need slash commands. On runtimes with a prompt hook, plain requests (keyword banks in up to 11 languages) can start most workflows: "review this PR" starts `/review`. Describing a whole app ("Build a TODO app with user authentication") suggests `/orchestrate`, and your agent decides whether to run it. Keywords inside code blocks are ignored.

`/orchestrate`, `/work`, `/ultrawork` and `/ralph` are **persistent** when you invoke them by name, as a slash command or in plain text ("ultrawork: add rate limiting"). The agent is then sent back to work when it tries to stop early (up to 5 times or 2 hours) until you say **"workflow done"**. A loosely matching request only suggests them.

**Measured, with caveats.** In the [benchmark](./benchmarks/README.md) (one prompt, Claude Code with five different add-on setups including plain, `claude-opus-4-6`, one build each), oma scored 80.6 against 70.7 for plain Claude Code, at 1.7x the cost ($4.04 vs $2.37) and 1.8x the time.

<details>
<summary>All 21 workflows</summary>

| Command | What it does |
|---------|--------------|
| `/architecture` | Weighs design tradeoffs and produces a recommendation, review, or ADR |
| `/brainstorm` | Explores ideas and constraints and produces an approved design before planning |
| `/convert` | Converts PDF/HWP to Markdown, or transcodes images, video, and audio with ffmpeg |
| `/debug` | Reproduces a bug, fixes the root cause, writes a regression test, and scans for similar patterns |
| `/deepinit` | Maps an existing codebase into AGENTS.md, ARCHITECTURE.md, and a docs/ knowledge base |
| `/design` | Builds a design system, DESIGN.md, and tokens with accessibility checks |
| `/docs` | Finds broken doc references and proposes patches for docs a diff touched |
| `/explain` | Turns a diff, PR, branch, or topic into a self-contained interactive HTML explainer |
| `/orchestrate` | Runs agents in parallel, coordinates them through file state, and verifies the result (persistent) |
| `/plan` | Breaks a feature into prioritized tasks with API contracts |
| `/ralph` | Repeats `/ultrawork` with a separately spawned judge, up to 5 iterations (persistent) |
| `/recap` | Summarizes your AI conversation history for a day or period |
| `/review` | Reviews security (OWASP Top 10), performance, accessibility (WCAG 2.2 AA), and code quality |
| `/schedule` | Registers an agent job that runs on a recurring interval |
| `/scm` | Handles branches, merges, conflicts, worktrees, and Conventional Commits |
| `/security` | Scans source, agent skills, and MCP components, validates findings, and sets up CI gates |
| `/stack-set` | Detects your tech stack and generates stack-specific references for domain skills |
| `/tools` | Lists, enables, and disables MCP tools in plain language |
| `/ultrawork` | Five phases (PLAN, IMPL, VERIFY, REFINE, SHIP), each review in a fresh reviewer session (persistent) |
| `/video` | Turns a brief into a finished MP4 through a key-optional pipeline |
| `/work` | Coordinates several agents on a multi-domain project with PM planning and QA review (persistent) |

`oma verify triggers` evaluates the detector against a labeled English and Korean corpus of 212 prompts. CI fails above 10% false fires or 20% missed fires. Last measured: **0% missed-fire, 5.3% false-fire**. Full reference: [Workflows](https://first-fluke.github.io/oh-my-agent/docs/core-concepts/workflows/).

</details>

## See it work

An illustrative `/ultrawork` session. The `[OMA PERSISTENT MODE: ULTRAWORK]` block is the exact format the Stop hook prints; the other lines are paraphrased:

```text
you    /ultrawork add rate limiting to POST /login
agent  runs `oma goal set --gate test`
agent  PLAN writes .agents/results/plan-<run-id>.json
agent  IMPL -> VERIFY -> REFINE -> SHIP  (each review runs in a fresh reviewer session)
agent  "Rate limiting added. All tests pass."
oma    [OMA PERSISTENT MODE: ULTRAWORK]
       Stop gate 'test' FAILED (reinforcement 1/5).
       Fix the failures below, then finish the workflow — the stop is allowed only when the gate passes.
       --- gate output (tail) ---
       FAIL  src/auth/login.test.ts > returns 429 after 5 attempts
       To abandon instead: delete .agents/state/ultrawork-state-<host-session>.json or say "workflow done".
agent  fixes the limiter and stops again
oma    `test` exits 0: stop allowed, gate.passed appended to the session log
```

Afterwards, `oma state list` finds the session and `oma state get <oma-sid>` (the ID `state list` prints) shows every gate event. Under `/ralph`, `oma ralph verify --json` also checks that the phases left their files behind (output trimmed):

```json
{ "ok": false,
  "missing": [{ "id": "A3", "description": "a distinct QA agent ran (VERIFY phase)",
                "pattern": ".agents/state/memories/result-qa*.md or .agents/results/result-qa*.md",
                "status": "missing" }] }
```

## Everything in the box

<details>
<summary><strong>Plan and design</strong>: <code>/brainstorm</code>, <code>/plan</code>, <code>/architecture</code>, <code>/design</code></summary>

| Command | What it does | Writes |
|---|---|---|
| `/brainstorm` | Asks one clarifying question at a time and proposes 2-3 approaches that work differently, then hands off to `/plan`. Writes no code | `docs/plans/designs/<NNN>-<feature>.md` |
| `/plan` | Sizes the work as Simple, Medium or Complex; for Medium and Complex work, splits it into tasks, each with an agent, dependencies, acceptance criteria and a check command, and defines API contracts when the work crosses a boundary | `.agents/results/plan-<sid>.json`, `docs/plans/work/<NNN>-<name>.md`, contracts in `.agents/results/api-contracts/` when needed |
| `/architecture` | Reads earlier decisions first, compares at least 2 options, and marks replaced ADRs as superseded | An ADR or recommendation in `.agents/results/architecture/` |
| `/design` | Proposes 2-3 directions, then writes `DESIGN.md` with tokens and audits responsive layout and accessibility | `DESIGN.md`, CSS/Tailwind/shadcn tokens |

</details>

<details>
<summary><strong>Build</strong>: 7 domain skills, plus <code>/stack-set</code> to fit them to your stack</summary>

| Skill | Builds |
|---|---|
| oma-frontend | React/Next.js or Angular UI that follows your tokens, i18n and accessibility rules |
| oma-backend | APIs, auth and data access, layered router → service → repository |
| oma-mobile | Flutter, React Native or Swift apps |
| oma-db | Schemas, migrations, query tuning, vector/RAG retrieval plans |
| oma-tf-infra | Terraform for any cloud, with drift, destructive-change and cost risks called out |
| oma-dev-workflow | mise tasks, lint/format/typecheck, commitlint, git hooks, CI/CD and releases |
| oma-observability | OpenTelemetry, SLOs, alerting and incident forensics |

`/stack-set` reads your manifests and writes stack-specific references for the backend, frontend and mobile skills. In a monorepo, frontend, backend and mobile engineers are pointed at their workspace (pnpm, npm/yarn/bun workspaces, lerna, nx, turbo, `mise.toml`).

</details>

<details>
<summary><strong>Review, fix and ship</strong>: <code>/review</code>, <code>/security</code>, <code>/debug</code>, refactor, <code>/scm</code></summary>

| Command or skill | What it does | Writes |
|---|---|---|
| `/review` | A dependency audit, then OWASP Top 10, performance, WCAG 2.2 AA and code quality. Every finding gets file:line and fix code | The report in chat plus a memory record; no report file |
| `/security` | Scans your source, agent skills and MCP servers (Deepsec, Cisco Skill and MCP Scanner) and, given a scoped test deployment, runs ARTEX pen tests. The workflow requires an engine that failed to run to be reported as failed, not as clean | `.agents/results/security/<run-id>/` |
| `/debug` | Reproduces the failure, fixes the root cause with a minimal change, adds a regression test, and scans for the same pattern elsewhere | The fix and test; a bug note in `.agents/results/bugs/` when one is warranted |
| oma-refactor | Changes structure without changing behavior: characterization tests first, then refactor-only commits | `.agents/results/refactor/` |
| `/scm` | Conventional Commits split by logical change; branches, merges, rebases and worktrees | Commits and branches |

</details>

<details>
<summary><strong>Docs and knowledge</strong>: <code>/deepinit</code>, <code>/docs</code>, <code>/explain</code>, <code>/recap</code>, translation</summary>

| Command or skill | What it does | Writes |
|---|---|---|
| `/deepinit` | Turns an existing repo into an agent-ready knowledge base | `AGENTS.md`, `ARCHITECTURE.md`, `docs/` |
| `/docs` | Finds broken references, patches the docs a diff touched (only the patches you approve), and finds stale translations | `docs/generated/doc-refs.json`, patched docs |
| `/explain` | Turns a PR, branch or staged change into an HTML walkthrough with a 5-question quiz, or a topic into a one-page visual explainer | `.agents/results/explain/<date>-<slug>.html` |
| `/recap` | Summarizes your AI conversations across tools for a day or a period | `.agents/results/recap/<date>.md` |
| oma-translation | Translation that reads natively; placeholders, code and locale keys stay unchanged | Translated text |

</details>

<details>
<summary><strong>Research</strong>: search, market, papers, academic writing</summary>

| Skill | What it does | Writes |
|---|---|---|
| oma-search | Docs, web and code search, with a trust label on each source | Cited results |
| oma-market | Pain points, trends and competitors from community signals, framed with SWOT, Porter's 5 Forces and PESTEL | `.agents/results/market/<topic>-<date>.md` |
| oma-scholar | Paper search that reads a compact claims file (Knows format, about 700 tokens) instead of the full PDF (about 10K tokens) | `<paper>.knows.yaml` |
| oma-academic-writing | Drafts and audits academic prose against a rubric | Your file |

</details>

<details>
<summary><strong>Content and media</strong>: <code>/video</code>, <code>/convert</code>, slides, images, voice</summary>

| Command or skill | What it makes | Writes |
|---|---|---|
| `/video` | Shorts, explainers or demos as a finished MP4; keyed providers have key-free fallbacks | `.agents/results/videos/<run>/` with a manifest |
| oma-slide | 1920×1080 HTML decks, exported to PDF, PNG or PPTX | `.agents/results/slides/<session>/` |
| oma-image | Images through the vendor CLIs you're signed into, compared side by side | `.agents/results/images/<run>/` |
| oma-voice | Local text-to-speech and transcription through the Voicebox app | `.agents/results/voice/<run>/` |
| `/convert` | PDF or HWP to Markdown; image, video and audio conversion through ffmpeg | Next to the input file |

These pipelines report a missing source or vendor key instead of silently returning a thinner result.

</details>

<details>
<summary><strong>Hooks that run without being asked</strong></summary>

| Hook | What it does | Off switch / limit |
|---|---|---|
| Keyword start | Starts the matching workflow from a plain request | Questions, pasted text and code blocks are skipped |
| Skill injector | Points your agent at the right skills for the prompt | Paused while a persistent workflow is active |
| Stop gate | Sends a persistent workflow back to work; with `oma goal set --gate test`, the stop is allowed when that script exits 0 within 25 s | Say "workflow done"; it also releases after 5 blocks or 2 hours |
| Refactor guard | At stop, flags edited files over 500 lines for `refactor-engineer` | Opt-in: `ref...

© First Fluke · MIT · first-fluke/oh-my-agent

Similar plugins

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

From the same set69

The whole set →
oma-security oma-security runs security scans across source code, agent skills, and MCP components. Executes targeted penetration tests and configures engine-specific CI gates. CX Codex +1 ★ 1,472repo stars oma-voice oma-voice generates speech, transcribes recordings, and processes existing audio files. Use it for voiceovers, transcripts, or audio edits with specified media settings. CX Codex +1 ★ 1,472repo stars oma-orchestration oma-orchestration breaks a complex request into prioritized tasks and dispatches them to parallel specialist agents while tracking progress through to a final report. CX Codex +1 ★ 1,472repo stars oma-observability oma-observability routes observability, tracing, and MELT+P telemetry architecture across systems, tunes OpenTelemetry transport, and guides multi-dimension incident forensics. CX Codex +1 ★ 1,472repo stars oma-translator oma-translator translates and reviews UI strings, documentation, and marketing copy using project context. Helps retain the source tone, terminology, and structure. CX Codex +1 ★ 1,472repo stars oma-research oma-research — a plugin for searching academic literature, conducting market research, extracting data from documents, and preparing research materials directly in Claude Code. CX Codex ★ 1,472repo stars oma-security oma-security runs security scans across source code, reviews vulnerabilities, and provides verified remediation in Claude Code and Codex. CX Codex ★ 1,472repo stars oma-frontend oma-frontend supports frontend implementation, interface design, code review, and debugging. Use it when building or checking an interface. CX Codex ★ 1,472repo stars

Project sponsors

Companies that keep this analytics open