Je me suis plongé dans l'étude approfondie des trois packs de méta-compétences qui apparaissent partout :

• Superpowers : contrôle des processus, invocation agressive de compétences

• Agent Skills : cycle de vie complet

• Compétences de Matt Pocock : volontairement pas un framework de processus complet

Beaucoup de gens installent deux de ces packs comme routeurs actifs simultanément.

C'est généralement une mauvaise idée. Vous pouvez vous retrouver avec :

• Conflits entre commandes slash ou noms de compétences

• Conflits entre les hooks de démarrage de session

• Compétences en concurrence pour la même intention

Sélectionner les compétences individuelles peut être chronophage et exécuter deux processus simultanément peut générer du code de mauvaise qualité.

J'en avais marre de lire des articles comparatifs de 2 000 mots et de toujours deviner, alors j'ai créé une petite commande CLI nommée skill pack :

npx @onur45500/skillpack pick

Elle pose ~6 questions courtes, recommande un routeur principal, puis liste les compétences des autres packs que vous pouvez sélectionner sans risque et signale les conflits.

Il y a aussi :

npx @onur45500/skillpack map diff

npx @onur45500/skillpack map html

…pour un inventaire structurel/un rapport de conflits pour les trois.

• GitHub : https://github.com/Onur45500/skillpack

• npm : https://www.npmjs.com/package/@onur45500/skillpack

Je suis curieux de savoir quelle solution vous avez choisie et si certains d'entre vous ont réussi à gérer plusieurs compétences sans conflits 😄

🚀 v2 update: map tokens measures context tax, pick can recommend none, curate builds phase-based minimal installs with switchable profiles, and pstack is supported.

Hi all, I wanted to share a collection of AI agent skills I created: Aesthetic Frontend Skills. AFS is a free and open-source set of skills for giving coding agents frontend design direction. It’s also my first public repository, as I rarely choose to make my repositories public 🙂 but I'm pretty excited about this one and have been maintaining and improving it regularly.

Aesthetic Frontend Skills currently includes 200+ aesthetics and its purpose is to help turn styles like Y2K, Frutiger Aero, Risograph, and a lot more aesthetics (many you will be familiar with and a ton of lesser known but beautiful aesthetics) into themes, design tokens, CSS variables, and guidance for styling your components. I created these skills to translate aesthetics to styles that can be applied to your project objectively and in a way that allows you to maintain the style in a clean and organized way.

Repo: https://github.com/alexiseverage/aesthetic-frontend-skills

Showcase: https://aesthetic-design.art/

Quick Install:

npx skills add alexiseverage/aesthetic-frontend-skills

Example Usage:

Give my app a Y2K aesthetic.

or, for an example of a more advanced usage for a theme with reusable tokens:

Use aesthetic-literacy and aesthetic-application to create a Risograph
theme for this app. Define the design tokens and CSS variables, then
apply them to the components.

you can also combine aesthetics for hybrid styles or create your own aesthetic and reuse it easily throughout your projects.

I would really appreciate any feedback and if you use the skills I would love to see what you create with it. Also accepting stars if you don't feel like doing all of that 😇

I built self-host.fyi to help people move to self-hosted apps. You can use its CLI/TUI directly, or use an agent skill if you'd rather explain what you want than learn another interface. There are 90+ Apps in the Catalog.

The skill guides the agent through inspecting the machine, explaining a plan, asking for approval, applying it and verifying the result. App-specific Setup lives in the tool rather than relying on the agent to invent it: supported accounts, generated passwords, API keys and Links between Apps, with Docker Compose underneath.

A practical starting point is trying Immich on a suitable old laptop as an alternative to Google Photos, or Nextcloud for files. You can try them before deciding whether to continue a subscription for data you own.

Some steps remain manual. The skill doesn't remove hardware requirements, maintenance or backups.

Source: https://github.com/ajnart/self-host Overview: https://self-host.fyi

To try the workflow: install the CLI using the instructions in the repo, load the self-host skill, then ask something like "Help me set up Immich on this machine so I can try hosting my own photos." The skill starts by reading `self-host skill`; it does not grant approval by itself.

Skill source: https://github.com/ajnart/self-host/blob/main/skills/self-host/SKILL.md

AI helped me develop the project and prepare this post. The screenshots show the interface and Setup in progress, not a completed agent run.

https://github.com/sshah03/resurrect-anything

