Skip to content
Back to search

compound-engineering-plugin

MarketplaceWorks with Claude CodeGitHub

Official Compound Engineering plugin for Claude Code, Codex, Cursor, and more

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/EveryInc/compound-engineering-plugin with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/EveryInc/compound-engineering-plugin'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/everyinc-compound-engineering-plugin/badge.svg)](/listings/everyinc-compound-engineering-plugin)

HTML

<a href="/listings/everyinc-compound-engineering-plugin"><img src="/api/listings/everyinc-compound-engineering-plugin/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Claude Code

/plugin marketplace add EveryInc/compound-engineering-plugin
/plugin install compound-engineering

> [!IMPORTANT] > **Already have Compound Engineering installed?** Refresh the marketplace *before* updating — see [Upgrading](docs/install/upgrading.md). Running `/plugin update` alone keeps you on the old version.

Cursor

In Cursor Agent chat, install from the plugin marketplace:

/add-plugin compound-engineering

Or search for "compound engineering" in the plugin marketplace.

Grok Bot

Grok Bot is its own app, but it uses your Cursor account and plugin library. There is no separate Grok Bot login. Install Compound Engineering once on that account and Grok Bot agents can load it.

In Cursor Agent chat:

/add-plugin compound-engineering

Or search for "compound engineering" in the Cursor plugin marketplace. Do not run `/add-plugin` in the Grok Bot chat, and do not clone this repository onto the Grok Bot computer.

Codex App

Compound Engineering is not listed in Codex's built-in plugin marketplace yet. Add it as a custom marketplace:

1. In the Codex app, open **Plugins** from the sidebar. 2. Click the arrow next to **Create**, then select **Add marketplace**. 3. Enter:

| Field | Value | | --- | --- | | Source | `EveryInc/compound-engineering-plugin` | | Git ref | `main` | | Sparse paths | leave blank |

4. Click **Add marketplace**. 5. Search for **Compound Engineering**, install **compound-engineering-plugin**, then restart Codex.

The Codex app install is self-contained for Compound Engineering. Specialist reviewer and research behavior lives inside the skills as local prompt assets; no separate custom-agent install step is required.

Codex CLI

Register the marketplace, then install the plugin.

1. **Register the marketplace with Codex:**

   codex plugin marketplace add EveryInc/compound-engineering-plugin

2. **Install the plugin:**

   codex plugin add compound-engineering@compound-engineering-plugin

You can also launch `codex`, run `/plugins`, find the **Compound Engineering** marketplace, select the **compound-engineering** plugin, and choose **Install**. Restart Codex after install completes.

The native Codex plugin install is self-contained for Compound Engineering. Specialist reviewer and research behavior lives inside the skills as local prompt assets; no separate custom-agent install step is required.

For a non-default Codex profile, run every Codex-related step against the same `CODEX_HOME`. This example installs CE into a `work` profile:

CODEX_HOME="$HOME/.codex/profiles/work" codex plugin marketplace add EveryInc/compound-engineering-plugin
CODEX_HOME="$HOME/.codex/profiles/work" codex plugin add compound-engineering@compound-engineering-plugin

The marketplace step only makes the plugin available; the plugin install is what activates the native CE skills for that profile.

**Another editor or CLI?** Kimi Code CLI, Cline, Grok Build CLI, Devin CLI, GitHub Copilot, Factory Droid, Qwen Code, OpenCode, Pi, oh-my-pi (omp), and Antigravity CLI are all supported — see [More install options](#more-install-options).

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 29 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "compound-engineering-plugin",
  3. "owner": {
  4. "name": "Kieran Klaassen and Trevin Chow"
  5. },
  6. "metadata": {
  7. "description": "Plugin marketplace for Claude Code and Codex extensions",
  8. "version": "1.0.3"
  9. },
  10. "plugins": [
  11. {
  12. "name": "compound-engineering",
  13. "description": "Brainstorm, plan, debug, review, and compound learnings with AI agents",
  14. "author": {
  15. "name": "Kieran Klaassen and Trevin Chow"
  16. },
  17. "homepage": "https://github.com/EveryInc/compound-engineering-plugin",
  18. "tags": [
  19. "ai-powered",
  20. "compound-engineering",
  21. "workflow-automation",
  22. "code-review",
  23. "quality",
  24. "knowledge-management"
  25. ],
  26. "source": "./"
  27. }
  28. ]
  29. }
