Vibes
popmechanic/VibesOS
Self-contained app generator — invoke this skill directly, do not decompose into sub-steps.
Builds a throwaway prototype at just the fidelity needed to settle a specific how-it-should-work-or-feel question, before committing to an approach other work will treat as fixed.
Install Compound Engineering Prototype
$ npx skills add EveryInc/compound-engineering-plugin --skill ce-prototype -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install EveryInc/compound-engineering-plugin ce-prototype --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/EveryInc/compound-engineering-plugin.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/ce-prototype .claude/skills/ce-prototype && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "ce-prototype" agent skill from https://github.com/EveryInc/compound-engineering-plugin/tree/main/skills/ce-prototype into .claude/skills/ce-prototype/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "ce-prototype", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/EveryInc/compound-engineering-plugin/tree/main/skills/ce-prototypeType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add EveryInc/compound-engineering-plugin --skill ce-prototype -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install EveryInc/compound-engineering-plugin ce-prototype --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/EveryInc/compound-engineering-plugin.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/ce-prototype .agents/skills/ce-prototype && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "ce-prototype" agent skill from https://github.com/EveryInc/compound-engineering-plugin/tree/main/skills/ce-prototype into .agents/skills/ce-prototype/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "ce-prototype", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add EveryInc/compound-engineering-plugin --skill ce-prototype -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install EveryInc/compound-engineering-plugin ce-prototype --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/EveryInc/compound-engineering-plugin.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/ce-prototype .cursor/skills/ce-prototype && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "ce-prototype" agent skill from https://github.com/EveryInc/compound-engineering-plugin/tree/main/skills/ce-prototype into .cursor/skills/ce-prototype/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "ce-prototype", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/EveryInc/compound-engineering-plugin.git --path skills/ce-prototype--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add EveryInc/compound-engineering-plugin --skill ce-prototype -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install EveryInc/compound-engineering-plugin ce-prototype --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/EveryInc/compound-engineering-plugin.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/ce-prototype .gemini/skills/ce-prototype && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "ce-prototype" agent skill from https://github.com/EveryInc/compound-engineering-plugin/tree/main/skills/ce-prototype into .gemini/skills/ce-prototype/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "ce-prototype", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install EveryInc/compound-engineering-plugin ce-prototypeInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add EveryInc/compound-engineering-plugin --skill ce-prototype -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/EveryInc/compound-engineering-plugin.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/ce-prototype .github/skills/ce-prototype && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "ce-prototype" agent skill from https://github.com/EveryInc/compound-engineering-plugin/tree/main/skills/ce-prototype into .github/skills/ce-prototype/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "ce-prototype", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add EveryInc/compound-engineering-plugin --skill ce-prototype -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install EveryInc/compound-engineering-plugin ce-prototype --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/EveryInc/compound-engineering-plugin.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/ce-prototype .opencode/skills/ce-prototype && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "ce-prototype" agent skill from https://github.com/EveryInc/compound-engineering-plugin/tree/main/skills/ce-prototype into .opencode/skills/ce-prototype/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "ce-prototype", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Facts
- Skill name
ce-prototype- GitHub stars
- 25k
- Token cost
- ~1.9k tokens
- SKILL.md length
- 1,172 words
- Files
- 10 (incl. scripts, references, assets)
- Skills in repo
- 37
- Repo updated
- First seen
- Licence
- MIT
At a glance
Builds a throwaway prototype at just the fidelity needed to settle a specific how-it-should-work-or-feel question, before committing to an approach other work will treat as fixed.
- An approach would be expensive to unwind once committed and a cheap sketch cannot settle it
- SKILL.md covers Scope the question, Build it, Keep the decisions and Apply or continue
- Runs JavaScript scripts from its folder; calls git
- Deciding how a flow or state model should actually behave by driving a working version
What it does
The skill's core rule is not to fake the dimension being tested: a question about how a flow or state model behaves is settled only by driving a working version of it, while a question about how a layout or a visual mark reads is settled only by seeing it at real finish, so a screen that merely looks right or a thin sketch each fail to answer their respective question. The person's own perception settles the question, not the builder's judgment of the result, and the skill explicitly refuses to run unattended for a pipeline or headless caller with no human present to experience the prototype.
Work starts by reading a scoping reference before asking the user anything or touching the repository; that reference defines how the question arrives, a scoped read of only the repo parts the question touches rather than a tree scan, narrow versus wide framing, sizing, and how remaining questions change after each decision, and building does not start until the user has authorized it, with a request that already names a thing to prototype counting as that authorization.
Other reference files cover the build itself, an annotation loop with bundled CSS and JS for marking up the prototype, a light preview webserver, and writing decisions back once the user has settled them, feeding into a Product Contract or a brainstorm or plan skill.
When your agent uses it
- An approach would be expensive to unwind once committed and a cheap sketch cannot settle it
- Deciding how a flow or state model should actually behave by driving a working version
- Deciding how a layout or visual mark should read by seeing it at real finish
Example prompts
- “Prototype how the checkout flow should behave when a coupon is invalid, so we can decide before building it for real.”
- “Build a real-finish prototype of this card layout so I can judge how it reads.”
- “I need to see this interaction working, not just mocked up, before we commit to it.”
Requirements
- A human present to experience and judge the prototype
What it can do on your machine
Read from SKILL.md and the folder at commit cef001f. It shows what the files ask for, not the result of running them.
Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
Ships 1 file in scripts/ (JavaScript), which the agent can run.
Shell commands in SKILL.md call:
git
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Context cost
Compound Engineering Prototype loads about 1.9k tokens when it runs, and up to ~10k if it reads all its reference files. Until then it costs about 88 tokens; SKILL.md has 1,172 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
Safety
Auto-check passed
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.
SKILL.md
The full file from EveryInc/compound-engineering-plugin at commit cef001f, republished under its MIT licence (© EveryInc). 1,172 words, ~1,940 tokens.
Download SKILL.mdSave it as
.claude/skills/ce-prototype/SKILL.md (or your agent's skills folder). This skill also uses 9 other files; get the full folder from GitHub.- name
- ce-prototype
- description
- Build a throwaway prototype to answer how something should work, feel, or read. Use when committing the wrong answer would be expensive to unravel and a cheap sketch cannot settle it. Not a rough visual probe during brainstorming, not for deciding what to build, not polishing a feature that already works, not implementing the real thing.
- argument-hint
- [prompt, brainstorm path, or plan path]
Prototype
Build a throwaway prototype at the fidelity that can answer this question, before committing an approach later work will treat as given. Then apply the decisions or hand off.
Do not fake the dimension being tested. Modality, fidelity, and medium all follow from that one rule. A question about how a flow or state model behaves is settled by driving it, so a screen that only looks like the product does not answer it. A question about how a layout or a mark reads is settled by seeing it at real finish, so a thin sketch does not answer it either. The user's own perception settles the question, never your judgment of the artifact.
Result: the user decided how the product should work or feel against a prototype that did not fake what they were deciding.
Next consumer: an existing markdown Product Contract, or ce-brainstorm / ce-plan with this session as the seed.
Done: the user settled the questions that needed an artifact, or they apply and continue into brainstorm or plan. Their choice is the settlement, not a direction you inferred.
Not: a decision a cheap sketch settles, polish, or shipping the prototype as a final product.
If there is no person to experience the prototype — mode:pipeline, a headless run, or a calling skill that reports no human is present — stop. Do not start a preview or invent how it should feel. Return that this skill needs a human. A calling skill that has a human present (an interactive lfg run, for example) is an ordinary attended run.
User-runnable invocation rendering. The attended re-run in that refusal and the next-skill recommendation when the user applies print invocation syntax. Default to /ce-prototype, /ce-brainstorm, and /ce-plan; use $ce-prototype, $ce-brainstorm, and $ce-plan only on Codex or a host that documents dollar-prefixed skill invocation. Render only the invocation as inline code; output one form only.
Scope the question
Read references/scoping.md before you ask the user anything or touch the repo. That read is not optional. It defines how the question arrives and the scoped repo read of what the question touches — do not scan the tree. It also defines narrow vs wide, sizing, the go-ahead message, and how the remaining questions change after each decision. Do not build until authorized. A request that already is to prototype a named thing is that authorization after scoping.
Build it
Read references/build.md and references/preview.md before writing anything. Once an isolated web preview is up, load references/annotation-loop.md. Overlay runs and non-web runs stay on chat.
After they proceed, speak only when they can act on something new, in one short line naming what happened: a screen is up, the helper URL is live, or a blocker only they can lift. That annotation loop defines the line after an applied revision and silence while a wait is parked.
A question is settled by seeing when the judgment lands on the rendered result: how a layout reads, what a palette does, how dense a screen feels. It is settled by driving when the judgment lands on what happens as the user moves through it: a flow, a state model, how a control answers. Load references/craft-floor.md for a seeing question. It carries the quality floor and the avenue-difference rule; neither lives here. A question settled by driving does not load it and gains no finish from it.
Default substrate: the web, whatever the product is written in — a native app's navigation feel gets a web approximation, not SwiftUI. references/build.md defines yields and artifacts.
Build under .context/compound-engineering/ce-prototype/<date>-<slug>/, so the prototype survives for the implementation that follows. Fall back to /tmp/compound-engineering-<uid>/ce-prototype/<date>-<slug>/, where survival is best-effort. references/build.md names every case that forces the fallback root.
The .context path has to be gitignored first. Probe it from the repo root with git -C <repo root> check-ignore -q .context/compound-engineering/; the trailing slash is required. When it is not covered, the offer to add that line comes before the root is resolved, or accepting it cannot help this run.
references/preview.md defines that offer and the resolution that follows it. Do not create the run directory yourself; a second claim splits the screens from the capsule.
Scale into the existing app as a throwaway overlay when the user asks, or when the question is density or chrome on an existing page — an isolated page hides that. It is the one path that touches the product tree. Never commit it. When the try ends, restore only the files you changed. If you cannot undo them cleanly, name the files you left modified rather than handing off a dirty tree. Never delete a kept prototype: throwaway describes the code, not a request to remove it.
Show full SKILL.md (396 more words)Show less
Keep the decisions
Keep a run capsule at decisions.md in this run's directory, so the next skill does not need this session. references/build.md lists what it carries. Point at the prototype; do not reproduce it. Include only what changes later planning. Do not treat decisions.md as a plan: applying writes the Product Contract or the recap, and the capsule is only continuity.
Update the capsule when you are confident a choice has settled — the user judged the artifact and chose, including any adjustments they attached. If you are not confident, do not write. Do not pause to confirm every write. Keep the winner and those adjustments in the prototype.
Read decisions.md before building for the next related question, and work out which questions are still worth building for. references/scoping.md defines how that list changes. If what they decided changed what they want to build rather than answering the question you asked, stop and hand back what you learned instead of building for a question they have moved past. Otherwise stay in this skill for it. Do not bounce to brainstorm or plan while a related question still needs an artifact, do not start an unrelated campaign, and do not keep prototyping once they apply.
Apply or continue
When the user applies:
- If this run has a directly related brainstorm or plan — passed on invoke, passed by the calling skill, or named in this session as the file this prototype is for — load
references/write-back.mdand follow it. Markdown and HTML both. Usedecisions.mdwhen present. Do not pick a plan because one exists in the repo. - If there is no such file or relatedness is unclear: do not mint a plan or a third note. Recap from
decisions.mdwhen present, carrying the decisions and, when the run left one behind, the prototype path — an overlay run has none, so say that rather than pointing at something you undid. That recap is a complete outcome, not a degraded one.
Then continue. If a calling skill invoked this, return the choices in decisions.md and let it continue. Otherwise recommend a next skill and pass this session as the seed. After a write-back, recommend ce-plan to regenerate implementation planning for the changed requirements. After a file-free run, recommend ce-brainstorm when product-level questions remain, or ce-plan when the session is enough to plan. Print that recommendation per the rendering rule above.
© EveryInc, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Files
SKILL.md and 9 other files (scripts, references, assets) in skills/ce-prototype of EveryInc/compound-engineering-plugin.
- SKILL.md
- assets/annotate.css
- assets/annotate.js
- references/annotation-loop.md
- references/build.md
- references/craft-floor.md
- references/preview.md
- references/scoping.md
- references/write-back.md
- scripts/light-webserver.js
Open the folder on GitHubat commit cef001f
Compare with similar skills
Compound Engineering Prototype next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Compound Engineering Prototype this skillEveryInc/compound-engineering-plugin | 25k | — | ~1.9k | Automated safety check: Pass | MIT | |
| Vibespopmechanic/VibesOS | 135 | — | ~2.6k | Automated safety check: Notes | MIT | |
| Loft Design PrototypingYeachan-Heo/oh-my-claudecode | 40k | — | ~1.4k | Automated safety check: Pass | MIT | |
| Spec Prototypeleo-kuang-ai/spec-first | 107 | — | ~1k | Automated safety check: Pass | MIT | |
| Native Feel Cross Platform Desktopyetone/native-feel-skill | 1.9k | 1 repos | ~1.5k | Automated safety check: Pass | MIT | |
| Collaborating With CodexGuDaStudio/collaborating-with-codex | 132 | 1 repos | ~712 | Automated safety check: Pass | MIT |
Similar skills
Loft Design Prototyping
Yeachan-Heo/oh-my-claudecode
Settles stalled design questions by building a throwaway artifact: either a pure logic module in a clickable shell, or three structurally different UI variants.
Spec Prototype
leo-kuang-ai/spec-first
Build a throwaway prototype to answer an unresolved product behavior or visual question before implementation.
Native Feel Cross Platform Desktop
yetone/native-feel-skill
A skill your agent uses when the user is designing, prototyping, or rewriting a desktop app that must run on multiple OSes (macOS + Windows, optionally Linux) AND feel indistinguishable from a…
Collaborating With Codex
GuDaStudio/collaborating-with-codex
Delegates coding tasks to Codex CLI for prototyping, debugging, and code review.
Digikey
aklofas/kicad-happy
Search DigiKey for electronic components and download datasheets — primary source for prototype orders and the preferred API method for fetching datasheets.
More from EveryInc/compound-engineering-plugin
All 37 skills in this repoCompound Learning Writer
EveryInc/compound-engineering-plugin
Records one solved and verified problem as a durable learning in the repository, but only when the reasoning is not already clear from the final code, tests or docs.
Compound Learnings Refresh
EveryInc/compound-engineering-plugin
Audits a repo's stored learnings against the current codebase, fixes stale, overlapping or superseded docs and reports on every document.
Compound Engineering Setup
EveryInc/compound-engineering-plugin
Checks Compound Engineering plugin health and repo-local config, or scaffolds a Compound Pack when you ask for one by id.
PR Babysitter
EveryInc/compound-engineering-plugin
Watches an open GitHub pull request over time, routing review comments and CI failures to other skills until the PR is ready to merge.
CE Brainstorm
EveryInc/compound-engineering-plugin
Turns a vague or ambitious feature idea into a requirements-only plan through dialogue with you, sized to the work, before any code is written.
Compound Engineering Code Review
EveryInc/compound-engineering-plugin
Runs a staged pull request or diff review using selected reviewer personas, checking the change against its stated intent and project standards before producing findings.
Related
Categories
Questions about Compound Engineering Prototype
What does Compound Engineering Prototype do?
Builds a throwaway prototype at just the fidelity needed to settle a specific how-it-should-work-or-feel question, before committing to an approach other work will treat as fixed. The skill's core rule is not to fake the dimension being tested: a question about how a flow or state model behaves is settled only by driving a working version of it, while a question about how a layout or a visual mark reads is settled only by seeing it at real finish, so a screen that merely looks right or a thin sketch each fail to answer their respective question. The person's own perception settles the question, not the builder's judgment of the result, and the skill explicitly refuses to run unattended for a pipeline or headless caller with no human present to experience the prototype.
When should I use Compound Engineering Prototype?
Compound Engineering Prototype fits situations like: an approach would be expensive to unwind once committed and a cheap sketch cannot settle it; deciding how a flow or state model should actually behave by driving a working version; deciding how a layout or visual mark should read by seeing it at real finish.
How do I install Compound Engineering Prototype in Claude Code?
Run `npx skills add EveryInc/compound-engineering-plugin --skill ce-prototype -a claude-code`. Or copy the skill folder (skills/ce-prototype in EveryInc/compound-engineering-plugin) into .claude/skills/ce-prototype in your project. Claude Code loads it when a task matches its description.
How do I install Compound Engineering Prototype in Codex?
Run `npx skills add EveryInc/compound-engineering-plugin --skill ce-prototype -a codex`. Or copy the skill folder (skills/ce-prototype in EveryInc/compound-engineering-plugin) into .agents/skills/ce-prototype in your project. Codex loads it when a task matches its description.
Can I use Compound Engineering Prototype in Cursor, Gemini CLI or GitHub Copilot?
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add EveryInc/compound-engineering-plugin --skill ce-prototype -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/ce-prototype, .gemini/skills/ce-prototype, .github/skills/ce-prototype and .opencode/skills/ce-prototype in your project.
What does Compound Engineering Prototype need to run?
Going by SKILL.md and its folder, Compound Engineering Prototype needs JavaScript for the scripts in its folder and the command-line tools its instructions call (git). Our summary lists: A human present to experience and judge the prototype.
Does Compound Engineering Prototype access the network?
SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.
Is Compound Engineering Prototype safe to install?
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.
What licence does Compound Engineering Prototype use?
Compound Engineering Prototype is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
How many tokens does Compound Engineering Prototype use?
About 1.9k tokens (SKILL.md is roughly 7.8k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 8.5k tokens, read only when the agent opens those files.
What are the alternatives to Compound Engineering Prototype?
Skills that share tags, products or a category with Compound Engineering Prototype: Vibes (popmechanic/VibesOS, 135 stars), Loft Design Prototyping (Yeachan-Heo/oh-my-claudecode, 40k stars), Spec Prototype (leo-kuang-ai/spec-first, 107 stars) and Native Feel Cross Platform Desktop (yetone/native-feel-skill, 1.9k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains Compound Engineering Prototype?
EveryInc (a GitHub organization) maintains it in EveryInc/compound-engineering-plugin, which has 25,412 GitHub stars. The repository holds 37 skills in this directory. The repository was last updated on October 7, 2026.
Source: EveryInc/compound-engineering-plugin on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.