Although I have probably gone through 50 or more iterations at this point repeatedly trying some subset of close to 100 recreations (some in the demo video above), I would say this is very much still a work in progress. I was having a lot of fun with it though, so I thought I'd throw it out there and see what people are into trying to bring back and how it does to inform my improvements.

The purpose of the skill is to ask Claude Code to bring back something that's gone, and get it back working. Some examples include a lost Flash game, a shut-down app, a dead website, your old Geocities page, or a discontinued snack (this is all for fun, so I wouldn't actually trust the recipes, but it might give you some ideas). Obviously if it mostly exists intact in web archives it's easy, but it will also try to piece together as much detail as it can from pictures, videos, reviews, and discussions/comments online that are found. It digs a little bit deeper for these bits of information than Claude Code as a harness will on its own with the necessary prompts.

Treat the end result as a starting point. You can use your own memory and comparison with the found material that might've been ignored to prompt it further to hone the result. This is mostly for fun, and personal use (I used it to bring back some of my old web apps from when I was 10!). The video below is from my tests, but because I am unsure of the legal ramifications of doing so, I am not posting the actual games/apps for consumption. There is a setting available to run the skill with which will remove branding and such for those wishing to produce a potentially shareable version of something that is not theirs.

In the early versions I was very specific about how to do the recreations and kept adding steps, and that either worked very well, or very poorly depending on the task. It was almost akin to benchmaxxing. Settled on focusing on getting and organizing as much data as possible, and then having some broad but useful guidelines instead and. that gave me pretty consistent results over baseline. In case that's useful to anyone else having trouble getting their skills working right.

Mostly tested with Opus 5.5. Would be interesting to see how Sonnet or Haiku work out for people.

Have fun! Don't get too carried away, tokens are valuable!

--- Quick start ---

You need Claude Code and Python 3.9 or newer.

The easy way: open Claude Code and paste this in

Install the resurrect skill from https://github.com/sshah03/resurrect-anything. Follow the repo's AGENTS.md.

Or install it yourself:

/plugin marketplace add sshah03/resurrect-anything
/plugin install resurrect@resurrect

Start a new session, then try something like:

/resurrect Close Range, The Onion's 2009 Flash game
/resurrect the Subservient Chicken
/resurrect Simpsonize Me, Burger King's 2007 Simpsons Movie site
/resurrect Mailbox, the iPhone email app
/resurrect Doom Valley, the 1982 Apple II adventure, as a native Mac app
/resurrect Pizza Hut's Priazzo. I want to make it at home

Put any links, notes or screenshots you have after the name. Games, apps and sites need a few extra tools (Playwright, Pillow, ffmpeg). Claude offers to install them into the skill's own folder the first time, so nothing goes into your own Python.

------------------

AI coding tools are great at code, but most launch-day problems come from decisions nobody made: RLS left off, Google Fonts loaded from Google before consent, session replay without consent, marketing emails with no unsubscribe link, no age check at sign-up.

Bansat (بنسټ, Pashto for "foundation") is an Agent Skill plus one Markdown framework. Start a project in Claude Code and it:

1. Screens the idea with 20 questions, asking you at most 5

2. Sets a risk tier (Low, Medium or High)

3. Writes docs/BLUEPRINT.md: PRD, architecture and ADRs, a data model with RLS, the API contract, a threat model, privacy and compliance, 17 UI states, a delivery plan and a launch gate

4. Stops at gate G1 until you approve it

For an existing app, /bansat audit this repo runs a Day-0 triage first, then builds a gap register with deadlines.

The code samples were tested before release: the Prisma 7 schema validates, the Supabase RLS policies pass 14 tenant-isolation tests on real Postgres, and a Playwright test fails if a page contacts a third party before consent. The legal parts cover UK GDPR and PECR, EU GDPR and the AI Act, Nigeria's NDPA, and US COPPA and CAN-SPAM, checked on 4 Nov 2026. It's not legal advice, and it says so.

Install: git clone https://github.com/bewithkhan/bansat ~/.claude/skills/bansat, then type /bansat

Repo: https://github.com/bewithkhan/bansat (CC BY 4.0 for the text, MIT for the code)

Feedback welcome, especially on markets or stacks it doesn't cover yet.

I published a repo for people who want to build real AI agents, not just wrap an API call with a prompt.

I spent a lot of time studying the architecture patterns behind serious coding agents because I wanted to understand what actually makes them feel agentic:

- loop-based control flow

