sordi-ai/skill-everything

---

---

THE PITCH

Self-learning · Save tokens · Skills to GO · Quality compounds.

Self-learning skills for AI agents. Beyond fine-tuning, beyond vector DBs, beyond black-box memory. Your domain knowledge — local, in plain Markdown, versioned in Git, hot-loaded as composable sub-skills.

⚡ Save tokens. Up to 84 % fewer input tokens. $28 saved per 1,000 messages on Claude Code & OpenCode (selective sub-skill loading); compact-router savings on Cursor & Gemini CLI. Per-message bill stays flat as your library grows.

🚀 Skills to GO. Same Markdown across Claude Code, Cursor, Gemini CLI, OpenCode. Switch tools — your skills come with.

✨ Quality compounds. Every accepted PR makes the next session smarter — through reviewed commits, not silent self-learning.

git clone https://github.com/sordi-ai/skill-everything.git

Star this repo to ship smarter agents.

[!NOTE] Drop-in compatible. Generates CLAUDE.md, .cursorrules, GEMINI.md, and SKILL.md from one skills/_index.yml — same domain knowledge, four agent runtimes.

---

WHY IT WINS

Six reasons skill-everything is a Git-native pattern for agent memory.

• Cross-tool by design. One source, four agent runtimes — Claude Code, Cursor, Gemini CLI, OpenCode. Generated from a single skills/_index.yml, drift-checked in CI on every PR. Same domain knowledge, four runtimes, zero re-authoring.
• Beyond fine-tuning. Domain knowledge compounds in plain Markdown — git diff-able, screenshot-shareable, instantly auditable. Your agent’s brain lives in skills/, versioned in Git, not in opaque weights.
• Self-extending memory. Every accepted change makes the next session smarter. git log --grep="learn(" is your agent’s growth trail. Quality compounds — commit by commit, through reviewed PRs gated by lint-rules + CODEOWNERS.
• 84 % fewer input tokens. $28 saved per 1,000 messages. Per-skill 3k-token cap, CI-enforced by tools/validate_rules.py. On Claude Code & OpenCode the router loads only the matching sub-skill; on Cursor & Gemini CLI the saving comes from the compact router pattern (full breakdown in Per-tool token reality). Add the 50th skill, the 200th skill — your per-message bill stays flat where the runtime supports lazy loading.
• Modular by design. Composable sub-skills, hot-loaded on demand. Domain knowledge — local, in one place, organised by trigger. The library grows; per-message cost doesn’t.
• Drop-in compatible with the agent ecosystem. CLAUDE.md, .cursorrules, GEMINI.md, and SKILL.md are all generated from the same source. Works with the formats your tools already read — today.

---

ARCHITECTURE

One register. Four loaders. Same sub-skills across four agent runtimes.

skills/_index.yml is the single source of truth. Every sub-skill is declared once with its id, tokens_target, triggers, and load order. From it, tools/render_loaders.py regenerates four loader files: SKILL.md (OpenCode), CLAUDE.md (Claude Code), GEMINI.md (Gemini CLI), and .cursorrules (Cursor). Edit the index, regenerate, done.

A CI no-drift job runs git diff --exit-code against the regenerated loaders on every PR — the four runtimes stay in lockstep, automatically. One source updates them all.

One source of truth. Four loaders. Zero drift.

[!NOTE] CI-enforced single-source-of-truth. loaders-no-drift validates that every regenerated loader matches its source on every commit — the four-runtime ecosystem stays in lockstep, automatically.

---

TOKEN MATH

Same task. Same agent. Up to 84 % fewer input tokens. Add a skill, pay nothing extra.

The single-message punch: monolithic prompts load .cursorrules every turn, all of it. With selective sub-skill loading (Claude Code, OpenCode), skill-everything loads the router (~800 tokens) plus exactly one sub-skill on demand (~800 tokens) — 84 % fewer input tokens per message. On Cursor & Gemini CLI the router itself is the saving today (see Per-tool token reality).

The scaling promise: monolithic prompts grow linearly with your skill library — every user, every message, every skill. Skill-everything stays flat as the library grows from 1 to 50 skills.

The bottom line: $47 with caching beats the $75 uncached-monolithic baseline — that’s $28 saved per 1,000 messages, 37 % cheaper. And the architectural win compounds: at 30, 90, 200 skills, monolithic explodes — skill-everything stays flat. Caching helps both. Only one of the two stays flat as your library grows.