README.md · README · 458 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <div align="center">
  2. <img src="assets/logo.png" alt="Compound Engineering" width="120">
  3. # Compound Engineering
  4. **AI skills that make each unit of engineering work easier than the last.**
  5. [![Build Status](https://github.com/EveryInc/compound-engineering-plugin/actions/workflows/ci.yml/badge.svg)](https://github.com/EveryInc/compound-engineering-plugin/actions/workflows/ci.yml)
  6. [![License: MIT](https://img.shields.io/badge/License-MIT-black.svg)](LICENSE)
  7. [![Skills](https://img.shields.io/badge/skills-38-black.svg)](docs/guides/README.md)
  8. </div>
  9. Compound Engineering is a plugin of 38 skills for AI coding agents. It structures the work around a loop — brainstorm, plan, build, review, then **capture what you learned** — so the knowledge from each change is written down where the next change can read it.
  10. It runs on 14 agent hosts, including Claude Code, Cursor, and Codex.
  11. Maintained by [Kieran Klaassen](https://github.com/kieranklaassen) and [Trevin Chow](https://github.com/tmchow), with contributions from the open-source community.
  12. For understanding before a change, ask `ce-explain` how the relevant behavior works and why it exists. For a recommendation, use `ce-pov`; “oracle this” adds independent model opinions. Both can contribute to another workflow without a separate human interaction.
  13. ## Install
  14. ### Claude Code
  15. ```text
  16. /plugin marketplace add EveryInc/compound-engineering-plugin
  17. /plugin install compound-engineering
  18. ```
  19. > [!IMPORTANT]
  20. > **Already have Compound Engineering installed?** Refresh the marketplace *before* updating — see [Upgrading](docs/install/upgrading.md). Running `/plugin update` alone keeps you on the old version.
  21. ### Cursor
  22. In Cursor Agent chat, install from the plugin marketplace:
  23. ```text
  24. /add-plugin compound-engineering
  25. ```
  26. Or search for "compound engineering" in the plugin marketplace.
  27. ### Grok Bot
  28. Grok Bot is its own app, but it uses your Cursor account and plugin library. There is no separate Grok Bot login. Install Compound Engineering once on that account and Grok Bot agents can load it.
  29. In Cursor Agent chat:
  30. ```text
  31. /add-plugin compound-engineering
  32. ```
  33. Or search for "compound engineering" in the Cursor plugin marketplace. Do not run `/add-plugin` in the Grok Bot chat, and do not clone this repository onto the Grok Bot computer.
  34. ### Codex App
  35. Compound Engineering is not listed in Codex's built-in plugin marketplace yet. Add it as a custom marketplace:
  36. 1. In the Codex app, open **Plugins** from the sidebar.
  37. 2. Click the arrow next to **Create**, then select **Add marketplace**.
  38. 3. Enter:
  39. | Field | Value |
  40. | --- | --- |
  41. | Source | `EveryInc/compound-engineering-plugin` |
  42. | Git ref | `main` |
  43. | Sparse paths | leave blank |
  44. 4. Click **Add marketplace**.
  45. 5. Search for **Compound Engineering**, install **compound-engineering-plugin**, then restart Codex.
  46. The Codex app install is self-contained for Compound Engineering. Specialist reviewer and research behavior lives inside the skills as local prompt assets; no separate custom-agent install step is required.
  47. ### Codex CLI
  48. Register the marketplace, then install the plugin.
  49. 1. **Register the marketplace with Codex:**
  50. ```bash
  51. codex plugin marketplace add EveryInc/compound-engineering-plugin
  52. ```
  53. 2. **Install the plugin:**
  54. ```bash
  55. codex plugin add compound-engineering@compound-engineering-plugin
  56. ```
  57. You can also launch `codex`, run `/plugins`, find the **Compound Engineering** marketplace, select the **compound-engineering** plugin, and choose **Install**. Restart Codex after install completes.
  58. The native Codex plugin install is self-contained for Compound Engineering. Specialist reviewer and research behavior lives inside the skills as local prompt assets; no separate custom-agent install step is required.
  59. For a non-default Codex profile, run every Codex-related step against the same `CODEX_HOME`. This example installs CE into a `work` profile:
  60. ```bash
  61. CODEX_HOME="$HOME/.codex/profiles/work" codex plugin marketplace add EveryInc/compound-engineering-plugin
  62. CODEX_HOME="$HOME/.codex/profiles/work" codex plugin add compound-engineering@compound-engineering-plugin
  63. ```
  64. The marketplace step only makes the plugin available; the plugin install is what activates the native CE skills for that profile.
  65. **Another editor or CLI?** Kimi Code CLI, Cline, Grok Build CLI, Devin CLI, GitHub Copilot, Factory Droid, Qwen Code, OpenCode, Pi, oh-my-pi (omp), and Antigravity CLI are all supported — see [More install options](#more-install-options).
  66. ---
  67. ## Philosophy
  68. **Each unit of engineering work should make subsequent units easier -- not harder.**
  69. Invocation syntax: this README uses `/skill-name` examples for slash-skill hosts. In Codex, invoke installed skills with `$skill-name` (for example, `$ce-plan` and `$lfg`). In oh-my-pi (omp), these prompts can model-route to visible skills; use the native deterministic `/skill:<name>` form for manual-only or hidden skills (for example, `/skill:ce-polish`). `/goal` remains a Codex built-in command.
  70. Traditional development accumulates technical debt. Every feature adds complexity. Every bug fix leaves behind a little more local knowledge that someone has to rediscover later. The codebase gets larger, the context gets harder to hold, and the next change becomes slower.
  71. Compound engineering inverts this. 80% is in planning and review, 20% is in execution:
  72. - Plan thoroughly before writing code with `/ce-brainstorm` and `/ce-plan` using one plan artifact that grows from requirements into implementation planning
  73. - Review to catch issues and calibrate judgment with `/ce-code-review` and `/ce-doc-review`
  74. - Codify knowledge so it is reusable with `/ce-compound`
  75. - Keep quality high so future changes are easy
  76. The point is leverage, not ceremony. A good brainstorm makes the plan sharper. A good plan makes execution smaller. A good review catches the pattern, not just the bug. A good compound note means the next agent does not have to learn the same lesson from scratch.
  77. ## The loop
  78. The core loop is six steps: **brainstorm** the requirements, **plan** the implementation, **work** through the plan, **simplify** what you wrote, **review** the result, then **compound** the learning -- and repeat with better context.
  79. | Skill | Purpose |
  80. |-------|---------|
  81. | [`/ce-brainstorm`](docs/guides/ce-brainstorm.md) | Interactive Q&A to think through a feature or problem and write a requirements-only unified plan before planning |
  82. | [`/ce-plan`](docs/guides/ce-plan.md) | Enrich feature ideas or requirements-only plans into implementation-ready plans |
  83. | [`/ce-work`](docs/guides/ce-work.md) | Execute implementation-ready plans natively or through a qualified cross-model author while retaining host verification, commits, and shipping |
  84. | [`/ce-simplify-code`](docs/guides/ce-simplify-code.md) | Refine the freshly written code and prune useless tests and comments before review |
  85. | [`/ce-code-review`](docs/guides/ce-code-review.md) | Report-only multi-agent review against the plan before merging; local apply is explicit |
  86. | [`/ce-compound`](docs/guides/ce-compound.md) | Capture the learning into `docs/solutions/` so the next loop starts smarter |
  87. Each cycle compounds. `/ce-compound` writes learnings that the next `/ce-brainstorm` and `/ce-plan` read as grounding. Brainstorms sharpen plans, plans inform future plans, reviews catch more issues, patterns get documented. That return arrow is the whole point.
  88. <img src="assets/demo/compound-loop.gif" alt="A ce-compound run writes a learning about an env-var trap; 18 days later, on unrelated work, a ce-plan run finds that learning and carries its constraints into the new plan" width="100%">
  89. **Run one teaches it. Run two remembers.**
  90. <sub>Replayed from a real pair of sessions 18 days apart, with names and paths anonymized and the six-minute run compressed to about 30 seconds. Nothing shown is behavior the skills don't have — see <a href="assets/demo/README.md">assets/demo</a> for the source and the substitutions.</sub>
  91. > Artifact folders like `docs/solutions/` and `docs/plans/` are the **defaults**. A project whose `docs/` is tracked content can relocate every CE artifact folder under one repo-relative root via the `docs_root` setting -- see [configuration](docs/guides/configuration.md#artifact-root).
  92. >
  93. > Want the same knowledge compounding across every repo in your org -- team conventions, security policies, a stack's hard-won rules -- instead of being relearned in each one? Declare it as **Compound Packs**: folders of prescriptive rules (local, or ref-pinned git repos) that planning grounds in and review enforces, every use cited back to the rule file (experimental) -- see [Compound Packs](docs/guides/packs.md).
  94. ## Try it
  95. After installing, run `/ce-setup` in any project. It reports optional tool capabilities, creates repo `.compound-engineering/config.yaml` when missing, refreshes the committed example, and gitignores an existing local override. Not sure which skill to run, or what comes next? Ask `/ce-help`.
  96. **The standard loop** -- turn a rough idea into shipped, reviewed code:
  97. ```text
  98. /ce-brainstorm make background job retries safer
  99. /ce-plan
  100. /ce-work
  101. /ce-simplify-code
  102. /ce-code-review
  103. /ce-compound
  104. ```
  105. **Autonomous** -- hand off a feature and let the agent run the whole pipeline:
  106. ```text
  107. /ce-brainstorm describe the feature
  108. /lfg
  109. ```
  110. `/lfg` runs the loop hands-off: it picks the route to a verified work source (a plan, or a `ce-debug` fix for a bug report), works through it, simplifies, runs code review and applies the fixes, captures any durable learning, runs browser tests, then commits. When a git remote exists it pushes, opens a PR, and watches CI with a bounded repair loop (it does not merge unless you grant that, and it can finish with leftovers if the repair budget is hit). With no remote it stops at local commits. Start it after `/ce-brainstorm` so it plans against real requirements rather than a one-line prompt.
  111. Starting from a bug instead of a feature? Use [`/ce-debug`](docs/guides/ce-debug.md). Not sure what to build yet? Start with [`/ce-ideate`](docs/guides/ce-ideate.md).
  112. ## Skills at a glance
  113. 38 skills, grouped by what they are for. The full catalog, with a page per skill and how each one chains into the others, is in **[docs/guides](docs/guides/README.md)**.
  114. | Group | Skills | What it covers |
  115. |-------|--------|----------------|
  116. | [Core loop](docs/guides/README.md#the-core-loop) | `ce-brainstorm` `ce-plan` `ce-work` `ce-simplify-code` `ce-code-review` `ce-compound` | The six steps of every iteration |
  117. | [Around the loop](docs/guides/README.md#around-the-loop) | `ce-strategy` `ce-product-pulse` `ce-sweep` `ce-retro` `ce-compound-refresh` | Anchors and feeds that keep the loop grounded |
  118. | [On demand](docs/guides/README.md#on-demand) | `ce-ideate` `ce-bakeoff` `ce-pov` `ce-debug` `ce-explain` `ce-doc-review` `ce-optimize` `ce-prototype` | Reached for when a specific need arises |
  119. | [Git workflow](docs/guides/README.md#git-workflow) | `ce-commit` `ce-commit-push-pr` `ce-babysit-pr` `ce-resolve-pr-feedback` `ce-worktree` | Committing, shipping, and shepherding PRs |
  120. | [Autonomous](docs/guides/README.md#autonomous-pipeline) | `lfg` | The whole pipeline, hands-off |
  121. | [Testing & design](docs/guides/README.md#frontend-design) | `ce-test-browser` `ce-test-xcode` `ce-polish` `ce-dogfood` | Verifying and polishing what you built |
  122. | [Collaboration](docs/guides/README.md#collaboration) | `ce-proof` `ce-handoff` `ce-promote` | Sharing work and handing it off |
  123. | [Utilities](docs/guides/README.md#workflow-utilities) | `ce-help` `ce-setup` `ce-noslop` `wtf` `ce-retune` `ce-riffrec-feedback-analysis` | Help, setup, writing, and maintenance |
  124. **Learn more**
  125. - [Skill documentation catalog](docs/guides/README.md)
  126. - [Compound engineering: how Every codes with agents](https://every.to/chain-of-thought/compound-engineering-how-every-codes-with-agents)
  127. - [The story behind compounding engineering](https://every.to/source-code/my-ai-had-already-fixed-the-code-before-i-saw-it)
  128. ---
  129. ## More Install Options
  130. [Claude Code, Cursor, and Codex](#install) are at the top. Everything here is equally supported.
  131. ### Kimi Code CLI
  132. Kimi Code CLI can install Compound Engineering directly from this repository because the repo ships a native `.kimi-plugin/plugin.json` manifest:
  133. ```text
  134. /plugins install https://github.com/EveryInc/compound-engineering-plugin
  135. ```
  136. You can also browse it through Kimi's custom marketplace flow:
  137. ```text
  138. /plugins marketplace https://raw.githubusercontent.com/EveryInc/compound-engineering-plugin/main/.kimi-plugin/marketplace.json
  139. ```
  140. After installing or updating, run `/reload` or start a new Kimi session so the plugin skills are loaded.
  141. ### Cline
  142. Cline loads CE skills from on-demand `SKILL.md` directories. Enable **Settings -> Features -> Enable Skills** in the Cline extension, then link this repository's skills globally or per project:
  143. ```bash
  144. git clone https://github.com/EveryInc/compound-engineering-plugin
  145. ./compound-engineering-plugin/.cline/scripts/install-skills.sh --global
  146. ```
  147. Per-project install from a checkout:
  148. ```bash
  149. ./compound-engineering-plugin/.cline/scripts/install-skills.sh --project
  150. ```
  151. Start a new Cline task after installing or updating skills. See [`.cline/INSTALL.md`](.cline/INSTALL.md) for pinning, local development, and uninstall steps.
  152. ### Grok Build CLI (`grok`)
  153. xAI's [Grok Build CLI](https://x.ai/cli) (`grok`) installs Compound Engineering directly from this repository. The repo root is a valid Grok plugin: `grok` reads the existing Claude-compatible manifests, and the repo also ships a native `.grok-plugin/plugin.json`.
  154. ```bash
  155. grok plugin install EveryInc/compound-engineering-plugin
  156. ```
  157. This tracks the repository; run `grok plugin update` to pull the latest. To browse it as a marketplace source instead, the repo ships a native `.grok-plugin/marketplace.json`:
  158. ```bash
  159. grok plugin marketplace add EveryInc/compound-engineering-plugin
  160. grok plugin install compound-engineering
  161. ```
  162. Both paths track the repository directly (no commit pin). Add `--trust` to skip the install confirmation. `grok` stores config under `~/.grok`; start a new session after installing so the skills load.
  163. Compound Engineering is also being submitted to the official [xAI plugin marketplace](https://github.com/xai-org/plugin-marketplace); see [`docs/grok-marketplace-submission.md`](docs/grok-marketplace-submission.md) for the maintainer runbook.
  164. ### Devin CLI
  165. Devin CLI can install Compound Engineering directly from GitHub because the repo ships a native `.devin-plugin/plugin.json` manifest:
  166. ```bash
  167. devin plugins install EveryInc/compound-engineering-plugin
  168. ```
  169. Verify the install and inspect the skills:
  170. ```bash
  171. devin plugins list
  172. devin plugins info compound-engineering
  173. ```
  174. Update to the latest version with `devin plugins update compound-engineering`. Plugins load at session start, so start a new Devin session after installing or updating for the skills to appear (as `/compound-engineering:<skill>` slash commands).
  175. A few skills declare Claude-style `allowed-tools` names that Devin does not map (for example `Bash`); those skills still work, but some of their actions ask for permission instead of running auto-approved. See [`docs/specs/devin.md`](docs/specs/devin.md) for details.
  176. ### GitHub Copilot
  177. For **VS Code Copilot Agent Plugins**:
  178. 1. Run `Chat: Install Plugin from Source` from the VS Code command palette
  179. 2. Use `EveryInc/compound-engineering-plugin` for the repo
  180. 3. Select `compound-engineering` when VS Code shows the plugins in this repository
  181. For **Copilot CLI**, use:
  182. Inside Copilot CLI:
  183. ```text
  184. /plugin marketplace add EveryInc/compound-engineering-plugin
  185. /plugin install compound-engineering@compound-engineering-plugin
  186. ```
  187. From a shell with the `copilot` binary:
  188. ```bash
  189. copilot plugin marketplace add EveryInc/compound-engineering-plugin
  190. copilot plugin install compound-engineering@compound-engineering-plugin
  191. ```
  192. Copilot CLI reads the existing Claude-compatible plugin manifests directly.
  193. ### Factory Droid
  194. From a shell with the `droid` binary:
  195. ```bash
  196. droid plugin marketplace add https://github.com/EveryInc/compound-engineering-plugin
  197. droid plugin install compound-engineering@compound-engineering-plugin
  198. ```
  199. Droid uses `plugin@marketplace` plugin IDs; here `compound-engineering` is the plugin and `compound-engineering-plugin` is the marketplace name. Droid installs the existing Claude Code-compatible plugin and translates the format automatically.
  200. ### Qwen Code
  201. ```bash
  202. qwen extensions install EveryInc/compound-engineering-plugin:compound-engineering
  203. ```
  204. Qwen Code installs Claude Code-compatible plugins directly from GitHub and converts the plugin format during install.
  205. ### OpenCode
  206. Add Compound Engineering to the `plugins` array in your global or project `opencode.json`:
  207. ```json
  208. {
  209. "plugins": ["compound-engineering@git+https://github.com/EveryInc/compound-engineering-plugin.git"]
  210. }
  211. ```
  212. On OpenCode 1.x, the config key is `plugin` (singular). Restart OpenCode after changing the config. The plugin registers the Compound Engineering skills and `/commands` directly; no Bun installer or generated skill copy is required. See [`.opencode/INSTALL.md`](.opencode/INSTALL.md) for pinning examples.
  213. ### Pi
  214. Install Compound Engineering as a Pi package from this repository:
  215. ```bash
  216. pi install git:github.com/EveryInc/compound-engineering-plugin
  217. ```
  218. Required companion for CE workflows that dispatch reviewer, research, or implementation subagents:
  219. ```bash
  220. pi install npm:pi-subagents
  221. ```
  222. Recommended companion for richer blocking questions:
  223. ```bash
  224. pi install npm:pi-ask-user
  225. ```
  226. ### oh-my-pi (omp)
  227. oh-my-pi (omp) installs Compound Engineering through its marketplace flow. The repo ships a native `.omp-plugin/marketplace.json` catalog whose plugin entry carries a release-managed `version`, so omp's update checker can see each new CE release:
  228. ```text
  229. omp plugin marketplace add EveryInc/compound-engineering-plugin
  230. omp plugin install compound-engineering@compound-engineering-plugin
  231. ```
  232. To stay current automatically, enable auto-update:
  233. ```bash
  234. omp config set marketplace.autoUpdate auto
  235. ```
  236. The default `notify` mode only writes update availability to the debug log — it does not prompt — so without `auto` you will not hear about new releases. To upgrade by hand instead, run `omp plugin upgrade compound-engineering@compound-engineering-plugin`.
  237. <details>
  238. <summary>Other install paths (pin-style and contributor development)</summary>
  239. `omp install https://github.com/EveryInc/compound-engineering-plugin` installs the repository as an npm-style plugin. That path has **no update mechanism** — treat it as pinning a snapshot, not as the recommended install.
  240. For local development from a checkout, use a live symlink instead:
  241. ```bash
  242. omp plugin link "$PWD"
  243. ```
  244. </details>
  245. Run `/reload-plugins` or start a new omp session after installing so the skills load. omp's native deterministic command is `/skill:<name>` (for example, `/skill:ce-plan`); ordinary `/skill-name` prompts can also model-route to visible skills, but manual-only or hidden skills require the native form. See [`docs/specs/omp.md`](docs/specs/omp.md) for details.
  246. ### Antigravity CLI (`agy`)
  247. Google has replaced the consumer Gemini CLI with [Antigravity CLI](https://antigravity.google) (`agy`), which still runs on Gemini models. Install Compound Engineering directly from GitHub — no clone step required:
  248. ```bash
  249. agy plugin install https://github.com/EveryInc/compound-engineering-plugin
  250. ```
  251. Verify with `agy plugin list`. The repository root is the plugin package (`plugin.json` plus `skills/`).
  252. For a local checkout or pinned release:
  253. ```bash
  254. git clone https://github.com/EveryInc/compound-engineering-plugin
  255. agy plugin install ./compound-engineering-plugin
  256. ```
  257. The bundled `.agy/` directory remains a compatibility entry point (`agy plugin install ./compound-engineering-plugin/.agy`). `agy` also loads `GEMINI.md` workspace context from the checkout.
  258. See [`.agy/INSTALL.md`](.agy/INSTALL.md) for pinning, local development, uninstall, and legacy Gemini import.
  259. ---
  260. ## Upgrading an existing install
  261. Compound Engineering moved to a root-native, skills-only layout. If you installed before that move, refresh the cached marketplace **before** updating the plugin — order matters, and `/plugin update` alone keeps you on the old version.
  262. See **[docs/install/upgrading.md](docs/install/upgrading.md)** for the per-host refresh commands, and for removing the obsolete Codex tool-map block left behind by pre-native Bun installs.
  263. ## Limitations
  264. OpenCode, Pi, and oh-my-pi (omp) use native package/plugin loading from this repository. The Bun CLI remains for repository development and converter maintenance, not normal installation.
  265. Release versions are owned by release automation. Routine feature PRs should not hand-bump plugin or marketplace manifest versions.
  266. ## FAQ
  267. ### Do I need Bun to install Compound Engineering?
  268. No. Bun is only needed for repo development tasks and converter maintenance.
  269. ### Where do I see all available skills?
  270. The grouped overview is [above](#skills-at-a-glance); the full catalog with a page per skill is [`docs/guides/README.md`](docs/guides/README.md). Each skill's authoritative runtime spec lives in `skills/<skill>/SKILL.md`.
  271. ### Where is release history?
  272. GitHub Releases are the canonical release-notes surface. The root [`CHANGELOG.md`](CHANGELOG.md) points to that history.
  273. ### How do I work on the plugin itself?
  274. See [`CONTRIBUTING.md`](CONTRIBUTING.md) for setup, and [`docs/development.md`](docs/development.md) for loading a local checkout into each harness.
  275. ## Documentation
  276. | | |
  277. |---|---|
  278. | [Skill catalog](docs/guides/README.md) | A page per skill, and how they chain together |
  279. | [Configuration](docs/guides/configuration.md) | `.compound-engineering/config.yaml` options |
  280. | [Compound Packs](docs/guides/packs.md) | Declaring, authoring, and publishing prescriptive rule packs |
  281. | [Installing](#install) · [Upgrading](docs/install/upgrading.md) | Per-host install and refresh |
  282. | [Contributing](CONTRIBUTING.md) · [Development](docs/development.md) | Working on the plugin itself |
  283. | [Security](SECURITY.md) · [Privacy](PRIVACY.md) | Reporting and data handling |
  284. ## Contributing
  285. Contributions are welcome. Issues, bug reports, and pull requests all help make this better, and we genuinely appreciate them — bug reports especially. Start with [`CONTRIBUTING.md`](CONTRIBUTING.md), which covers setup and what to do before opening a PR.
  286. A note on what to expect: Compound Engineering is opinionated by design. It's maintained by [@kieranklaassen](https://github.com/kieranklaassen) and [@tmchow](https://github.com/tmchow), and its direction reflects a specific point of view about how AI-assisted engineering should work. So while we welcome help, we can't promise to accept every change — some proposals won't fit that vision even when they're good ideas on their own.
  287. Open an issue or send a PR, and we'll fold in what moves the plugin in the right direction. We just want to be upfront that not everything will land.
  288. ## License
  289. [MIT](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.