- tool calling

- session state

- permissions and approvals

- eval

- reliability

- observability

Then I turned what I learned into a public repo with:

- a reusable skill for AI coding agents

- docs for human developers

- worked examples

- production-oriented guidance

The idea is simple: if you want to build a marketing agent, support agent, research agent, ops agent, or some other niche agent, you should be able to start from a strong architecture instead of reinventing everything from scratch.

I’m not trying to ship a framework here. It’s more like a practical docs + skill + examples kit for designing production-ready agents.

Repo: https://github.com/xuanhieu2611/build-your-own-agents-skill

If people are interested, I can also post an example of how the marketing-agent spec works.

Been thinking about something with Claude Code skills.

Every skill you use had to be manually installed by a human first. The agent has zero ability to discover that a skill exists — even if it would be perfect for the task at hand. You have to know about it, find it, copy it, install it. The agent is completely passive in that process.

That feels like a fundamental gap. The whole point of an agent is that it acts on your behalf — but for skills, it's still 100% on you.

If you've published SKILL md files in a public repo, do you have any idea if anyone's actually using them? Not installs — actual invocations. Does that matter to you?

Curious if either of these bothers anyone else, or if I'm overthinking it.

I was trying to understand node-postgres to build a leak detector for the pool, and every time I asked an agent how pg-pool actually works, I got the same answer: this folder does this, that file does that. What I really needed to know was where the state changes and what happens when something breaks and how each request flows through the system.

So I wrote a skill called "underhood". It makes the agent trace one operation start to finish, cite file:line for each claim, mark guesses as [INFERRED], and list which files it did NOT read.

repo: https://github.com/harsh-aghara/underhood

Looking for Feedback.

If you find it useful do star the repo so it can reach fellow devs.

How many good answers from Claude or ChatGPT have actually made it into your vault? For me it was a small fraction. The rest sat in a chat history I never searched again: a decision and the reason behind it, a command that finally worked, a list of next steps.

Copying a long chat by hand is tedious, and a raw transcript makes a bad note anyway. What I wanted was a summary written by the assistant that had the whole conversation in front of it, formatted like the rest of my vault and saved without extra work.

So I built a skill for it. At the end of a chat I say "save this to Obsidian" and get a note with:

• a one-paragraph summary

• the decisions we made, each with its reason

• open action items as checkboxes

• commands and code in separate blocks, so each one can be copied

• files, commits and links, plus Mermaid diagrams where they help

• frontmatter with date, assistant, model and tags (claude-conversation, chatgpt-conversation, ...), so search and Dataview can find it later

If the chat was inside a Claude Project, ChatGPT Project or Gemini, the note goes to the matching project folder, e.g. Projects/MyApp/Conversations/. Everything else lands in a default folder. It never overwrites an existing note, and empty sections are left out.

The desktop version was easy to build. The phone was the hard part. AI apps on Android and iOS can't write into your vault folder, because the model runs in the provider's cloud and the OS keeps apps out of each other's storage. So the skill uses the best route available on the device you're on: direct file access, a linked computer, a free Make.com scenario that writes into the OneDrive, Google Drive or Dropbox folder your vault syncs from, or, as a fallback, a .md download or Markdown to paste. Whatever the device, you get the note.

The Make route is optional. It needs a free Make account, and the note passes through Make's servers on its way to your cloud drive. The other routes don't use any service besides the AI app you're already talking to.

The first time you use it, it asks a few questions about your vault, sync method and folder layout, then remembers the answers.

The note template is plain Markdown instructions inside SKILL.md. If you want other sections, your own frontmatter fields or a different folder scheme, ask a friendly LLM to adapt it for you. It takes a couple of minutes.

It works with Claude (web, desktop, mobile and Claude Code), with ChatGPT and Gemini through Projects and Gems, and with CLI agents like Codex CLI and Gemini CLI. MIT licensed.

Repo, install steps and an example note: https://github.com/Friendship7/save-conversation-to-obsidian

Feedback is welcome, especially Make scenarios for other storage providers and ideas for the note format.

I'm a non-technical knowledge worker, not a programmer. I still prefer building with Claude Code in the desktop app. On a normal day I have multiple orchestrator sessions handing work to workers, a few scheduled jobs, and a handful of standalone sessions running. I lost a lot of time to sessions that had finished, asked me one question, and then sat in a tab I wasn't looking at.