Same architecture, every provider. The up-to-84 % input-token reduction is architectural, not pricing-conditional — switch from Sonnet to Opus, Kimi, or GPT-4o, the ratio stays where the runtime loads sub-skills selectively. Per-message dollar amount scales with the provider tier; the proportional saving doesn’t.

Per-tool token reality

The 84 % is architectural — it requires selective sub-skill loading. Here’s what each runtime actually does today.

Takeaway. The architectural win is identical across all four runtimes — same sub-skills, same source of truth, same drift-checked CI. The realisation depends on what the runtime supports today: full lazy loading on Claude Code & OpenCode, compact-router savings on Cursor & Gemini CLI. Plain Markdown works everywhere; the loader maturity catches up over time.

---

HOW IT WORKS

Five agent steps, three CI gates, one self-extending loop. Same Markdown across four agent runtimes.

Trigger → Analyse → Formulate → PR → Lint → Merge. The system captures every signal the agent picks up — errors, deployment gotchas, naming conventions, domain shorthand — and turns it into a versioned, schema-validated rule that ships to all four runtimes via the loader generator + drift-checked CI. (See the self-extension-loop diagram in the hero block above.)

[!NOTE] CI-validated, schema-checked, drift-detected. Every rule passes lint-rules + auto-approve-rule-pr before landing in main — JSON-Schema-validated, verb-allow-listed, fully auditable. SECURITY.md has the trust model.

---

SELF-EXTENSION

Self-learning skills — every commit makes the next session smarter.

The agent doesn’t just use the skill set — it grows it. Trigger → search → analyse → formulate → PR. Repeats are captured by the validator and gated by CODEOWNERS review. Quality compounds, commit by commit — through reviewed PRs, not silent self-learning.

learn(errors): is a commit-type that triggers lint-rules CI and validates every proposed rule against schemas/error-entry.json — a JSON-Schema with verb allow-list and pattern guards.

$ git log --grep="learn("
learn(errors): ERR-2026-001 — never disable strict checks for convenience
learn(errors): ERR-2026-007 — grep before claiming a rename complete  (count 1 → 2)
learn(errors): ERR-2026-012 — order migrations before backend deploys

The full self-extension workflow — including the CI gate, the auto-approve-rule-pr policy, and the schema-validated rule grammar — lives in skills/self-extension-workflow/SKILL.md.

Browse the full public error log → — every mistake captured and every rule derived, in plain Markdown.

---

MEMORY TO GO

Switch tools. Your skills come with.

Take your skills anywhere. Your self-learning sub-skills live once in skills/_index.yml and travel with you across four agent runtimes — Claude Code, Cursor, Gemini CLI, OpenCode — with zero re-authoring.

tools/render_loaders.py deterministically generates CLAUDE.md, .cursorrules, GEMINI.md, and SKILL.md from the same index. Switch from a Claude Code session to Gemini CLI mid-project and your composable sub-skills, your error log, your self-extension workflow are already loaded — identical, token-capped, schema-validated. Plain Markdown sync. Open formats. Local-first memory.

This is portable agent memory done the boring way: plain Markdown, git-versioned, CI-gated. Beyond fine-tuning, beyond vector DBs, beyond black-box memory. One source. Four runtimes. Memory follows you.

---

SELF-HOSTED & SMALLER MODELS

The smaller your model, the bigger the win.

Skill-everything’s router pattern is custom-made for self-hosted and quantized models — Ollama, llama.cpp, vLLM, LM Studio, MLX, and every local runtime in between. When the context window is 8k and there’s no Anthropic prompt-caching layer, token efficiency stops being a nice-to-have and becomes the difference between shipping and not.

• 8k context fits. A 10,000-token monolithic .cursorrules doesn’t even load on a Llama 3 8B. Skill-everything’s ~1,600-token footprint runs comfortably on 8k, 16k, or 32k windows — with room left for the actual conversation, tool calls, and reasoning.
• No caching tax. Cloud monolithic prompts lean on Anthropic prompt-caching to stay competitive. Local models have no caching layer — every token is paid in compute time and VRAM pressure. Skill-everything’s flat per-message footprint translates directly into faster inference, lower thermal pressure, fewer OOMs.
• Sharper needle-in-haystack. Smaller models lose accuracy fast as context grows. Loading exactly the matched sub-skill puts the relevant rule on top, where the model can actually use it — the difference between a hallucinated convention and a clean call.
• Self-hosted by design. Plain Markdown, local-first, version-controlled. Drops into any local runtime — your domain knowledge stays on your hardware, your agents stay private.

Built for every model. Best on the small ones.

