Less noise. Less over-engineering. The right rigor where it matters.
Efficiency is a lightweight plugin for Agent Plugins v1 clients, Cursor, and Codex that makes agent work leaner without making it careless:
- match effort and validation to the actual risk,
- simplify designs and changed code without changing behavior,
- reduce recurring context and instruction bloat,
- use RTK and project filters safely, and
- keep responses direct, understandable, and actionable without losing important evidence.
RTK (Rust Token Killer) is optional; it trims noisy terminal output before it reaches the model. Efficiency adds no custom MCP server, telemetry, or background automation.
Across its four portable workflows, Efficiency starts with the outcome, translates non-obvious technical consequences into practical meaning, and names the next useful action when one exists. The guidance is written for mixed technical knowledge, preserves exact technical text, and does not force every answer into one template.
| Goal | Agent Plugins v1 | Cursor | Codex |
|---|---|---|---|
| Right-size work and validation | efficiency skill |
/efficiency |
$efficiency |
| Challenge design and code simplicity | efficiency skill |
/efficiency |
$efficiency |
| Reduce recurring context | context-optimization skill |
/optimize-context |
$context-optimization |
| Inspect or prepare RTK | rtk-setup skill |
/setup-rtk |
$rtk-setup |
| Design a safe RTK filter | rtk-filter-design skill |
/create-rtk-filter |
$rtk-filter-design |
| Keep responses concise | Not in the portable core | Automatic response-simplicity rule |
Optional $response-simplicity-setup |
Cursor also includes the optional read-only efficiency-auditor and rtk-filter-auditor. Codex can run the same checks through an inherited subagent when you explicitly request a second pass.
The Agent Plugins target contains four portable skills: efficiency, context-optimization, rtk-filter-design, and rtk-setup. Cursor exposes those four workflows as skills and slash commands. Codex discovers five skills: the same four portable skills plus its native response-simplicity-setup adapter.
npm run build:targets creates three isolated bundles:
| Target | Output | Surface |
|---|---|---|
| Agent Plugins v1 | .build/plugins/agent-plugins/geldmacher-efficiency |
Root plugin.json and exactly four portable skills |
| Cursor | .build/plugins/cursor/geldmacher-efficiency |
Cursor manifest, four skills, commands, agents, and rule |
| Codex | .build/plugins/codex/geldmacher-efficiency |
Codex manifest, four portable skills, and the private setup skill |
The portable manifest targets the Agent Plugins 1.0.0 Working Draft pinned in the vendored schema. It has no MCP server, extensions, commands, agents, rules, or hooks. Native bundles intentionally omit root plugin.json so manifest selection stays unambiguous.
The Codex manifest uses the documented ./skills/ root and .codex-plugin contains only plugin.json. The Codex-only setup skill is maintained under adapters/codex/skills in the repository and projected into the generated Codex bundle as skills/response-simplicity-setup; it never enters the Agent Plugins or Cursor targets.
On Agent Plugins clients other than Cursor or Codex, the portable skills use conservative host-neutral behavior. They inspect only documented context or RTK integration surfaces, report unknown host integration as unverified, and do not assume Cursor hooks or Codex guidance paths.
Efficiency is not yet available in a public plugin store. Keep the Git checkout as the canonical source and deploy generated host copies from it. Do not clone into ~/.cursor/plugins/local or ~/.codex/plugins; those directories contain managed deployment copies and are atomically replaced.
Install Git, Node.js 22 or newer, and npm. The selected host must also be installed: Cursor for a Cursor deployment, or the Codex CLI with plugin support for a Codex deployment.
mkdir -p ~/src/geldmacher-plugins
git clone https://github.com/geldmacher/efficiency.git ~/src/geldmacher-plugins/efficiency
cd ~/src/geldmacher-plugins/efficiency
npm ciIf you already have a checkout, use it instead and run npm ci from its repository root.
Choose one host or deploy both:
| Target | Preview without changing host state | Install or update |
|---|---|---|
| Cursor only | npm run deploy:local -- --dry-run --cursor-only |
npm run deploy:local -- --cursor-only |
| Codex only | npm run deploy:local -- --dry-run --codex-only |
npm run deploy:local -- --codex-only |
| Cursor and Codex | npm run deploy:local -- --dry-run |
npm run deploy:local |
Append --full to an install command to run the complete repository release-check before deployment. Inspect the current installed state with npm run deploy:status; add --cursor-only or --codex-only to limit that check to one host.
The deploy command builds and validates all three deterministic bundles, then atomically replaces only the selected Cursor and Codex copies. There is no Agent Plugins deploy flag; .build/plugins/agent-plugins/geldmacher-efficiency is a conformance, package, and client-integration output.
- Cursor:
~/.cursor/plugins/local/geldmacher-efficiency - Codex source:
~/.codex/plugins/geldmacher-efficiency
Every installed copy contains a .local-deploy.json receipt with its content-derived local version, Git revision, dirty status, source path, and deployment time. Dirty checkouts are allowed and explicitly recorded. For Codex, the command also creates or updates only this plugin's entry in the personal Marketplace and refreshes the verified Codex cache with codex plugin add geldmacher-efficiency@personal --json. Do not delete Codex caches manually.
After installation or an update, reload Cursor before testing its plugin surface and start a new Codex task before testing Codex discovery. Review changed hooks manually before granting trust. The deploy command does not restart either host or grant hook trust. See the Cursor plugin documentation and OpenAI's local plugin documentation.
First protect any local work, then fast-forward the checkout and redeploy:
cd ~/src/geldmacher-plugins/efficiency
git status --short
git fetch origin
git pull --ff-only
npm ci
npm run deploy:local -- --dry-run
npm run deploy:local
npm run deploy:statusInspect a dirty status before pulling; commit or stash intentional local changes rather than discarding them. git pull --ff-only refuses a divergent history instead of creating an implicit merge. npm ci synchronizes dependencies with the updated lockfile. The last three commands above update both hosts; use the matching --cursor-only or --codex-only flag when only one host is installed. An unchanged bundle is a verified no-op; changed content receives a new host-specific local version and replaces the previous copy transactionally.
Ask for the outcome you want; Efficiency infers whether you are planning, adjusting, or reviewing work.
/efficiency Keep this small refactor proportional and verify the risky paths.
/efficiency Challenge this design once for simplicity before implementation.
/efficiency Review the current changes for code simplicity.
/efficiency Review whether this bug investigation has a tight, proportionate feedback loop.
/efficiency Draft a verifiable pull request summary and identify open validation gaps.
/optimize-context Find recurring instructions that can be consolidated.
/optimize-context Reduce these agent instructions without weakening their trigger coverage.
/setup-rtk Inspect my RTK setup without changing it.
Use the matching $efficiency, $context-optimization, or $rtk-setup skill in Codex.
Design reviews use the supplied proposal as their scope. Without an explicit path, code review covers the current Git change set. If none exists, Efficiency asks for a focused scope instead of reviewing the entire repository.
For debugging or performance work, Efficiency can assess whether the investigation has a focused, fast, deterministic feedback loop. It recommends the next proportionate step but does not start diagnosis, instrumentation, tests, fixes, delegation, or artifact creation without separate authorization. Context optimization can also review agent-consumed documents, keeping universal instructions available while moving branch-specific material behind precise conditional references.
For commit messages, pull request descriptions, release notes, and change summaries, the efficiency workflow follows project conventions first. It distinguishes verified behavior, intended behavior, and open work; material claims should trace to the diff, a check, other evidence, or a labelled assumption. This is communication guidance, not proof that a change works.
- Skills are opt-in. Only Cursor loads the short response rule automatically.
- Review requests never edit code. Simplification requires an explicit scoped change request.
- RTK setup, filter trust, and global guidance changes are previewed before approval.
- Auditors are read-only; independent model work happens only when requested.
- Specialized design, debugging, and agent-document guidance loads only for the matching workflow branch.
- Concision never removes material evidence, uncertainty, risks, blockers, approvals, or validation status. Efficiency does not replace correctness, security review, project requirements, or host approvals.
- The communication guidance supports quick understanding and action, but repository checks cannot prove live activation or actual human comprehension.
- AI-Slop means low-value generated output here. The plugin judges observable utility, not whether content looks AI-written.
Design and code simplification preserve observable behavior, public interfaces, persisted formats, security, performance, and project conventions unless you authorize otherwise. The workflow challenges the current design once, recommends a smaller alternative only when it is materially better, and can conclude that the existing design is already proportionate. RTK statistics are cumulative unless a same-task baseline exists.
| Component | Requirement |
|---|---|
| Cursor | Local plugin support enabled |
| Codex | Plugin support enabled |
| RTK | Optional; 0.44.0 for the verified Cursor hook baseline, 0.44.2 for the verified Codex command baseline |
| Development | Node.js 22 or newer |
| Platform | macOS, Linux, or WSL for the documented RTK workflows |
Broad compatibility ranges are not certified yet; release receipts record exact tested versions.
Efficiency 2.0 removed the old aliases; 2.2 keeps the smaller surface:
| 1.x entry point | Replacement |
|---|---|
/budget-efficiency |
/efficiency with a before-work request |
/review-efficiency |
/efficiency with an in-progress or after-work request |
efficiency-budget |
efficiency |
efficiency-review |
efficiency |
context-change-auditor |
efficiency-auditor with a context focus |
npm ci
npm run release-check
git diff --checkThe release check validates all three manifests and target bundles, Agent Skills discovery and frontmatter, path containment, version alignment, links, and policy contracts. Source links exclude ignored .build output, while every newly generated target is checked directly for bundle-local links. It proves repository format and bundle state—not installation, live host behavior, broad client compatibility, Marketplace state, or publication.
Before a release, complete the release checklist. Runtime checks remain separate: Agent Plugins runtime smoke, Cursor runtime smoke, and Codex runtime smoke.
- Missing in Cursor: verify the local path and
.cursor-plugin/plugin.json, then reload Cursor. - Missing in Codex: verify the personal marketplace entry and
.codex-plugin/plugin.json, reinstall, restart Codex, and open a new task. - Rejected by an Agent Plugins client: inspect that client's stated v1 support, then test only the generated
agent-pluginsbundle; repository conformance does not certify every client. rtk gainfails: verify that Rust Token Killer—not anotherrtkbinary—is installed.- Project filters are skipped: run
rtk verify --require-all, complete RTK's trust flow, and re-trust after every filter edit. - Codex response guidance is inactive: run
$response-simplicity-setupfor status; manifest installation alone does not activate global guidance.