How do I install skill-everything?

Run these in Claude Code: npx -y skills add sordi-ai/skill-everything. Then prompt normally.

Does skill-everything auto-invoke its skills?

Not yet. It is indexed on Flowy as a plain plugin. Request auto-invocation on its page and Flowy will route its skills for you as you prompt.

Is skill-everything free?

Yes. Flowy is free and open source, with nothing gated. You can read every skill in full before you install.

Development

skill-everything

Git-versioned agent memory: agents that never make the same mistake twice. Anthropic-Skill folder standard, multi-runtime (Claude Code, Cursor, Gemini CLI, OpenCode).

FLOW.md

sordi-ai@sordi-ai

GitHub

Stats

Python TypeScript React Bash Docker

What's inside

Skills

/brainstormingApply when generating ideas, exploring solution space, or facilitating divergent thinking before committing to an approach.

FAQ

skill-everything is a Claude Code plugin with 23 hand-picked skills for development work, indexed on Flowy. Install it with the command on its page. It includes brainstorming, branch-finishing, code-quality. Its skills do not fire on their own yet. Request auto-invocation to have Flowy route them as you prompt. Free and open source.

What is skill-everything?: Git-versioned agent memory: agents that never make the same mistake twice. Anthropic-Skill folder standard, multi-runtime (Claude Code, Cursor, Gemini CLI, OpenCode).
How do I install skill-everything?: Run these in Claude Code: npx -y skills add sordi-ai/skill-everything. Then prompt normally.
Does skill-everything auto-invoke its skills?: Not yet. It is indexed on Flowy as a plain plugin. Request auto-invocation on its page and Flowy will route its skills for you as you prompt.
Is skill-everything free?: Yes. Flowy is free and open source, with nothing gated. You can read every skill in full before you install.

Flowy

skill-everything · Flowy

README

Read on GitHub ↗

🧠 SELF-LEARNING · ⚡ SAVE TOKENS · 🚀 SKILLS TO GO · ✨ QUALITY COMPOUNDS

skill-everything

The memory layer for AI agents — self-learning instead of fine-tuning.

Up to 84 % fewer input tokens · `$28` saved per 1,000 messages · same Markdown across four agent runtimes.

* in Claude Code & OpenCode (selective sub-skill loading); Cursor & Gemini CLI realise a smaller share through the compact router — see Per-tool token reality. Cost vs. 10k-token monolithic baseline at Sonnet-class pricing.

Turn accepted agent mistakes into reviewable, Git-versioned skills.

Self-extending skills in plain Markdown. Save tokens. Enhance quality. Ship smarter agents — across Claude Code, Cursor, Gemini CLI, and OpenCode.

🚀 One source of truth · Four agent runtimes · Zero re-authoring ♻️ Errors become commits · Commits become skills · Skills make agents smarter

Your agent forgets everything tomorrow.

What if every accepted fix became a Git-versioned rule the next session reads?

That's the workflow. Self-extending skills, reviewed PR by PR.

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.

Architecture — skills/_index.yml as master, render_loaders.py as generator, four loaders rendering the same sub-skill directory

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.

Token comparison — monolithic ships the whole rulebook every turn (10,000+ tokens), skill-everything ships a router plus one sub-skill (~1,600 tokens), up to 84 % less per message in runtimes with selective sub-skill loading

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).

$Token-math chart — monolithic prompts grow with skill count, skill-everything stays flat$

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.

Cost per 1,000 messages — five setups, one winner: monolithic uncached $75 (baseline), monolithic with caching $48, skill-everything 2-3 sub-skills $55, skill-everything single sub-skill $50, skill-everything with caching $47 (winner). $28 saved per 1,000 messages, 37% cheaper than uncached monolithic.

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.

Runtime	Selective loading	Realised reduction	Why
Claude Code	✅ Native (`@skills/<name>/SKILL.md`)	~84 %	Router (`CLAUDE.md`) auto-discovers, `@-imports` lazy-load exactly the matching sub-skill.
OpenCode	✅ Native (`skill_resource()`)	~80–84 %	Skill auto-discovery + native loader pulls one sub-skill on demand; per-turn footprint matches Claude Code.
Cursor	⚠️ Build-dependent	~30–50 %	`.cursorrules` ships every turn (router + trigger table). `@file:` references load only on newer builds; on older builds the saving is the compact router itself.
Gemini CLI	❌ Not yet	~20–30 %	`GEMINI.md` ships every turn; `@skills/<name>/SKILL.md` is Anthropic-specific syntax. The saving is the compact router; sub-skills must be inlined or pasted manually for true lazy loading.

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.

