# Show HN: Skillmaxxing – make every agent self-evolving > Source: > Published: 2026-06-26 22:37:12+00:00 **Self-evolving skills for your coding agent.** Your agent auto-creates and auto-improves its own skills as it works — no command, no trigger, no babysitting. Every coding agent starts every task from zero. It solves the same gnarly migration, re-derives the same release flow, re-learns the same repo quirk — and forgets it the moment the session ends. **Skill Maxing makes the forgetting stop.** It hooks into your agent so that, after real work, the agent reflects on what it just did and crystallizes the reusable parts into a **skill** — or improves a skill it already has. Over days, your agent gets measurably better at *your* codebase. That's a self-evolving agent, and it takes one line to turn on. Inspired by the [Hermes Agent](https://github.com/NousResearch/hermes-agent) self-improvement loop, adapted to run on the hooks that Claude Code, Codex, and other agents already expose. **Requirement:** Node.js ≥ 20 (the CLI is a Node program). Check with `node -v` . ``` npm i -g skillmaxxing && skillmaxxing plugin install ``` Installs the CLI globally and wires the hooks to it. Restart your agent session and you're done — **you never have to invoke anything.** Fast, persistent, and works on every laptop. ``` npx skillmaxxing plugin install ``` Works without installing anything globally; the hooks fall back to a version-pinned `npx` call. Great for trying it out — for daily use prefer the global install (the `npx` hook adds a little latency at each turn-end). ``` /plugin marketplace add Bennyoooo/skillmaxxing /plugin install skillmaxxing npm i -g skillmaxxing && skillmaxxing plugin install --agent codex ``` Codex has no programmatic stop hook, so self-evolution runs **in-session** via standing guidance written to `AGENTS.md` . Claude Code gets the full background loop below. Pick one mechanism per agent.For Claude Code, use either the marketplace pluginor`plugin install` — not both, or you'll get duplicate hooks. Manage it any time: ``` skillmaxxing plugin status # is it active? skillmaxxing plugin uninstall # remove the hooks ``` Skill Maxing installs just two hooks. You do nothing — the loop runs itself. ``` ┌──────────────────────────────────────────────────────────────┐ │ SessionStart → inject standing guidance │ │ "crystallize reusable work; fix stale skills"│ │ │ │ Stop (task done) → count tool calls in the transcript; if │ │ enough new work accrued, fork a background │ │ reflector: review the session and, if │ │ warranted, create ONE new skill or improve │ │ an existing one — autonomously, trusted:false│ └──────────────────────────────────────────────────────────────┘ ``` There's no per-tool hook — work is counted from the session transcript at Stop — so the agent stays fast on every install path. This mirrors Hermes' layers: | Hermes | Skill Maxing | |---|---| | Always-on system-prompt nudge | SessionStart hook injects skill-creation guidance | | Background review after N iterations | Stop hook counts transcript tool calls and forks a headless reflector past a threshold | | Provenance-gated curation | New/changed skills are recorded until you approve them`trusted: false` | Two key Hermes ideas carry straight over: the reflector **prefers updating an existing skill over creating a near-duplicate**, and it is **conservative** — most sessions produce no skill at all. | Mode | What happens on a substantial session | Pick it when | |---|---|---| `auto` (default) | A background agent (`claude -p` , restricted to skill tools) reflects and writes/updates a skill while you keep working | You want truly hands-off self-evolution | `nudge` | The agent is reminded to crystallize the workflow itself, in-session | You want zero extra processes / full visibility | ``` npx skillmaxxing plugin install --mode nudge --threshold 12 ``` The background reflector is **recursion-guarded** (it can never trigger itself) and **detached** (it never blocks your session). Every skill it writes is `trusted: false` and never auto-executes until you grant trust. Everything above is built on two CLI primitives the reflector (or you) can call directly. The CLI is **model-agnostic** — it does the deterministic work; your agent supplies the reasoning. **Create** — turn a workflow into a tested skill: ``` skillmaxxing skillify --draft draft.json # stage → smoke-test → review → --commit ``` **Improve** — make an existing skill measurably better, safely: ``` skillmaxxing optimize ``` `optimize` is an **eval-gated** loop (rollout → reflect → bounded edit → validate): a candidate is promoted only on a strict score win with no regression, every version is retained, and any change is reversible. **Untrusted by default.** Auto-created and improved skills are`trusted: false` ; the sandbox refuses to run their code without your explicit`--allow-exec` .**Reversible.** Promotions are atomic and every prior version is retained — revert any time.**No surprise execution.** The background reflector writes skills; it does not run untrusted code or touch your project source. | Capability | Status | |---|---| | Auto-create skills (hook-driven) | ✅ v1 | | Auto-improve skills (eval-gated) | ✅ v1 | | Cross-agent install (Claude Code, Codex) | ✅ v1 | | Discover skills from public sources | 🧰 CLI ready — landing in the plugin next | | Team workspace: share + collaboratively optimize | 🧰 CLI ready — landing in the plugin next | Discovery and team sharing already exist as CLI commands (`skillmaxxing discover` , `skillmaxxing workspace` ); they're intentionally held out of the v1 plugin surface to keep the install dead-simple. ``` php npm install npm run build # tsc -> dist/ npm test # node:test, ~90 tests node scripts/gen-hero.mjs # regenerate the hero ``` Zero runtime dependencies beyond `yaml` . ESM, Node ≥ 20. MIT