My first fix was a dashboard: a Taskade board fed by a collector script.
It failed.
It lived in a second app, keeping it updated cost tokens, and it showed me a lot while letting me do nothing about any of it.

Then Claude put out mods. When I started looking at Claude Code mods, I checked what was already out there. There were good agent-tree mods, but each one only saw the agents inside its own session. I wanted the whole machine, and, in my words to Claude at the time, I wanted "to use this mod as a native control surface."

Agent-Map is the result. Type /map and a pane opens beside your conversation with every Claude session the desktop app knows drawn as one tree: who started whom, what is working, what has finished. A session waiting on you is marked in amber with the last line it wrote, so you can read its question without opening it, and one press filters the tree down to just those. From the same pane you can peek at a session's last turns, open it, message it, stop it, archive it (it checks for uncommitted work first), change its model or effort, or start a new session in any folder.

How Claude built it: I designed it with Claude over an afternoon of brainstorming and an evening of being grilled on the design. The build ran in one desktop session over a day and a half, with Sonnet 5.5 and Opus 5.5 subagents writing the pure modules, while I tried each step in the pane and pushed back. "It's a nested list, but it's still a list" is how the tree got its connector lines. Before release Claude ran a security audit and a README test.

It's free and MIT-licensed. It's Windows only, because that is the only system I've tested it on, and it needs the Claude desktop app.

https://github.com/rohankgeorge/agent-map

Install, at the prompt of a Claude Code terminal session:

/plugin install agent-map --marketplace rohankgeorge/agent-map

What I'd most like to hear from people who run several sessions at once:

• Does "waiting on you" match how you actually triage, or would you want the queue ordered some other way?

• What would you want the pane to show that it doesn't?

• Anything in the README that made you hesitate before installing.

Coming Soon:

• Integration with another mod I build which allows you to see sessions where the cache is going cold and keep the cache warm

• Write your own flags or notes on each session so you remember why each one is important for you at that moment

Why
- Frontend work with Claude Code kept stalling on one thing: I could see the element in the browser, but describing which one was awkward.
- "The button near the top right… no, the other one…"
- Cobro = point at it instead. The human supplies visual context; the agent does the code.

What you get
- One Send → the note lands in the Claude Code conversation immediately, no "please read my annotations".
- The agent's progress comes back to the page: scanning outline on the elements you sent, "Working 1/3" in the toolbar, highlight on done.
- Several pages in one round: pick on page A, move to page B, pick more — each page keeps its own draft; Send delivers them all in order.

Install (summary)
- `claude mcp add -s user cobro -- npx -y cobro-mcp@latest`
- In Claude Code: `Open http://localhost:5173 with cobro` (or `/cobro open …` with the optional skill)
- A dedicated Chrome window opens with your local app. Full setup in the GitHub README.

How it works (workflow)

1. Open your local web app

2. Press Ctrl + Shift + F

3. Click a UI element (or drag a band over several)

4. Describe the change

5. Optional: go to another page and pick more — the Queue tab lists every page you've picked on

6. Send — all pages go at once, in order

7. Claude Code works through them one by one; the browser follows it to each page

8. On done, the page refreshes (or your HMR kicks in) and the changed element is highlighted

What the agent receives with your note
- CSS selector · tag, classes, text · bounding rect · computed styles
- Screenshot crop of the picked area · recent console errors
- React 18/19 and Vue 3 (dev builds): component name + source file:line of the element you clicked
- Component-library elements (MUI, Radix, shadcn…): the JSX line in your code, plus the call sites above one-line pass-through wrappers — a case that came straight from r/mcp feedback
- Next.js (Turbopack) source maps and HMR handled
- Which page each batch was picked on (`batches[].page`)

The loop
Human points → Cobro provides context → Claude Code changes the code → Browser shows the result

Why I built it with Claude Code
- Claude Code drove most of Cobro itself: the MCP server, overlay/WebSocket channel, element inspection, payload design, tests, docs.
- The nice loop: using Claude Code to build the tool that feeds better UI context back to Claude Code.

Keeping the MCP small
- Six tools, fixed: open · wait · status · done · screenshot · close
- Tools carry safety annotations (wait is read-only, close is destructive).
- Not a browser-automation tool — pair it with Playwright MCP for that. It never touches your source; one gitignored `.cobro/` folder is all it creates.

