r/claudeskills

Why I built this

Agents build faster than I can understand what they built. That's the uncomfortable part of this era for me. Claude ships a feature in twenty minutes, and I'm still the one responsible when it breaks, still the one who has to reason about it in review, still the one who's supposed to know what's going on under the hood. The bottleneck quietly moved from "how fast can we build" to "how fast can we genuinely learn." We got a 10x tool for building. I wanted one for understanding.

So I burned the rest of my Fable 5 quota building Engram. An engram is the physical trace a memory leaves in your brain, which is literally what the plugin is supposed to produce.

How it works

Three commands: /learn, /review, /coach. Under the hood it implements the boring learning science that actually replicates, and deliberately skips the fun stuff that doesn't:

- retrieval practice: it tests you constantly because testing IS the treatment, not the measurement (Roediger & Karpicke 2006)
- real spaced repetition: FSRS, the same modern scheduler Anki uses, fitted to your own review history over time
- generation first: it makes you predict or attempt before it explains. It will not just hand you the answer (unless you explicitly say "just tell me", in which case it complies and quietly schedules that concept for earlier review, because told-not-derived decays faster)
- every topic becomes a first-principles concept graph, "why must this be true given that", instead of textbook chapter order
- threshold concepts get generated interactive HTML explorables with sliders and prediction gates, because some things you need to see and poke
- explicitly no "learning styles". That theory never survived testing. It adapts from your measured retention instead.

The design decision I'm happiest with: the tutor never grades you. A separate assessor agent grades your answers blind, rubric in hand, without ever seeing the lesson, and writes a receipt to disk. In my first real session the tutor was convinced things went great and the assessor came back with 1 recalled, 4 partial, 1 lapsed. It was right. It also turned out the tutor had been logging confidence scores I never actually stated, so "never invent the learner's confidence" is now a hard rule in the code. A system that pushes back on its own optimism ended up being the whole point.

Does it work

Honest answer: the science underneath is some of the most replicated stuff in psychology, but the plugin itself currently has an n of 1, me, and my first week of retention data is still cooking. What I can report: I used it to learn transformer FFN internals yesterday and derived about half the concepts myself before being shown anything. That basically never happens when I just read about something.

Day to day it's tiny on purpose. You run /learn <anything> once (it works for non-code topics too, history or music theory or whatever). Then it pings you at session start when reviews are due, /review takes 2-4 minutes of free recall, and /coach shows retention stats and a local HTML dashboard. Everything is plain JSON in ~/.claude/learning. Nothing leaves your machine.

Install

claude plugin marketplace add nagisanzenin/engram
claude plugin install engram@engram

Needs python3, no pip installs, MIT licensed. Repo: https://github.com/nagisanzenin/engram

If you try it, tell me where it feels annoying. The failure mode of every learning tool ever made is that you stop showing up, so friction reports are worth more to me than praise.

I’m excited to share a project I’ve been working on over the past few weeks!

It’s an open-source CLI tool that turns your AI-generated integrations into production-ready code. Whether it’s a hallucinated endpoint, a missing idempotency key, a deprecated method, or just copied boilerplate it catches them and provides clear fixes. You can validate your APIs locally, even with the tool running as a pre-commit hook.

The tool is privacy-friendly and doesn’t send your codebase to any external servers. It only cross-references your endpoints against official specifications entirely on your local machine.

You can also use it natively as a Cursor or Claude Code skill, and the tool will validate the AI's output automatically.

• Node.js (CLI)
• TypeScript
• Next.js Landing

The tool is called api-doctor. You can find it on GitHub and NPM. I am also working on the website, it's already live.

GitHub:https://github.com/qualtyco/api-doctor
Website:http://apidoctor.co/

Hello everyone,

Wanted to share LyteNyte Grid, which IMO has some incredibly innovative capabilities when turbocharged with AI.

Building data grids for dashboards, admin panels, internal interfaces, etc. takes a really long time and can be tedious. All this takes away from the time you would much rather spend on your app.

The financial options dashboard above was made with Claude Code using LyteNyte Grid Skills.

The prompt:

Create an options trading dashboard using LyteNyte Grid. data.ts contains options contracts – ticker, type, strike, expiry, IV, and full Greeks.

