Autoprompt Skill
A multi-agent skill for coding agents that layers coordination, execution, and independent review to cut failures by 45% on agentic coding tasks.
Adapter tests show allowlisted child dispatch, depth/parent-edge validation, mission-binding hash revalidation failing closed, explicit `/autoprompt` triggering, and interactive install/uninstall/doctor paths; CI uses SHA-pinned actions with minimal permissions. Deductions: the installer rewrites local agent configs but the source shown offers no per-change manifest or explicit user confirmation of exact writes; sensitive-data handling (telemetry, logs, tokens) is entirely unaddressed in the provided files.
package. declares zero npm runtime dependencies; requirements are explicitly listed (Node 20+, Python 3.11+, Bash 4.3+, PyYAML); CI runs across Node 20/22/24 and Windows with an extensive contract and lifecycle test suite. Deductions: user-facing failure behavior is only inferable from test fixtures (probe timeouts, binding denials); the concrete semantics of `doctor --strict` and error-message quality are not documented.
A per-provider support table lists nine agents with audited versions, plus a custom-agent compatibility guide and custom-model guide; capability boundaries for mode=/max_subs=/agents= are marked per provider, with distinct trigger syntax for Codex and Oh My Pi. Deductions: audience is developers already on these hosts; unsuitable scenarios are only footnoted ('may differ heavily' for small tasks) rather than systematically documented.
Documentation architecture is strong: contents, install, benchmarks, controls, workflow, examples, FAQ, and license are all present with FAQ answers split into dedicated files; MIT license text is in-repo and install/update/uninstall/check commands are complete. Deductions: no CHANGELOG exists, so the 1.0.4 version has no traceable history; CONTRIBUTING/SECURITY/SUPPORT are link-only and maintainer/update commitments cannot be verified from the provided files.
The 45% failure reduction (29→16) maps to one measured OpenCode run, and the ~3x time / ~2x token trade-off is honestly labeled a planning estimate, not a measurement; DeepSeek's score is explicitly flagged as non-comparable — a solid cost-benefit disclosure. Deductions: the benefit rests on a single run of a single provider; timing/token logs were not retained, and actual output usability cannot be confirmed statically.
A dedicated benchmark methodology/'evidence boundaries' doc is linked, and measured versus estimated figures are clearly separated (earning full marks for fact/inference separation); a benchmark-request template provides a traceability path. Deductions: everything is single-source self-attestation — no third-party reproduction or independent corroboration, and the benchmark doc itself is not among the provided files, so the '45%' figure can only be taken on the README's word.
- The installer writes into local coding-agent configurations and skill directories; inspect the writes in an isolated environment first and verify that `autoprompt uninstall` fully rolls back.
- The 45% failure reduction comes from a single measured OpenCode run; the ~3x time / ~2x token cost is an estimate and may not pay off on small tasks — validate on your own workload at small scale.
- The publisher is unverified and identity is unknown; audit the installer scripts in a controlled environment before adopting in production projects.
- Sensitive-data handling (logs, tokens, telemetry) is not mentioned anywhere in the provided files; organizations handling private code should assess data flows independently.
What does this agent do, and when should you use it?
Autoprompt is an MIT-licensed coding-agent skill (v1.0.4) distributed via npm from the Spielewoy/autoprompt-skill repository. It organizes work through a subagent hierarchy — coordinators, a manager, execution lanes, and independent checks — so no single agent plans, approves, and verifies its own output. It installs into nine supported coding agents: Claude Code, Codex, OpenCode, Kilo Code, VS Code, Prime Agent, Oh My Pi, DeepSeek Harness, and Reasonix. In a measured Terminal-Bench 2.1 run with OpenCode 1.18.7, solves went from 60/89 to 73/89 and failures dropped from 29 to 16 — a 45% reduction and +14.61 points. It runs locally and requires Node.js 20+, Python 3.11+, and Bash 4.3+, with run controls like `mode=`, `max_subs=`, and `agents=` for concurrency and model routing. The README is explicit about the trade-off: roughly 3x the time and 2x the tokens, estimates based on user reports rather than retained measurement logs.
You invoke it with /autoprompt <goal> ($autoprompt in Codex, /skill:autoprompt in Oh My Pi), optionally with concurrency controls: mode=tokensaver caps active subagents at six, mode=wide opens every ready lane, and mode=custom max_subs=N sets your own ceiling. The skill takes the goal through a loop of planning, build, review, tests, sign-off, and sweep: coordinator layers decompose the task, execution lanes implement it, and independent check layers verify results. Where the host supports it, agents= routes subagents to specific models; otherwise the active or parent model is inherited. Documented example goals include fixing a race condition with a regression test, building a booking flow end to end, comparing job-queue libraries against a codebase, and migrating models with limited parallelism. After installation, autoprompt doctor --strict checks all detected installations and autoprompt uninstall [PROVIDER] removes them.
- A developer on Claude Code or OpenCode whose agent keeps producing broken code, using Autoprompt to reduce failure rate.
- A team migrating many models or files, limiting parallel work with
mode=custom max_subs=4to avoid machine overload. - An engineer who wants a regression test written alongside every bug fix.
- A Codex user building a multi-step feature (e.g., a booking flow from API to checkout) with
mode=wideto open all execution lanes. - A developer comparing libraries or architectures who wants a researched recommendation grounded in their codebase.
What are this agent's strengths and limitations?
- Measured benchmark evidence: OpenCode 1.18.7 failures on Terminal-Bench 2.1 dropped from 29 to 16 (45% fewer), +14.61 points.
- Nine supported coding agents (Claude Code, Codex, OpenCode, Kilo, VS Code, Prime Agent, Oh My Pi, DeepSeek Harness, Reasonix), each with audited versions documented.
- Layered design separates coordination, management, execution, and independent judgment, preventing self-approval and self-verification by one agent.
- Install lifecycle is verifiable via
autoprompt doctor, update/repair flows, and per-provider uninstall.
- Significant cost: the README states roughly 3x the time and 2x the tokens, based on user experience reports, not measured logs.
- For very small tasks, the trade-off may differ heavily.
- Requires a local runtime with Node.js 20+, Python 3.11+, and Bash 4.3+ — not usable directly in purely cloud or GUI-only environments.
- Custom
agents=model routing works only on Claude Code and Codex; the other seven hosts inherit the current or parent model.
How do you install or deploy this agent?
Prerequisites: Node.js 20+, Python 3.11+ exposed as python with PyYAML, Bash 4.3+ on macOS/Linux; Git only for the source install. Install with npm install -g autoprompt-skill, then run autoprompt to launch the interactive installer, choose your coding agent, and confirm its path (enter N to supply a different path). From source: git clone https://github.com/Spielewoy/autoprompt-skill && cd autoprompt-skill && npm install -g . && autoprompt. Verify with autoprompt doctor --strict.
How do you use this agent?
Invoke explicitly inside a supported agent: /autoprompt <goal> in Claude Code/OpenCode, $autoprompt <goal> in Codex, /skill:autoprompt in Oh My Pi. Examples: /autoprompt fix the registration race and add a regression test; /autoprompt mode=wide build the booking flow from API to checkout; /autoprompt mode=custom max_subs=4 migrate every model. It does not start in the background; you trigger it each time.
How does this agent compare with similar options?
The README cites DeepSeek's own 82.7% Terminal-Bench 2.1 result as a reference point but explicitly notes it used DeepSeek's own test setup and is not a comparable third run.
FAQ
Does Autoprompt mean I literally do not have to prompt?
How autonomous is it?
What is the actual overhead?
Is my coding agent supported?
Why doesn't it start in the background?
/autoprompt <goal>.