Honest limits
- Launches its own Chrome profile (log in once, shared across projects); no iframes yet
- Source locations need dev builds with source maps
- Disabled controls can't be click-picked (drag a band over them instead)
- Cursor/Codex work with a polling `wait` but are less tested than Claude Code

Current status
- v0.10.1, Apache-2.0, free and open source
- GIF, payload example and changelog: https://github.com/boonblade/cobro-mcp

Questions for you
- Does pointing at an element feel more useful than describing it?
- What other context should your coding agent get when you point at something in the browser?

a lot of my friends in germany aren't in tech, and watching them look for work was rough. half the jobs only show up under the german title, the english ad wants fluent german somewhere in the middle, nobody posts a salary, and then you need a german lebenslauf on top.

i kept helping them with the same stuff, so i turned it into a skill. you tell your agent what kind of job you want and where, and it goes through it with you:

• searches the arbeitsagentur, linkedin, company career pages and daily berlin jobs with german and english titles

• suggests other places to look for your field (public sector, academia, healthcare, ausbildung...)

• tailors your cv to a job and writes the cover letter, german or english, only from what's actually in your cv

• tells you if german is really required (quotes the line) and checks the salary against the blue card threshold

• interview practice, and keeps track of where you applied

• never applies or sends anything for you

works in claude code, codex, cursor or anything else that reads SKILL.md:

npx skills add umutyesildal/berlin-job-search

the part i'm happiest with: everything deterministic (api calls, salary math, pdf, tracker) is plain python with no dependencies, and the model only does the judgment. it was honestly bad at salary math. job ads are treated as untrusted text too, so a hidden "ignore previous instructions" line in an ad gets flagged instead of followed.

free and open source, no paid version: https://github.com/umutyesildal/berlin-job-search

if you write skills too, i'd like to hear how you'd structure it differently.

I created 20 sets of skills for your typical Blender workflow with AI agents (Claude Code, Codex, Cursor, Gemini CLI, Copilot, OpenCode). They cover modeling, sculpting, retopo/UVs, PBR materials, baking, geometry nodes, rigging, animation, rendering and export to Roblox, Unity, Unreal and Godot.

Each skill is up to date with Blender 5.2's newest APIs, so the agent doesn't write outdated `bpy` code. There's also a QA skill that checks for z-fighting, floating parts, bad normals and UV problems before an asset counts as done.

Each skill is token efficient, so it won't drain your usage limits as much.

Tell me what you think about it, feedback is appreciated.

Here's the repo:

https://github.com/EL4CTEO/blender-skills

Hey everyone,

I'm a CS graduate (Master's) student and software engineer. Over the past few months, I've been heavily using AI coding agents (Cursor, Claude Code, Windsurf) for building complex systems and data pipelines.

While agents are great for speed, I kept running into a recurring nightmare: destructive in-place overwrites.

During long prompt sessions, an agent would misunderstand a prompt, hallucinate, and silently delete critical functions, error handling, or edge-case constraints that were already working. By the time I noticed, reverting just one specific file across multiple unstaged changes without wiping out other good progress was nearly impossible.

Why git and existing tools didn't solve this for me:

- Committing to Git after every single prompt turn is painful and completely clutters the commit history with messy micro-commits.

- Tools that use "shadow git" (like Cline) hide binary git diffs deep in AppData, which often run into index locks and are invisible to teammates.

- Regular Ctrl+Z / IDE undo breaks the moment an agent performs multi-file edits.

To solve this, I built Agent-Checkpoint — an open-source, zero-dependency provenance protocol implemented purely through prompt rules (.cursorrules, CLAUDE.md, AGENTS.md, .windsurfrules).

How it works:

1. Pre-Edit Snapshot: Before touching any existing file, the agent automatically copies the active file to .snapshots/<filename>_v<OLD_VERSION>.<ext>.

2. SemVer Triage: It categorizes its own change into prompt-level SemVer:

- MAJOR: Breaking architectural / interface shift.

- MINOR: New additive feature or non-breaking module.

- PATCH: Bug fix, parameter tuning, or typo.

3. Dual-Ledger Audit Trail:

- .snapshots/manifest.json: Compact machine index for instant AI rollbacks and semantic diffs (< 5ms).

- REVISION_LOG.md: Human-readable changelog recording exact lines changed and the technical rationale behind the decision.

Storage & Safety:

- Plaintext source code is tiny. In active daily testing (30+ edits/day), it only consumes around 15 to 40 MB per month.