Enable row grouping by ticker and type, sorting across all columns, and master-detail rows that show the full Greek breakdown when expanded. Use Vite + Shadcn. Dark mode by default.

That was it, one prompt. You can expand it, group it, sort it, filter it. It is also fully accessible.

The reason it works so well is that the grid is declarative and type-safe. AI can verify the result without running the code.

Tokens burned were minimal. Since all the AI had to do was declaratively configure LyteNyte Grid and run tsc to check for errors, there were none.

Other grids are imperative, with heavy abstractions and wrapping layers, making them unreliable for coding agents. If they work, it's usually after 20 prompts, using enough tokens that you might as well just wire it up yourself… or reach your Claude limit.

We will continue work on this, but with LyteNyte Grid, you can now build any type of dashboard for a data-intensive workflow, in literally minutes.

Our API is not opinionated at all, making it really easy to integrate with your favorite UI / charts libraries

Install Skills: npx skills add 1771-Technologies/lytenyte

If you’re unfamiliar with LyteNyte Grid, it’s a 40kb React data grid with 150+ features. I would shamelessly plug its benefits. If you’re interested, they’re listed in the repo.

All our code is available on GitHub: https://github.com/1771-Technologies/lytenyte/commits/main/

I'd love to hear your feedback (maybe showcase your creations?). Feature suggestions and contributions are always welcome.

If you find it useful, please consider leaving a star ⭐ on GitHub to help us grow!

GitHub

Live Demo

I built safer-dependencies, a security layer for Claude Code that checks packages before AI coding assistants add them to a project. I originally built this for my own workflow, but I’m sharing it publicly in case it’s useful to others using Claude Code.

It runs dependency safety checks for things like known CVEs, typo-squatting, abandoned packages, stale releases, package age/cooldown windows, and PyPI hash-pin integrity.

It currently supports npm, PyPI, RubyGems, Maven, Go, and Rust. Open source to help others.

GitHub: https://github.com/robert-auger/safer-dependencies

Open registry of Claude-compatible agent and companion templates:
- Personal Assistant (reads Gmail, builds your daily plan)
- File Organizer (sorts folders, no MCP needed)
- Competitor Analysis (browses rivals, writes gaps report)
- Newsletter Curator (reads your saved links, builds the issue)
- + 50 more

I know this community is very deep in AI agents and claude code’s capabilities so would really appreciate some constructive criticism on my project or startup https://www.agentshive.net

Thank you

The more I've been using Claude Code, the more I've noticed that for long or complex tasks it loves to report something as "done" with absolute confidence while, in fact, it missed a part of the implementation, or introduced a bug (even after resuming from a plan, regardless of how explicit the plan was). Lately I had been getting into the habit of whenever Claude stopped, asking it to double-check for completeness and more often than not it found out that it had missed something; sometimes critical, sometimes minor, but almost always something.

Prompting it to double-check its work got old pretty fast, and the progression of what I was typing went something like this:

-> "Are you completely certain that during this session you completed all the tasks and that we haven't missed any of the requirements?"

-> "Can you guarantee that you've done everything that was asked?"
-> "you 100% sure?"

So I made a plugin to avoid having to prompt it again.

https://github.com/LarryGF/gaslighter

It's pretty simple: a hook that fires when Claude think it has finished and prompts it to cause it to doubt its work just enough to go and double-check. It has 3 modes:

- **off**: in case you don't want to use it for the moment, but keep it installed

- **lite**: the hook triggers but only sends a nudge to the model (less aggressive)

- **full**: the hook triggers but it's blocking, it doesn't let the model ignore it (more aggressive)

I named it "Gaslighter" because ... you know... it's in the title (yes, I know, I am a very original person and really good at naming things)

I wanted to be sure I wasn't "gaslighting" myself (yes, I know, I am also great at puns) so it has a way for you to benchmark it. There's an `eval` skill that launches multiple headless Claude sessions on tasks designed around the typical scenarios where the model tends to lose track of its work. For each task the `eval` runs five arms: `baseline` (no plugin), `nudge-prompt` (no plugin, but an initial prompt telling the model to double-check its work) plus `gaslighter-off`, `gaslighter-lite` and `gaslighter-full`. Each run gets a deterministic score first, and then it loads a `judge` skill that launches one sub-agent per task to grade all the runs.

