Your prompt sucks. Let's fix that.
What's new (v13 — RePrompter v2): two intents (improve my prompt / build this whole thing), specifiability routing, One-Shot build prompts, team execution seeded from a build brief — digest
RePrompter is a prompt engineering skill for AI coding agents. It takes rough, low-quality prompts and transforms them into structured, high-scoring prompts that produce dramatically better results. Templates are aligned with 2026 vendor guidance: clear sectioning, calibrated emphasis, outcome-first instructions, load-bearing constraints, structured-output routing, context budgeting, and tool-description quality. Works with Claude Code, OpenClaw, Codex, Grok CLI, Hermes Agent, or any LLM that accepts structured prompts.
| You say | You get |
|---|---|
| "reprompt this: ..." — make my prompt better | Interview → the right shape for the job: a structured, scored spec prompt for bounded work, or an autonomous build prompt for whole-product asks (announced, overridable) |
| "one-shot this: ..." — build this whole thing | Plain-language interview (max 4 questions) → a prose build prompt that finishes in one session — or, on request, the same brief split across an agent team |
Where the result goes. Improve outputs can be pasted (default), compressed to a /goal command (Codex, Claude Code, Hermes), compiled to a runnable Claude .workflow.js, or delivered to another model via headless-relay. Build runs as one prompt or splits across a team. Everything that used to be a separate "lane" is now one of these — a format the result takes or the way it executes.
Nothing was removed. Team execution (repromptverse, smart run, swarm triggers), the /goal and Workflow formats, cross-model relay delivery, and Reverse mode (extract the prompt DNA from a great output) all work exactly as before — see SKILL.md. v13 changed the map, not the machinery: every v12 trigger still routes to its intent. The one behavior change is honest and opt-out — a clearly whole-product "reprompt this" now offers an autonomous build prompt (say "spec" for the old structured, scored output); bounded and ambiguous asks stay spec-XML exactly as before.
Input: "uhh build a crypto dashboard, maybe coingecko data, add caching, test it too"
Score: 1.6/10
Output: Structured XML prompt with role, context, task, requirements,
constraints, output format, and success criteria
Score: 9.0/10 (+462%)See the full generated prompt
<role>
Senior full-stack engineer specializing in real-time dashboard systems,
REST API integration, and cache-aware data pipelines.
</role>
<context>
- Frontend + backend + tests required (cross-layer scope)
- Data source: CoinGecko API (free tier, 30 calls/min rate limit)
- Existing API behavior must be preserved
</context>
<task>
Deliver a real-time crypto dashboard backed by a cache-aware CoinGecko proxy API,
with unit tests for both API and UI, without breaking existing API contracts.
</task>
<requirements>
- Build dashboard UI with loading, error, empty, and stale-data states
- Implement backend CoinGecko proxy with JSON schema validation + configurable cache TTL
- Preserve backward compatibility for all existing API consumers
- Add deterministic unit tests for frontend rendering states and backend edge cases
- Cache must serve stale data on upstream failure (stale-while-revalidate pattern)
</requirements>
<constraints>
- No direct client-side calls to CoinGecko (all traffic through proxy)
- No breaking changes to existing API response fields or status codes
- Mock all external network boundaries in tests
- Rate limit CoinGecko calls to stay within free tier (30/min)
</constraints>
<output_format>
- Backend: /api/prices endpoint returning { prices: [...], cached: bool, updatedAt: ISO }
- Frontend: React component with 5s auto-refresh interval
- Tests: Vitest suite with >=80% branch coverage
</output_format>
<success_criteria>
- Dashboard auto-updates every 5s and shows "stale" indicator when cache is old
- Proxy returns normalized data within 200ms (cache hit) / 2s (cache miss)
- Existing API integration tests still pass with zero modifications
</success_criteria>| Dimension | Before | After | Change |
|---|---|---|---|
| Clarity | 3 | 9 | +200% |
| Specificity | 2 | 9 | +350% |
| Structure | 1 | 10 | +900% |
| Constraints | 0 | 8 | new |
| Verifiability | 1 | 9 | +800% |
| Decomposition | 2 | 9 | +350% |
| Overall | 1.6 | 9.0 | +462% |
Scores are self-assessed. Treat as directional indicators, not absolutes.
You say: one-shot this: a first-person shooter like the recent Call of Duty games, in the browser
RePrompter asks a few plain questions, then emits one prose build prompt you paste into any coding agent. It names a real reference, staffs the work with a separate harsh critic that judges the running artifact (never the builder's summary), and ends on a checkable bar. The image below is one real frame from a single maximal-mode dogfood run — a browser FPS in a self-contained HTML file, textures/models/audio generated in code — captured at the 269 FPS shown top-left. It is one run's result, not a guarantee for every run:
Two dogfood runs, same lane:
| Mode | Prompt | Result |
|---|---|---|
| Default (one session) | Vampire-Survivors-style browser roguelite | a naive "build me X" prompt produced only scaffolding — a module contract, a build system, a test harness, no game; the One-Shot prompt produced a complete playable game (146 kills, level 7, ~70fps with 200+ enemies in an automated soak test) |
| Maximal (opt-in) | the CoD-style FPS above | one run: 7 sub-agents in isolated repo copies judged each round against 10 real Call-of-Duty stills; ~11.8k lines / 34 modules. Rough edges remain (see below) |
Lands at a strong working prototype — expect to keep iterating after it stops. It does not produce a shipped AAA title; the FPS above still has rough edges (muzzle-flash bloom, one stray additive box), and the honest close says so up front.
Credit where the shape came from: the one-prompt build pattern is @mattshumer_'s — a CoD-like browser FPS from 152 dictated words — reproduced and dissected by @ziwenxu_ as the "Gauntlet Loop" (name a real bar, separate builder from critic, loop on real output). RePrompter's One-Shot template is that shape made fillable, plus the checklist stop so a run ends on its own instead of at your rate limit.
Recommended: install the Claude Code plugin. One install registers the RePrompter skill namespace and both Ambient Prompt Gate hooks; future updates use Claude Code's native plugin update flow.
/plugin marketplace add AytuncYildizli/reprompter
/plugin install reprompter@reprompter
If you previously installed ~/.claude/skills/reprompter, remove that personal copy before using the plugin. Personal skills shadow/duplicate plugin skills, so leaving it in place can make Claude Code load the old copy instead of /reprompter:reprompter.
The plugin ships the Ambient Prompt Gate enabled for Claude Code UserPromptSubmit and Stop. Use REPROMPTER_AMBIENT=0 as the per-feature off switch; Claude Code's disableAllHooks still disables all hooks, including plugin hooks.
Fallback for copy-based or non-plugin setups:
mkdir -p skills/reprompter
curl -sL https://github.com/aytuncyildizli/reprompter/archive/main.tar.gz | \
tar xz --strip-components=1 -C skills/reprompterSource archives are runtime-only (.gitattributes export-ignore): they contain SKILL.md, references/, and scripts/ but not dev/dist trees like skills/ (the Hermes-only install package — see Install paths), plugin/, .claude-plugin/, benchmarks/, assets/, or docs/. Plugin installs use git clone through Claude Code's marketplace flow, so export-ignoring the plugin tree does not affect plugin installs. Installed an older full copy? It's safe to delete those directories from it — upgrades won't bring them back.
For the /goal output format on Claude Code, pin the CLI to v2.1.139 or later. /goal depends on the hooks layer — if disableAllHooks or allowManagedHooksOnly is set in settings.json the command is unavailable on any version (v2.1.140 only made the failure visible). Managed environments that block hooks should stick to Single mode for goal-shaped work.
claude --version
# Expect 2.1.139 or later. Upgrade if older.Copy-based RePrompter installs can tell you when they are behind the latest release. Claude Code plugin installs stay silent here because native plugin update detection owns freshness. On the first invocation in a copy-based session, RePrompter runs a fail-soft check (scripts/version-check.js) that compares your local SKILL.md version against the latest GitHub release and prints a notice only if you're behind (silent when up to date). The result is cached ~24h (keyed by repo), so repeat runs add no latency; the first uncached check waits up to ~3s for GitHub, then fails soft and silent if it can't reach it (a failed lookup is cached ~1h so offline sessions don't repeat the timeout). Disable it entirely with REPROMPTER_VERSION_CHECK=0.
The notice's upgrade command is path-aware: it re-fetches into the exact directory this skill is installed in, so it works the same whether you run Claude Code (~/.claude/skills/reprompter), Codex (~/.codex/skills/reprompter), OpenClaw, Grok CLI, or a project-local skills/reprompter/. (Hermes installs ship no scripts/, so the check doesn't run there — use hermes skills install to update.)
Run it manually any time:
cd skills/reprompter # run from the skill's install dir (where scripts/ lives)
node scripts/version-check.js # prints a notice only if behind; silent otherwise
node scripts/version-check.js --json # explicit status: {local, latest, behind, notice}To get nudged at session start (Claude Code, opt-in), add a SessionStart hook in ~/.claude/settings.json:
{
"hooks": {
"SessionStart": [
{ "hooks": [ { "type": "command", "command": "node /absolute/path/to/skills/reprompter/scripts/version-check.js" } ] }
]
}
}Because a skill is cached per session, after updating you must start a new session for the new version to load.
Root SKILL.md is canonical for Claude Code, Codex, OpenClaw, Grok, and direct GitHub browsing. skills/reprompter/ is the Hermes-only installable package, generated from root and sanitized for Hermes Skills Guard.
Run copy-based installs from the parent directory that contains a cloned or downloaded reprompter/ folder:
mkdir -p /path/to/workspace/skills
cp -R reprompter /path/to/workspace/skills/For Hermes Agent v0.14+, prefer the generated install package so Skills Guard scans only the runtime skill artifact:
hermes skills install AytuncYildizli/reprompter/skills/reprompterAvoid using the two-part Hermes identifier as the primary install command because it can resolve stale marketplace content:
hermes skills install AytuncYildizli/reprompterHermes Agent's default manual skill location is ~/.hermes/skills/reprompter/. The skills/ package is excluded from GitHub source archives, so a manual copy needs a git clone (or any hermes skills install form above), not a tarball/ZIP download:
git clone https://github.com/AytuncYildizli/reprompter.git
mkdir -p ~/.hermes/skills
cp -R reprompter/skills/reprompter ~/.hermes/skills/For Codex, install or update the CLI and confirm the goals feature is available:
npm install -g @openai/codex@latest
codex --version
codex features list | grep '^goals'If goals is present but disabled, set features.goals = true in ~/.codex/config.toml and start a fresh Codex session before using /goal.
Use SKILL.md as the behavior spec. Templates are in references/.
Improve a prompt — the everyday case. RePrompter picks the shape for the job: a structured, scored spec prompt for bounded work, or an autonomous build prompt for whole-product asks (announced, and you can say "spec" to override).
reprompt this: build a REST API with auth and rate limiting
Build a whole thing — one prompt that makes the app, game, or site. Finishes in one session; ask for a team and the same brief splits across agents.
one-shot this: a focus timer app like a clean pomodoro tool
Advanced: extract the prompt DNA from a great output you want to reproduce.
reverse reprompt this: [paste a great output you want to reproduce]
RePrompter interviews you when interactive clarification is useful, generates the prompt, and (for spec prompts) shows a before/after quality score.
Formats an Improve result can take — /goal command, Workflow script, cross-model relay
Use RePrompter before /goal whenever the goal is bigger than a single direct instruction. The lane works on Codex CLI (any version exposing the goals feature), Claude Code CLI v2.1.139+ (native /goal slash command shipped on 2026-05-11), and Hermes Agent (persistent goals in the v0.13.0 / 2026.5.7 release). These runtimes shape the command as /goal <objective>, so RePrompter first builds the full expanded prompt, then compresses it into a dense copy-pasteable /goal <summary of expanded prompt> command. The command should read like a summary of the old long XML prompt, not a tiny rewrite of the rough input.
reprompt this for /goal: migrate our billing dashboard to the new API without breaking existing reports
Add an explicit runtime marker when you have one — "Codex /goal", "Claude Code /goal", or "Hermes /goal" — otherwise RePrompter will ask. RePrompter then shows a Goal Command Card:
| Field | Example (Claude Code) |
|---|---|
| Goal Command | /goal Migrate billing dashboard API usage to the new API by first mapping current data/report consumers, preserving schemas, filters, exports, scheduled outputs, and historical totals, implementing the smallest compatible adapter changes, adding parity fixtures, and proving compatibility with unit, integration, dashboard smoke, and report export checks. |
| Compressed From | Expanded RePrompter prompt |
| Objective | Migrate billing dashboard API usage without breaking reports |
| Runtime | Claude Code CLI (≥ v2.1.139) |
| Mode | /goal preflight |
| Paste Into | Claude Code TUI prompt, as-is |
| Risk Level | medium |
| Missing Inputs | API contract diff, report smoke path |
| Verification | npm run check, dashboard smoke, report export check |
| Quality | 3/10 → 8/10 |
For Codex or Hermes, the Card differs only in the Runtime (Codex CLI or Hermes Agent) and Paste Into rows.
Then run the generated command in your chosen runtime:
/goal Migrate billing dashboard API usage to the new API by first mapping current data/report consumers, preserving schemas, filters, exports, scheduled outputs, and historical totals, implementing the smallest compatible adapter changes, adding parity fixtures, and proving compatibility with unit, integration, dashboard smoke, and report export checks.
On Claude Code (v2.1.139+) the goal is thread-persistent — it survives /resume, terminal close, and context compaction — and a Haiku evaluator checks the completion condition against the transcript after each turn. Use /goal pause and /goal resume to handle interruptions. On Codex (alpha) the same /goal <objective> shape applies once features.goals = true in ~/.codex/config.toml and a fresh session is started. On Hermes Agent, /goal is also persistent and supports /goal status, /goal pause, /goal resume, and /goal clear; Hermes defaults to a bounded continuation loop and survives /resume.
For automation surfaces such as Whip, the same contract is available as a local runtime command:
node scripts/goal-command.js \
--input "migrate our billing dashboard to the new API without breaking reports" \
--target codex \
--out-dir /tmp/reprompter-goalIt writes goal-command.json, goal-command.txt,
goal-command-card.json, reprompter-expanded-prompt.md, and
compressed-goal-summary.txt. The command is artifact generation only; it does
not execute /goal, dispatch agents, read secrets, or touch production. The same /goal <objective> output also pastes directly into Claude Code v2.1.139+ and Hermes Agent — dedicated --target claude-code / --target hermes switches are planned for a follow-up release; until then the existing --target codex artifact text is shape-compatible with both /goal surfaces.
reprompter teams - audit the auth module for security and test coverage # run a Build/audit across agents
reverse reprompt this: [paste a great output] # extract the prompt DNA
Rough prompt → Input guard → Interview (2-5 questions) → Specifiability router
→ spec-XML (enumerable done-state) OR outcome-prose (quality-bar ask, announced)
→ Quality scoring (spec only) → Delta rewrite if < 7/10 → optional output format
18 validated templates cover feature, bugfix, refactor, testing, API, UI, security, docs, content, research, workflow, and multi-agent swarm patterns. The router picks spec-XML for bounded work and the One-Shot prose shape for whole-product asks; you can always override.
Idea → plain-language interview (max 4) → done-list brief
→ one prompt (default, finishes in one session) OR split across a team
The prose brief names a real reference, staffs parallel work with a separate harsh critic that judges the running artifact, and ends on a checkable done-list. Picking a team seeds the Repromptverse engine: each work area becomes an agent scope, the done-list becomes the team's success criteria, the critic becomes the Phase-4 evaluator, and the smoothing pass becomes synthesis.
Repromptverse → Plan Cards → per-agent prompt → execute → Result Cards → evaluate → retry (max 2)
Reverse → exemplar → EXTRACT structure → ANALYZE type/domain/tone → SYNTHESIZE prompt → flywheel
Repromptverse is the team-execution engine (standalone or seeded by a Build brief). Reverse extracts a reusable prompt from a great output and seeds the flywheel — solving its cold-start problem with known-good prompt/output pairs.
Closed-Loop Flywheel (v12) - The loop is now end-to-end. Every prompt emits a <success_criteria> block of testable assertions. After execution, scripts/outcome-record.js writes a structured record joining prompt + criteria + output; scripts/evaluate-outcome.js scores it against the criteria (regex / predicate / llm_judge / manual). Records feed into a local flywheel via npm run flywheel:ingest. At generation time, REPROMPTER_FLYWHEEL_BIAS=1 makes the skill consult past outcomes and bias toward historically winning recipes. npm run flywheel:ab compares bias-on vs bias-off effectiveness so you can prove whether the bias is helping. npm run flywheel:export and npm run flywheel:import move privacy-sanitized aggregate ledger packs across your own fleet without RePrompter networking. All data local.
Prompt Flywheel Recipe Fingerprinting - Every prompt carries a deterministic recipe fingerprint (template + patterns + capability tier + domain + context layers + quality bucket). Strategy learner groups outcomes by fingerprint so recommendations are grounded in repeated evidence, not one-off runs.
Ambient Prompt Gate (v12.13) - Opt-in Claude Code, Codex CLI, and Hermes Agent prompt hooks score task-shaped prompts locally and silently nudge only when the request is below threshold. Claude Code also records the boolean Stop-hook acceptance outcome. The gate is fail-soft, never blocks a prompt, dedupes outcomes, and writes no prompt or transcript text to the local outcome log (called telemetry in the code) or state.
Agent Cards - Plan Cards (before execution), Status Line (during), Result Cards (after). Full transparency into what agents will do, are doing, and found.
Advisory Run Supervisor (v12.15) - scripts/run-supervisor.js --advise reads local run telemetry and returns healthy, stalled, failing-evals, completed, or unknown verdicts for the orchestrator. It is read-only and advisory: it never kills, restarts, spawns, or messages workers.
Dimension Interview - Low-scoring prompt dimensions trigger targeted questions for interactive use. Autonomous goal/workflow/team lanes document reasonable defaults in <assumptions> instead of blocking on low-value questions.
Pattern Library - 7 pluggable prompt engineering patterns: runtime-aware constraint placement (constraint-first-framing compatibility key), uncertainty labeling, self-critique checkpoints, delta retry scaffolds, evidence-strength labeling, context-manifest transparency, and tool-description quality.
2026 Template Alignment - Templates keep validated structure, roles, success criteria, and delta retries while updating contested guidance: XML is the default but not mandatory, schemas route to structured-output APIs when available, prompts emphasize outcomes over hand-written plans, and constraints stay load-bearing rather than exhaustive.
Capability Routing - When multiple models are available, routes each agent by capability tier (reasoning, long context, cost-optimized, latency-optimized) with provider-diverse fallback chains.
RePrompter never transmits or collects anything from anyone. The Ambient Prompt Gate and flywheel write local files only on the user's own machine:
- Gate state and outcome log:
$XDG_CACHE_HOME/reprompter/ - Flywheel and runtime telemetry runs:
.reprompter/
No prompt or transcript text is ever persisted. Session ids are sha256-hashed before they are written.
Fleet flywheel packs are sanitized aggregates only: no prompt text, prompt hashes, task slugs, role labels, or hostnames are exported.
The single network call in the entire product is the version self-check (scripts/version-check.js) querying the GitHub releases API for the latest RePrompter release. It sends no user data and can be disabled with REPROMPTER_VERSION_CHECK=0.
You can inspect the local files, delete them anytime, and kill the gate log with REPROMPTER_TELEMETRY=0. To verify the local-only gate directly, read scripts/prompt-gate.js and scripts/stop-gate.js: they have no network imports.
npm run check # 334 tests + 4 benchmarks
npm run test:reverse-engineer # individual suite example| Suite | Tests |
|---|---|
| Intent router | 25 |
| Reverse engineer | 43 |
| Outcome collector | 43 |
| Strategy learner | 36 |
| Recipe fingerprint | 14 |
| Repromptverse runtime | 9 |
| Capability policy | 7 |
| Pattern selector | 10 |
| Runtime adapter | 5 |
| Flywheel E2E | 5 |
| Flywheel sync | 5 |
| Context builder | 3 |
| Artifact evaluator | 4 |
| Goal command | 11 |
| Workflow command | 20 |
| Version check | 21 |
| Prompt gate | 34 |
| Stop gate | 10 |
| Run supervisor | 10 |
| Hermes package | 8 |
| Claude Code plugin package | 10 |
| Telemetry schema/store | 6 |
| Observability report | 2 |
| Observability contract | 3 |
| Total | 344 |
All benchmarks at 100%: swarm routing (9/9), real-world routing (64/64), artifacts (84/84), flywheel (13/13), provider (9/9).
| Capability | Claude Code | Codex | OpenClaw | Grok CLI | Hermes Agent | Any LLM |
|---|---|---|---|---|---|---|
| Single mode | yes | yes | yes | yes | yes | yes |
/goal preflight |
yes¹ | yes | - | - | yes² | - |
| Reverse mode | yes | yes | yes | yes | yes | yes |
| Multi-agent parallel | yes | yes | yes | yes | yes | - |
| Multi-agent sequential | yes | yes | yes | yes | yes | yes |
| Workflow preflight / Option H | yes³ | - | - | - | - | - |
| Ambient gate | yes | yes | - | - | yes⁴ | - |
| Relay delivery (headless-relay) | yes⁵ | yes⁵ | yes⁵ | - | yes⁵ | - |
¹ Claude Code /goal requires CLI v2.1.139+ (shipped 2026-05-11) and depends on the hooks layer. Under disableAllHooks or allowManagedHooksOnly in settings.json, /goal is unavailable on any version — v2.1.140 only upgraded the failure mode from a silent hang to a clear error message. No config flag needed beyond the version pin in environments that permit hooks; managed environments that block hooks must use Single mode for goal-shaped work.
² Hermes Agent /goal is documented in the v0.13.0 / 2026.5.7 release. It uses the same /goal <objective> command shape, with /goal status, /goal pause, /goal resume, and /goal clear available in the runtime.
Codex parallel paths: D1 native subagents (Codex CLI 0.121.0+, multi_agent default-enabled) or D2 shell-level (codex exec --ephemeral --sandbox workspace-write + background + wait; workspace-write is required for workers to write their /tmp/rpt-*.md artifacts, and codex exec keeps approval = never automatically). See SKILL.md Option D and references/runtime/codex-runtime.md.
Grok parallel paths: F1 native subagents (spawn_subagent) or F2 shell-level (grok -p ... & + wait). Grok does not expose /goal.
Hermes parallel paths: G1 delegate_task batch for normal Repromptverse, G2 shell-level (hermes -z / hermes chat -q + background + wait) for external orchestration, or G3 Kanban for durable multi-profile workflows. See references/runtime/hermes-agent-runtime.md.
³ Claude dynamic Workflow tool (Option H + the Workflow preflight lane): RePrompter compiles the reprompted task into a runnable .workflow.js (JS-scripted background fan-out — agent()/parallel()/pipeline() with schema-validated returns and resumeFromRunId). Picked at Order 4, just below Option B, because the Workflow tool has no mid-run cross-agent messaging. First-class ultracode (adversarial verify + completeness critic + budget-scaled fleets) with a --no-ultracode off-ramp. See references/runtime/claude-workflow-runtime.md. Compiler: scripts/workflow-command.js.
⁴ Hermes Agent installs ship no scripts/ helpers, so the Ambient Prompt Gate needs a git clone or copied checkout that includes scripts/prompt-gate.js.
⁵ Requires the headless-relay skill (v1.3.1+) installed in the same session — its README documents install paths for Claude Code, Codex CLI, OpenClaw, and Hermes. The offer is availability-gated: only targets whose CLI is installed and authenticated are listed (built-in lanes plus user-connected custom/local targets), and when none are available — or the relay skill is absent — the step is completely silent. Grok CLI is a relay target, not a documented headless-relay host. The Grok target additionally requires headless-relay v2.0.0+, which isolates Grok fail-closed in a non-git directory (v3.0.0 recommended — it also runs Grok under a hermetic env -i with a clean HOME/temp GROK_HOME and its cross-tool config scan off, so your global ~/.grok rules do not leak into the model turn); on an older relay, do not deliver to Grok.
Claude Code plugin installs register the prompt and Stop hooks automatically. For copy-based Claude Code installs, add them manually:
{
"hooks": {
"UserPromptSubmit": [
{ "hooks": [ { "type": "command", "command": "node /absolute/path/to/skills/reprompter/scripts/prompt-gate.js" } ] }
],
"Stop": [
{ "hooks": [ { "type": "command", "command": "node /absolute/path/to/skills/reprompter/scripts/stop-gate.js" } ] }
]
}
}For Codex CLI copy-based installs, add a documented hook definition:
{
"hooks": {
"UserPromptSubmit": [
{
"hooks": [
{
"type": "command",
"command": "node /absolute/path/to/skills/reprompter/scripts/prompt-gate.js --format=codex",
"timeout": 10
}
]
}
]
}
}Review and trust the command via /hooks; changing the command requires re-trusting because Codex keys trust to the hook definition hash. Codex's [features] hooks = false disables all hooks.
For Hermes Agent, use a clone or copied checkout that includes scripts/, then document the shell hook in ~/.hermes/config.yaml:
hooks:
pre_llm_call:
- command: "node /absolute/path/to/skills/reprompter/scripts/prompt-gate.js --format=hermes"
timeout: 5Hermes asks for first-use approval per (event, command); non-TTY runs need HERMES_ACCEPT_HOOKS=1 or hooks_auto_accept: true. pre_llm_call cannot block, matching RePrompter's never-block contract.
Ambient flags: REPROMPTER_AMBIENT=0 disables nudges and outcome recording, REPROMPTER_AMBIENT_THRESHOLD changes the default score threshold (5), REPROMPTER_AMBIENT_COOLDOWN_MIN changes the per-session cooldown (15), and REPROMPTER_TELEMETRY=0 disables the privacy-safe gate local outcome log. Runtime-wide hook kill switches still win globally. The gate never blocks prompts or Stop events and never persists prompt or transcript text.
// ~/.claude/settings.json
{
"env": {
"CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
},
"preferences": {
"model": "opus"
}
}Feature flags: REPROMPTER_FLYWHEEL, REPROMPTER_POLICY_ENGINE, REPROMPTER_LAYERED_CONTEXT, REPROMPTER_STRICT_EVAL, REPROMPTER_PATTERN_LIBRARY, REPROMPTER_TELEMETRY (all 0|1, enabled by default).
SKILL.md # Behavior spec (the product)
references/ # 18 templates (XML + markdown)
feature-template.md
bugfix-template.md
reverse-template.md
marketing-swarm-template.md
...
scripts/ # Runtime engine
intent-router.js # Mode + profile routing
reverse-engineer.js # Exemplar analysis + prompt extraction
capability-policy.js # Model selection + fallback chains
context-builder.js # Token-budgeted context assembly
artifact-evaluator.js # Output quality gates
pattern-selector.js # Pluggable prompt patterns
recipe-fingerprint.js # Strategy hashing
outcome-collector.js # Flywheel data capture
strategy-learner.js # Historical recommendation engine
repromptverse-runtime.js # Orchestration composer
See CONTRIBUTING.md. PRs welcome.