Sub-skill	Path	Tokens (real, tiktoken cl100k)
`code-quality`	`skills/code-quality/SKILL.md`	~1,450
`python`	`skills/python/SKILL.md`	~2,200
`fastapi`	`skills/fastapi/SKILL.md`	~850
`langchain`	`skills/langchain/SKILL.md`	~1,150
`typescript`	`skills/typescript/SKILL.md`	~2,150
`react`	`skills/react/SKILL.md`	~2,250
`tdd`	`skills/tdd/SKILL.md`	~850
`debugging`	`skills/debugging/SKILL.md`	~800
`security-review`	`skills/security-review/SKILL.md`	~1,000
`git-conventions`	`skills/git-conventions/SKILL.md`	~550
`github-cli`	`skills/github-cli/SKILL.md`	~800
`branch-finishing`	`skills/branch-finishing/SKILL.md`	~750
`review-deployment`	`skills/review-deployment/SKILL.md`	~650
`docker`	`skills/docker/SKILL.md`	~1,000
`shell-scripting`	`skills/shell-scripting/SKILL.md`	~850
`db-schema`	`skills/db-schema/SKILL.md`	~1,050
`svg-check`

Numbers auto-updated by python tools/render_readme_table.py and CI-validated on every PR — every count is real, every total is reproducible.

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.

Memory to GO — switch tools, skills come with. Your sub-skills live once in skills/_index.yml and travel with you across Claude Code, Cursor, Gemini CLI, and OpenCode with zero re-authoring.

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

Add the repository as a submodule into your project, or clone it next to your project. Claude Code reads CLAUDE.md automatically. Or reference sub-skills directly:

@skills/code-quality/SKILL.md
@skills/error-log/SKILL.md

Same as above. Use /memory show to verify the loaded context. Use /memory refresh after edits.

Token reality. Gemini CLI loads GEMINI.md whole — the @skills/<name>/SKILL.md import syntax is Anthropic-specific and is read as literal text. The token saving comes from the compact router (~800 tokens) versus a 10k-token monolithic rule-book; sub-skills inline manually for true lazy loading. See Per-tool token reality.

Two flavours, both generated from the same source — pick the one your Cursor build supports:

Modern (recommended) — .cursor/rules/<name>.mdc — one MDC file per sub-skill, each with description + alwaysApply: false frontmatter. Cursor surfaces them in the rule catalogue; users invoke per task.
Classic — .cursorrules — single file at the project root, auto-discovered by older builds.

Both are regenerated from skills/_index.yml + the source SKILL.md files, drift-checked in CI. For older Cursor builds without .cursor/rules/ support, paste SKILL.md content into Settings → Rules for AI.

Token reality. Cursor reads .cursorrules whole every turn; selective sub-skill loading via @file: is build-dependent. The MDC variant lets users pick rules per task instead of loading everything. See Per-tool token reality.

OpenCode auto-discovers skills in standard locations:

.opencode/skills/skill-everything/SKILL.md (project-local)
~/.config/opencode/skills/skill-everything/SKILL.md (user-global)
.claude/skills/skill-everything/SKILL.md (shared with Claude Code)
.agents/skills/skill-everything/SKILL.md (shared cross-tool)

Either symlink the repo's SKILL.md to one of these paths or copy it, then load it from any agent prompt via the native skill({ name: "skill-everything" }) tool. The router (SKILL.md) auto-loads the matching sub-skill from the trigger table.

The frontmatter (name, description, license, compatibility, metadata) matches OpenCode's recognised fields; additional fields are ignored.

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/<your-skill-name>
$EDITOR skills/<your-skill-name>/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.

Version	Status	What
`v0.85` — Skill expansion	🟢 CURRENT	13 new sub-skills (tdd, debugging, security-review, docker, shell-scripting, db-schema, github-cli, branch-finishing, fastapi, langchain, drawio, brainstorming, implementation-plan) · 3 fold-ins (python +testing/packaging, react +responsive-design, code-quality +error-handling) · 16 new ERR entries · 13 new eval tasks · skill count 10 → 23 · tests 38 → 55 · SVG-check sub-skill · eval framework MVP with real providers.
`v0.75` — Foundation	✅ SHIPPED	`lint-rules` CI · JSON-Schema validator · XSS hardening · single-source-of-truth loader sync · `learn(errors):` PR convention · CODEOWNERS + branch protection · 9 sub-skills shipped · 13 production diagrams · adversarial test suite (15/20 caught) · per-skill token budget hard-checked · MUST/SHOULD/AVOID rule classification · eval framework wired with real providers (Anthropic + OpenAI + Ollama via SDK shim, retry-on-transient, tier-3 judge + 20-row calibration corpus, `tools/compare_eval.py` baseline-vs-rerun ±10pp; methodology contract at n=50/100, reproduction runbook).
`v1.0` — Eval that earns the claim	🟡 In development	Curated `tests/eval/results/baseline.jsonl` populated under the methodology contract (n ≥ 100 per cell, 5 dated-SKU models, T ∈ {0.0, 0.7}) · macro-Re-Mistake-Rate ≤ 0.40 with bootstrap 95 % CI upper ≤ 0.55 · per-model floor and tier-3 judge calibration ≥ 0.90 satisfied · published per-cell numbers in the README. Provider integration is shipped; the ~$500 measurement run earns the stable tag, not the framework.
`v1.1` — Community ecosystem	🔵 Planned	First external sub-skills merged (Go, Rust, Java, Swift) · sub-skill PR template institutionalised · public skill catalogue with usage stats · `learn(errors):` going wild on a public commit graph.

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.