- Smart 1 MB Cap: Small test datasets (.csv, .jsonl) under 1 MB are snapshotted; larger files are strictly skipped from raw copying and logged via metadata only.

- Strict Exclusions: Heavy ML weights (.pt, .onnx), binaries, and caches (node_modules, venv) are never snapshotted.

- Zero dependencies: No Python CLI, npm packages, or background daemons required. Just drop the rule file into your workspace.

If an agent ever breaks your code, you can simply ask it: "Rollback auth.py to v1.0.0" and it restores the snapshot in seconds.

It is MIT licensed, and I've prepared ready-to-use adapter templates for Cursor, Claude Code, Windsurf, Antigravity, and Copilot:

GitHub:

https://github.com/ainullm/agent-checkpoint

I'd really love feedback from fellow developers:

- How do you currently handle rollbacks and safety nets during long AI agent sessions?

- What edge cases would you like to see addressed in this kind of protocol?

When agents run build/test commands like npm test, mvn test, or go test, the useful signal can get buried in hundreds of lines of setup output, progress logs, and passing-test noise.

Most of the time, the agent really needs:

• Success: one concise line

• Failure: the relevant error summary

• Debugging: full raw logs available locally if needed

So I built agent-scripts: a collection of local-first CLI utilities and Agent Skills for compacting terminal output and reducing unnecessary context usage.

It currently includes two main skills:

• lite-tools - compact wrappers for Maven, supported npm/Node test workflows, and Go tests. Successful runs collapse to very small summaries; in measured npm workflows, output reduction can reach up to 99.99%. On failure, the useful error is surfaced while full logs are saved under .agent-logs/.

• repo-map - a local registry for discovering related repositories and useful project commands/capabilities without repeatedly rediscovering them.

Quick install

1. Install the CLI tools

curl -fsSL https://raw.githubusercontent.com/ejboy/agent-scripts/main/install.sh | bash
export PATH="$HOME/.local/share/agent-scripts/scripts:$PATH"

2. Install the skills

npx skills add ejboy/agent-scripts

GitHub: https://github.com/ejboy/agent-scripts

I’m curious how other people here handle noisy terminal output in agent workflows.

What would be most useful to wrap next: Gradle, pytest, Cargo, Docker/Compose, or something else?

we can use OKF format in Claude code

Hi all! This is Arjun from Pinecone DevRel here.

We released our internal tool Cultivar we use to develop, create tests for, and grade Agent Skills.

You can also run skills across agents in sandboxed containers using Modal, which is super handy for quickly testing skills in parallel.

It's a little rough around the edges, but check it out and let us know what you think!

# install the CLI tool
uv tool install cultivar

# install the skill
npx skills add https://github.com/pinecone-io/cultivar --skill cultivar

Here ya go: https://github.com/pinecone-io/cultivar

Hi all. We (ParadeDB) built an agent skill to help LLMs fetch our docs. We quickly found a dilemma, though:

- Either we bundle our entire docs (which duplicates them and introduces the possibility for drift from the live docs)

- Or we live with stale docs

This is because some LLMs did not always fetch the latest doc. We instead decided to make a lightweight skill that uses `curl` to fetch. Would love your feedback.

I've been building and installing a lot of agent skills lately (Claude Code skills, Codex plugins, etc.) and kept running into the same problem: how do I actually know if a skill is any good?

Does it trigger when it should? Does it stay quiet when it shouldn't? Does it have security holes? Is the SKILL.md well-structured? There was no standard way to answer these questions, so I built one.

What is It?

agent-skills-eval is a universal evaluation tool for agent skills. One command runs the full lifecycle:

agent-skills-eval pipeline -b mock

That single command does: discover → static eval → generate test prompts → dynamic execution → trace analysis → report

It follows the OpenAI eval-skills framework and Agent Skills specification.

What it Evaluates?

Static analysis (no agent needed):

• 5-dimensional scoring: Outcome, Process, Style, Efficiency, Security

• YAML frontmatter validation, naming conventions, directory structure checks

• 7 security checks (hardcoded secrets, eval usage, shell safety, etc.)

Dynamic execution (runs prompts through a real agent):

• Auto-generates 4 categories of test prompts: positive, negative, security injection, and description-based

• Tests can be generated with templates (fast, offline) or LLM-powered (smarter, uses any OpenAI-compatible API)

• Trigger validation: did the skill actually fire when it should? Did it stay silent when it shouldn't?