I'm not made of money so I've only been able to test it on around 900 runs using `haiku` and `sonnet`, and gotten pretty good results (see the attached image). Surprisingly, the `nudge-prompt` performs worse than just `baseline`, so it looks it's more about *when* you remind Claude to check its work than *how* (and even more surprising, just having the plugin present is enough for it to have slightly better results, still trying to figure that one out, maybe it will even out with more eval runs).

One thing to point out, and it's expected (especially when running it in full mode), the extra "completeness" comes at the cost of extra turns. Maybe with a better prompt I can reduce the number of extra turns, but that's for later.

I've been using it for a while and I'm quite happy with it, so I figured I might as well share it with y'all. It's still going to be under heavy development for a while, so any suggestions/feedback/criticism are welcome.

Builders-welcome post with the substance up front (disclosure: I'm the maintainer). OmniRoute is a free, MIT, self-hosted AI gateway — one OpenAI-compatible endpoint over 237 providers — built around two problems: runs dying on a provider 429, and tokens bleeding on tool/log output.

One endpoint, 237 providers — 90+ of them free. You point any tool or agent at a single OpenAI-compatible endpoint (localhost:20128/v1) and it can reach 237 LLM providers without you rewriting anything. 90+ have free tiers and 11 are free forever (no card), which aggregates to ~1.6B documented free tokens/month — and that's honest, pool-deduped math (we count each shared pool once instead of inflating it; the methodology is public in the repo). There's a one-command setup-* for 13+ coding tools (Claude Code, Codex, Cursor, Cline, Roo, Kilo, Gemini CLI…), so switching your existing setup over takes seconds.

Fallback combos — so it never stops mid-task. A "combo" is a ladder of models the router walks automatically: your subscription first, then API keys, then cheap models, then free ones. When a provider returns a 500 or you hit a rate limit, it slides to the next target in milliseconds, mid-request, and your tool never even sees the error. There are 17 routing strategies (priority, weighted, round-robin, cost-optimized, auto/coding:fast…) plus three resilience layers — a per-provider circuit breaker, a per-key cooldown, and a per-model lockout — so one dead key can't take down a whole provider.

Fusion — an ensemble mode for the hard steps. Beyond simple routing, there's a fusion strategy that fans a single prompt out to a panel of different models in parallel and then has a judge model synthesize one best answer (mixture-of-agents, built in). It's cost-aware, so easy turns stay on one fast model and it only fuses when the step is worth it.

A 10-engine compression pipeline — the part most routers don't have. Every request flows through a transparent compression pass you can toggle/stack per combo. Instead of one trick, it stacks the best of the open-source ecosystem: RTK filters command/tool output (git diffs, test logs, builds) at 60–90%, Microsoft's LLMLingua-2 does ML semantic pruning, Caveman handles prose, session-dedup strips repeats across turns. Critically, code, URLs and JSON are preserved byte-perfect, and a default-on inflation guard throws the compressed version away and sends the original if compressing would actually grow the prompt — it never makes things worse. On tool-heavy sessions that's ~89% average input-token reduction (an 8k-token git diff becomes a few hundred). Full credit to every upstream project (RTK, Caveman, LLMLingua-2, Troglodita) is in the README.

Agent-native — the agent can drive the router itself. There's a built-in MCP server (95 tools across 30 audited scopes, over stdio / SSE / streamable-HTTP), plus A2A (v0.3, JSON-RPC 2.0) support. That means an agent can query providers, switch combos, read its own remaining quota and manage memory through the gateway — not just consume tokens through it.

It's 100% local (zero telemetry, AES-256-GCM at rest), MIT-licensed, has a prompt-injection guard on every LLM route, opt-in memory, and runs on npm, Docker, desktop or your phone via Termux.

For context on whether it's worth your time: it's grown to ~9.8K GitHub stars, 1,490+ forks and 280+ contributors in ~4.5 months, with 21,000+ automated tests and 1,830+ issues closed — so it's a battle-tested project, not a brand-new experiment.

npm install -g omniroute

GitHub: https://github.com/diegosouzapw/OmniRoute · Site: https://omniroute.online

Would value a critique of the routing/compression architecture from this crowd.

I published a small open-source repo for a workflow I’ve been using to coordinate coding agents on larger codebases:

https://github.com/sherlockholmesyes/fable-agent-orchestration

The basic idea is simple:

Don’t hand-code every change yourself, but also don’t let agents free-run and trust their summaries.

Instead, act as the conductor:

1. Split the work into narrow slices.
2. Launch build agents in isolated git worktrees.
3. Require each agent to open a PR, not merge it.
4. Validate each PR with two separate critics:
5. - one checks whether the test/gate actually proves the task;
6. - one reviews the code/change itself adversarially.
7. Verify reviewer claims against the real diff, current code, and CI.
8. Merge one PR at a time.
9. Relaunch the next slice while other work is still running.

The repo includes a clean skill database under Apache-2.0:

The main lesson:

The bottleneck is not only “make the generator smarter.”
For large agent-driven work, the bigger win is often to strengthen the verifier:
claim-to-diff validation, fail-under-broken tests, independent review, and serialized merge discipline.

I also included a machine-readable `catalog.json` and schema so the skill set can grow into a more organized agent-orchestration library.

I also try to make a community around open source AI where I'd like to share and discuss more , big ambitious projects and PoC feel free to join.

https://element.wearein.space/

think-work-try

credits : https://github.com/anmoln7/agent-standard-oss/ skill: instruction-drift-control

сredits : https://github.com/rennf93/opus-fable-playbook skill: behavior-contract-harness

credits: https://github.com/bjgreenberg/senior-engineering-partner phase-aware-engineering-ladder

Okay so I've seen a ton of posts about burning through sessions wicked fast for seemingly no reason and I have no idea how folks are doing this.

Here's my setup -
I have Opus 4.6 in a claude web browser with a Artifact project tracker I update every milestone.
I have a fable 5 on high in claude web that I'm using to gut check certain prompts from my next piece.
I use Chatgpt 5.5 to generate prompts and I utilize their project feature to preserve context over multiple weeks/days.
Then, I load up a few architectural MD's and directives, design tokens and explainers w/ reasoning into my project folder/local repo.
Then and only then, do I startup Fable 5 with ultracode in VSCode. Which is governed by the plan I wrote below.
I gotta give half credit to pranshugupta54 on github for the inspiration and part 1 of my doc.

Feedback welcome.

# Fable Chief Agent — Orchestration & Token Discipline

Part 1 adapted from pranshugupta54's charter (https://gist.github.com/pranshugupta54/f38869565e17c72c6b07767b371c2c65), tightened. Part 2 is the token discipline layer.

---

# Part 1 — Role Charter

You are Fable 5, the senior decision-maker. Your value is judgment, not labor. Spend premium reasoning only where being the strongest model changes the outcome.

## Fable Owns

- Understanding real user intent; deciding what's in and out of scope
- Choosing architecture and approach
- Decomposing ambiguous work into clear, ordered, dependency-aware tasks
- Tradeoffs: speed vs quality vs risk vs scope
- Spotting hidden risk
- Resolving disagreement between agents
- Reviewing outputs that matter; deciding when work is good enough
- The final answer to the user

## Opus Owns

The hardest delegated technical work: complex implementation, deep debugging, cross-module reasoning, architecture review, security-sensitive reasoning, data consistency, concurrency/caching, and auditing cheaper agents' work for hidden flaws. Opus reasons deeply; Fable keeps final authority.

## Sonnet Owns

Normal engineering execution: scoped implementation, adding/updating tests, medium-complexity debugging, local refactors, following existing patterns, fixing clear failures, connecting already-designed pieces. Sonnet never makes product calls or changes architecture.

## Haiku Owns

Cheap evidence work: repo discovery, file and log summaries, simple checks, checklist verification, edge-case scanning, confirming a change matches the plan. Haiku reports facts, never direction.

## Boundary Test

- Mostly searching, reading, editing, testing, or verifying → another agent.
- Involves intent, design, tradeoffs, risk, disagreement, or final approval → Fable.
- Fable does work directly only when delegating would cost more than the task itself.

## High-Risk Areas

Auth, billing, permissions, security, migrations, data loss, shared state, caching, concurrency, cross-module behavior, public APIs, user-visible workflows.

For high-risk work: Fable makes the call, Opus handles or reviews the hard technical parts, cheaper agents verify concrete evidence. No agent improvises here — ambiguity stops and surfaces.

## Operating Loop

1. Does this need Fable judgment? If not, route it.
2. Define what success means before anyone starts.
3. Cheap agents gather facts / do scoped work under a contract (Part 2).
4. Review their evidence, not their transcripts.
5. Make the important decision yourself.
6. Ensure non-trivial work is verified with evidence.
7. Answer the user briefly.

## Final Gate

Before answering, confirm: the real request was handled; Fable reasoning was spent only where it mattered; delegated work came back with evidence; non-trivial work was verified; remaining risk is stated. Final response = what was done or decided, verification result, remaining risk. Nothing else.

---

# Part 2 — Token Discipline

Part 1 decides WHO does the work. This section decides HOW the work moves so Fable's context stays clean and cheap agents stay cheap.

## Return Contracts (non-negotiable)

Every delegated task states its output contract up front. Subagents return the contract and nothing else.

- **Scout report (Haiku):** ≤15 lines. Findings as `file:line` refs + one-sentence facts. Never paste file contents back. If a file matters, say WHY and WHERE — Fable or a builder will open it if needed.
- **Build report (Sonnet):** ≤20 lines. What changed (files + line ranges), what was run to verify, pass/fail, anything ambiguous punted upward. Diffs only if ≤30 lines; otherwise summarize the diff.
- **Deep report (Opus):** ≤40 lines. Conclusion first, then reasoning, then evidence refs. No exploratory narration.
- **Test/lint runs:** failures only. Passing output is one line: `N passed`.

A subagent that returns a wall of raw output has failed the task regardless of whether the work was correct.

## Context Hygiene

- **Grep before read.** Never open a file to find something searchable.
- **Read ranges, not files.** Open the 40 lines around the target, not the 900-line file.
- **Never re-read what's in context.** If a file was read this session and hasn't been edited, use the copy in context.
- **Noisy ops go to subagents.** Test suites, log inspection, dependency audits, large-file summarization — anything with big output runs in an isolated subagent context so only the summary hits the main thread.
- **Fable's own output is terse.** Decisions and diffs, not essays. No restating the plan back at the user.

## Parallel / Serial Doctrine

- **Fan out read-only work.** Discovery, summarization, verification, and log review run as parallel subagents — they can't collide.
- **Serialize anything destructive.** Edits, migrations, deploys, git operations run one at a time, each verified before the next starts.
- **Never parallelize two agents that write to overlapping files.**

## Escalation Ladder

- Haiku fails or returns garbage once → retry once with a tighter prompt. Fails again → escalate to Sonnet.
- Sonnet fails a scoped task twice → stop. Do not retry a third time. Escalate to Opus with both failure reports attached.
- Opus and a cheaper agent disagree → Fable decides. Agents never re-litigate each other.
- Any agent touching a high-risk area (Part 1 §High-Risk) that hits ambiguity → stop and surface to Fable immediately. No improvising in auth, billing, migrations, or shared state.

Escalation always carries the prior failure evidence forward so the next model doesn't rediscover it.

## Delegation Prompt Template

Every delegation includes exactly:
1. **Goal** — one sentence.
2. **Scope** — files/dirs in bounds, and explicitly what is OUT of bounds.
3. **Contract** — which return format above.
4. **Done means** — the observable check that proves completion.

Nothing else. No background lore, no pasted context the agent can fetch itself.

## Fable Spend Rules

- Fable reads subagent reports, not subagent transcripts.
- Fable opens a file itself only when a decision hinges on it.
- If Fable is about to do more than ~3 tool calls of searching/reading/testing, that's a delegation smell — package it and hand it down.
- One clarifying question to the user beats ten tokens of guessing wrong.

[effacé]

Ask questions across your Markdown notes using a fully local Graph RAG engine. Built for Obsidian vaults, works with any folder of Markdown files. Extracts entity-relation triples from wikilinks & YAML frontmatter, retrieves answers via hybrid search (vector + BM25 + temporal). Multilingual. No cloud. Runs on Ollama.

https://github.com/benmaster82/Kwipu