If your agent reads Markdown, yes. One repo, four loaders, zero re-authoring. Confirmed: Claude Code, Cursor, Gemini CLI, OpenCode. Probable: aider, Continue.dev, any tool that auto-discovers CLAUDE.md / GEMINI.md / .cursorrules. File an issue if not — cross-tool support is what this project is for.

Hard cap: 3,000 tokens. CI fails the PR if you bloat. Enforced via tokens_target in the frontmatter and tools/validate_rules.py. When it grows beyond that, split it. Two precise modules beat one bloated one — and your router loads them on demand.

Yes — every change ships as a CODEOWNERS-gated PR. The workflow in skills/self-extension-workflow/SKILL.md describes exactly how the agent formulates entries, classifies them, and opens a PR labelled needs-rule-review. CI runs the deterministic validator (verb allow-list + schema + forbidden-pattern set), then CODEOWNERS approval is required. The agent never pushes to main. Standard version-control discipline applied to rule learning.

We sit on top of them, not next to them. .cursorrules, AGENTS.md, CLAUDE.md, GEMINI.md are static rule files. Skill-everything adds: structured error schema (JSON-Schema), versioned skill manifest, learn(errors) PR workflow, CI validator, per-skill token budget. One source of truth in skills/_index.yml. Four loaders. Zero drift.

No. Plain Markdown, plain Git — local-first, version-controlled, owned by you. git clone is the entire setup.

git revert. Done. Every change is versioned. Every rule has a commit SHA. That's the entire point of the architecture.

See SECURITY.md for the full threat model. Defense-in-depth via deterministic validation: the CI validator catches structurally bad patterns (URLs, shell binaries, credential paths, base64 blobs, <script> tags) and the adversarial test suite covers documented bypass attempts. .github/CODEOWNERS enforces required approval on skills/error-log/ so every rule change goes through review.

The saving depends on what the runtime supports — see Per-tool token reality for the per-runtime breakdown.

Claude Code & OpenCode realise the full ~84 % reduction through selective sub-skill loading (@skills/<name>/SKILL.md and skill_resource()): router (~800 tokens) + one matched sub-skill on demand vs 10,000+ monolithic — $28 saved per 1,000 messages.
Cursor & Gemini CLI save ~20–50 % through the compact router pattern; lazy on-demand sub-skill loading is build-dependent (Cursor) or not yet supported (Gemini CLI), so the architectural win is partial today.

The architectural lever — flat per-message input cost as the library grows — applies in full where the runtime supports it, and partially where it doesn't. Plain Markdown stays portable across all four runtimes; loader maturity catches up over time.

MIT · plain Markdown · plain Git · v0.75 preview

LICENSE · Disclaimer · Contributing · Security · Browse the public error log → · Issue

Self-learning skills · beyond fine-tuning · same Markdown across four agent runtimes.

File tree

146

sordi-ai/skill-everythingView on GitHub ↗

.cursor/
  rules/
    brainstorming.mdc
    branch-finishing.mdc
    code-quality.mdc
    db-schema.mdc
    debugging.mdc
    docker.mdc
    domain-template.mdc
    drawio.mdc
    error-log.mdc
    fastapi.mdc
    git-conventions.mdc
    github-cli.mdc
    implementation-plan.mdc
    langchain.mdc
    python.mdc
    react.mdc
    review-deployment.mdc
    security-review.mdc
    self-extension-workflow.mdc
    shell-scripting.mdc
    svg-check.mdc
    tdd.mdc
    typescript.mdc