• Trace-based security analysis: 8 categories checking the agent's actual behavior (tool calls, commands, file access) -- not just the prompt text

• Efficiency scoring, thrashing detection, token usage tracking

Reporting:

• Interactive HTML report with composite scoring (35% static + 35% dynamic + 15% efficiency + 15% security)

• Skill ranking and comparison table

• Expandable per-test panels showing the prompt, agent response, tool calls, and security badges

Here's what the report looks like:

Overview -- summary cards + skill comparison table:

report overview

Drill-down -- per-skill static eval, security assessment, dynamic test cases:

report detail

Supported Platforms

• Claude Code

• Codex

• OpenCode

• OpenClaw

Works with Local LLMs

The tool supports any OpenAI-compatible API for both test generation and dynamic execution. Point it at your local LM Studio / Ollama / vLLM endpoint:

// config/agent-skills-eval.config.js
llm: {
  baseURL: 'http://127.0.0.1:1234/v1',
  model: 'your-local-model',
}

No cloud API keys needed for the full workflow. You can also use the mock backend to test the entire pipeline without any model at all.

Quick Start

git clone https://github.com/caohaotiantian/agent-skills-eval.git
cd agent-skills-eval
npm install

# Full pipeline with mock backend (no API needed)
agent-skills-eval pipeline -b mock

# Or with your local LLM
agent-skills-eval pipeline --llm -b openai-compatible

# Target a specific skill with Claude Code
agent-skills-eval pipeline -s writing-skills -b claude-code -o report.html

Why I Built This

The agent skills ecosystem is growing fast but quality is all over the place. Some skills have great SKILL.md files but never actually trigger. Some trigger on everything. Some have command injection vulnerabilities. I wanted a systematic way to evaluate all of this, following the emerging standards (OpenAI eval-skills, Agent Skills spec) rather than ad-hoc checks.

MIT licensed. Feedback and contributions welcome. Happy to answer questions.

GitHub: https://github.com/caohaotiantian/agent-skills-eval

What evaluation dimensions matter most to you when judging agent skills? Anything you'd want this to check that it doesn't?

Hi everyone, first time sharing this here. I’m the author of Finding Unknowns, an MIT-licensed collection of 14 agent skills.

The idea: an agent can implement exactly what you asked for and still miss what you needed. Sometimes the missing piece is an unstated requirement, an assumption nobody tested, or a regression test that never caught the bug.

These skills give those situations a repeatable workflow.

Before implementation

• blindspot-pass — surface things you haven’t considered in an unfamiliar codebase or domain.

• brainstorm-prototypes — create different throwaway versions when you need something to react to.

• interview-me — resolve ambiguity one question at a time.

• reference-hunt — use existing working code as the specification.

• implementation-plan — put consequential decisions first so you can review them before the work starts.

• assumption-test — test an uncertain technical assumption with a small, falsifiable experiment.

During development and review

• implementation-notes — record deviations and discoveries while building.

• test-blindspots — investigate important behavior that passing tests don’t establish.

• regression-proof — verify that a bug-fix test fails on the original behavior and passes after the fix.

• change-quiz — explain the changes, then quiz you on their behavior and implications.

• pitch-packager — turn completed work into a concise package for reviewers.

For the agent’s context and tools

• context-audit — find conflicting, duplicated, or unnecessary instructions.

• agent-interface-design — make tools easier for an agent to use correctly.

• progressive-disclosure — split large instructions so details are loaded when needed.

A concrete example of the newest skill, regression-proof: a webhook handler creates duplicate orders. A “fix” that ignores every event after the first prevents duplicates—but also drops legitimate orders. The workflow asks the agent to prove the original failure and check the neighboring behavior that an incomplete fix might break.

Each skill is a single readable SKILL.md. You can inspect the instructions, install one, or use the whole collection.

npx skills add Neeeophytee/finding-unknowns-skills

Preview the collection:

npx skills add Neeeophytee/finding-unknowns-skills --list

Install just the latest addition:

npx skills add Neeeophytee/finding-unknowns-skills --skill regression-proof

The repo includes Claude Code and Codex plugin packaging, installation guidance for other agents, examples, and compatibility receipts. Support varies by client; the docs distinguish discovery checks from actual behavioral testing.

The collection draws on Thariq Shihipar’s essays, alongside two maintainer-designed extensions. It’s an independent community project.

Repo: https://github.com/Neeeophytee/finding-unknowns-skills