---

QUICK START

Three steps. Five minutes. Your agent reads the same Markdown in all four tools.

git clone https://github.com/sordi-ai/skill-everything.git

---

CAPABILITY MATRIX

Capabilities sourced from each project’s documentation as of 2026-05. ✓ supported · ◐ partial · ✗ missing · n/a not applicable. AGENTS.md and Cursor Rules are siblings — skill-everything sits on top of them and adds the review and validation layers. mem0 / MemGPT solves a different problem (long-running embedded recall); if that’s your problem, use mem0.

---

WHAT’S INSIDE

The directory tree. Mono identifiers, comment column.

skill-everything/
├── SKILL.md                       # Router for OpenCode (generated)
├── CLAUDE.md                      # Router for Claude Code (generated)
├── GEMINI.md                      # Router for Gemini CLI (generated)
├── AGENTS.md                      # Cross-tool agent instructions (generated)
├── .cursorrules                   # Cursor router, classic single-file (generated)
├── .cursor/rules/                 # Cursor MDC rules — one per skill (generated)
│   ├── code-quality.mdc
│   ├── python.mdc
│   ├── typescript.mdc
│   ├── react.mdc
│   ├── git-conventions.mdc
│   ├── review-deployment.mdc
│   ├── domain-template.mdc
│   ├── error-log.mdc
│   └── self-extension-workflow.mdc
├── DISCLAIMER.md                  # Independent project, no employer endorsement
├── SECURITY.md                    # Threat model + responsible-disclosure
├── skills/                        # Anthropic Skills layout (one folder per sub-skill)
│   ├── _index.yml                 # Single source of truth for the routers
│   ├── _template/SKILL.md         # Copy this folder to start a new skill
│   ├── code-quality/SKILL.md      #   23 generic rules
│   ├── python/SKILL.md            #   20 Python-specific rules
│   ├── typescript/SKILL.md        #   17 TypeScript rules
│   ├── react/SKILL.md             #   17 React rules
│   ├── git-conventions/SKILL.md   # commit, branch, PR conventions
│   ├── review-deployment/SKILL.md # review + deployment checklists
│   ├── domain-template/SKILL.md   # template for project-specific knowledge
│   ├── error-log/
│   │   ├── SKILL.md               # YAML entries (validated by CI)
│   │   ├── exceptions.yml         # Forbidden-pattern bypass list
│   │   └── _entry-template.md     # Error entry template
│   └── self-extension-workflow/SKILL.md  # Six-step self-extension procedure
├── schemas/
│   ├── error-entry.json           # JSON-Schema for log entries
│   └── skill-manifest.json        # JSON-Schema for sub-skill frontmatter
├── tools/
│   ├── validate_rules.py          # CI lint: schema + verb allow-list
│   ├── render_loaders.py          # Regenerates SKILL/CLAUDE/GEMINI/.cursorrules from _index.yml
│   ├── render_readme_table.py     # Regenerates the token table above
│   └── templates/                 # Jinja2 templates for the routers
├── tests/                         # pytest suite + adversarial bypass tests
├── .github/
│   ├── CODEOWNERS
│   ├── ISSUE_TEMPLATE/
│   └── workflows/
│       ├── ci.yml                 # ruff + pytest matrix + secret-scan + token-budget + drift-check
│       ├── eval.yml                # workflow_dispatch eval pass + Monday cron smoke
│       ├── lint-rules.yml         # validate_rules.py
│       └── auto-approve-rule-pr.yml
├── CONTRIBUTING.md
└── LICENSE

---

CREATE YOUR OWN SKILL

Copy the template, fill the frontmatter, open a PR. CI takes care of the rest.

cp -r skills/_template skills/
$EDITOR skills//SKILL.md
# Update frontmatter (name matching dir, description, version, tokens_target, triggers), fill in rules, open a PR.

Each sub-skill has a skill-manifest frontmatter block declaring its name (matching the directory), description, version, tokens_target, triggers, and load order. CI validates the frontmatter on every PR. Keep each skill under 3,000 tokens. Split rather than bloat. Rules are action directives, not descriptions.

---

VERSIONS

v0.85 is the current release. 23 sub-skills shipped. v1.0 ships when the eval framework earns the claim. New features land in main via PR — watch the repo to see them ship.

Feature requests and roadmap updates land as PRs against ROADMAP.md in main — same loop as the rest of the repo: every change is a commit, every commit is reviewed, every release is auditable.

---

FAQ

The eight questions we expect on Show HN. Honest answers, no hedging.

---