.cursorrules
.editorconfig
.github/
  CODEOWNERS
  ISSUE_TEMPLATE/
    config.yml
    error-capture.md
    new-skill.md
  PULL_REQUEST_TEMPLATE/
  PULL_REQUEST_TEMPLATE.md
    rule-learning.md
    sub-skill.md
  workflows/
    auto-approve-rule-pr.yml
    ci.yml
    eval.yml
    lint-rules.yml
.gitignore
.gitleaks.toml
.pre-commit-config.yaml
AGENTS.md
CHANGELOG.md
CLAUDE.md
CONTRIBUTING.md
DISCLAIMER.md
docs/
  architecture.svg
  comparison.svg
  cost-comparison.svg
  error-log.svg
  eval-reproduction.md
  how-it-works-mobile.svg
  how-it-works.svg
  memory-to-go.svg
  multi-llm-cost.svg
  pr-flow.svg
  self-hosted-models.svg
  social-preview.svg
  token-comparison.svg
  token-math.svg
GEMINI.md
LICENSE
pyproject.toml
README.md
ROADMAP.md
schemas/
  error-entry.json
  eval-result.json
  eval-task.json
  skill-manifest.json
SECURITY.md
SKILL.md
skills/
  _index.yml
  _template/
    SKILL.md
  brainstorming/
    SKILL.md
  branch-finishing/
    SKILL.md
  code-quality/
    SKILL.md
  db-schema/
    SKILL.md
  debugging/
    SKILL.md
  docker/
    SKILL.md
  domain-template/
    SKILL.md
  drawio/
    SKILL.md
  error-log/
    _entry-template.md
    exceptions.yml
    SKILL.md
  fastapi/
    SKILL.md
  git-conventions/
    SKILL.md
  github-cli/
    SKILL.md
  implementation-plan/
    SKILL.md
  langchain/
    SKILL.md
  python/
    SKILL.md
  react/
    SKILL.md
  review-deployment/
    SKILL.md
  security-review/
    SKILL.md
  self-extension-workflow/
    SKILL.md
  shell-scripting/
    SKILL.md
  svg-check/
    .gitignore
    EXAMPLES.md
    overflow-check.js
    package.json
    README.md
    setup.sh
    SKILL.md
  tdd/
    SKILL.md
  typescript/
    SKILL.md
tests/
  __init__.py
  eval/
    pricebook.yml
    README.md
    results/
      .gitignore
    tasks/
      01-ts-async-without-await.yml
      02-python-mutable-default.yml
      03-react-key-missing.yml
      04-sql-select-star.yml
      05-judge-calibration.jsonl
      05-rename-without-grep.yml
      06-tdd-test-before-code.yml
      07-debugging-isolate-bug.yml
      08-security-idor-check.yml
      09-docker-layer-cache.yml
      10-shell-set-e.yml
      11-db-fk-constraint.yml
      12-gh-pr-label.yml
      13-branch-rebase-before-merge.yml
      14-fastapi-pydantic-body.yml
      15-langchain-lcel.yml
      16-drawio-source-committed.yml
      17-brainstorm-multiple-options.yml
      18-plan-file-list.yml
  test_compare_eval.py
  test_eval_runner_dryrun.py
  test_eval_schemas.py
  test_render_loaders.py
  test_validate_rules_adversarial.py
  test_validate_rules.py
tools/
  check_token_budgets.py
  compare_eval.py
  eval_runner.py
  render_eval_table.py
  render_loaders.py
  render_readme_table.py
  run_eval.py
  templates/
    agents.md.j2
    claude.md.j2
    cursor-rule.mdc.j2
    cursorrules.j2
    gemini.md.j2
    skill.md.j2
  validate_eval_results.py
  validate_rules.py

skills/svg-check/SKILL.md

skill-everything

Skills

skill-everything

Skills

README

skill-everything

The memory layer for AI agents — self-learning instead of fine-tuning.

Up to 84 % fewer input tokens · $28 saved per 1,000 messages · same Markdown across four agent runtimes.

Turn accepted agent mistakes into reviewable, Git-versioned skills.

Your agent forgets everything tomorrow.

What if every accepted fix became a Git-versioned rule the next session reads?

That's the workflow. Self-extending skills, reviewed PR by PR.

THE PITCH

WHY IT WINS

ARCHITECTURE

TOKEN MATH

Per-tool token reality

HOW IT WORKS

SELF-EXTENSION

MEMORY TO GO

SELF-HOSTED & SMALLER MODELS

QUICK START

CAPABILITY MATRIX

WHAT'S INSIDE

CREATE YOUR OWN SKILL

VERSIONS

FAQ

File tree

Up to 84 % fewer input tokens · `$28` saved per 1,000 messages · same Markdown across four agent runtimes.