Agent skills

Skills are the onboarding docs for agents: packaged procedural knowledge — markdown instructions, reference files, scripts — that a coding agent loads when a task matches. The container is boring (a folder with a SKILL.md); the idea is not: instead of hoping the model improvises well, you encode the expertise and the agent pattern-matches at a higher level (lauren’s “pull the agent to a different latent space,” clippings/7jeWwLvx0F0-transcript.md).

What makes something a skill rather than a prompt:

• Reusable across sessions and people — a prompt is conversation-local, a skill is an artifact (Poteto’s pstack: 23 playbooks + 23 principles + 24 skills, versioned and shipped to anyone; pstack)
• Procedural, not motivational — steps, commands, gotchas, verification; the anti-pattern is “abstract plans [that] only give you the illusion of progress”
• Failure-mode driven — pstack’s build method: “every time I saw a failure mode, I just made that a skill”
• Maintained with evals — skills rot as the product changes; the potato-mode eval playbook (coordinator rubric + sub-agent swarm) treats them like code with unit tests
• Ecosystem-specific packaging: Hermes loads skills/ per profile; Claude Code/Cursor/Codex consume SKILL.md-style packages — same idea, different loaders

This note is the catalog of interesting skills worth stealing — grouped by domain, each with what makes it clever.

Frontend design

• hallmark (OSS) (29.5k★, MIT, by Nutlope/Together) — “Anti-AI-slop design skill”: the most-shipped demonstration that a skill can change an output distribution, not just follow steps. Picks a macrostructure per brief, dresses it in one of 21 themes (or Custom from scratch), then runs 57 slop-test gates + pre-emit self-critique and “refuses the on-distribution defaults every LLM was trained into” — purple gradients and emoji-free-hero, meet the gate. Four verbs worth stealing as an interface grammar: default build, audit (score existing, punch list, no edits), redesign (keep copy/IA/brand, rebuild structure), study (extract design DNA from a screenshot → portable design.md). Two briefs produce different sites, “not colour-swaps of the same template.”

Diagrams

• drawio-skill (OSS) (by Agents365) — the ambitious one: natural language / codebase / IaC → editable .drawio with self-check (exports PNG, inspects its own output with vision, auto-fixes overlaps up to 2 rounds). The “keep it true over time” half is what elevates it past a generator: a Diagram IR separating meaning/provenance/geometry, diagramctl sync updating changed nodes while preserving hand-tuned layout, diagram-as-test CI rules (Internet-to-database access, cycles, trust boundaries) enforced on PRs, plus dependency queries, articulation-point detection, and failure-propagation simulation. Sources in: code imports (Py/JS-Ts/Go/Rust), Terraform/K8s/compose + live state (kubectl get -o json), SQL DDL, OpenAPI, AsyncAPI, protobuf, GraphQL, CI DAGs; Mermaid-as-authoring-format converts 28 types to native drawio. Works with Hermes (Agent Skills format). The thesis to steal: diagrams are models with projections, not pictures — generation is the easy 20%, drift-proof sync + architecture contracts are the product.
• archify (OSS) (77.2k★, MIT, JavaScript) — the viral sibling: idea/plan/codebase → standalone interactive HTML diagram you explore, extend, and share as one file. Same-era answer to drawio-skill with a different output bet: instead of the .drawio editor ecosystem, a self-contained page with truthful interaction (focus, upstream/downstream reach, exact routes reuse authored nodes — “instead of inventing topology”), typed JSON IR with schema-validated reproducible sources, atomic validation gates (schema/layout/SVG/route/label-clearance must pass before replacing last-known-good), failure repair receipts with stable rule codes, and optional SRC-evidence nodes that open git-verified file+line ranges pinned to one commit. The proof pattern worth stealing: a checked-in “Proof Lab” of 11 scenarios with JSON sources and validation receipts. “Not a general-purpose drawing editor or a Mermaid theme. It turns technical intent into a communication artifact.”
• sideshow (OSS) (608★, MIT, TS; sideshow.sh) — not a skill but the missing visual surface companion for agents: a live browser canvas where any harness (Claude Code, Codex, OpenCode, Pi…) publishes surfaces — diagrams, UI sketches, rendered markdown, highlighted diffs, terminal output — that render live while the agent works, with comment threads between user and agent on each surface (agent revises, thread shows the history). Two economics worth noting: surfaces send only content (the viewer supplies the chrome), so it’s cheaper than standalone-HTML artifacts — “far fewer tokens, and a faster draw”; and it’s verification-grade — the pstack “show me a video as proof” instinct, generalized to “show me the surface as proof.” Kin to drawio-skill (OSS)/archify (OSS) (diagram generators) but positioned as the runtime channel between agent and human.
• plannotator (OSS) (9.1k★, Apache-2.0, TS; plannotator.ai) — the review-side companion for agents: a local browser surface that plugs into agent hooks (Claude Code, Codex, Copilot CLI, Gemini CLI, OpenCode, Kiro, Droid, Amp, Pi) — when the agent proposes a plan/spec/HTML artifact or finishes a diff, it opens in the browser for visual annotation, and comments go back to the agent with one click. Markdown review + code review + HTML artifacts in one loop. The completion of the visualization channel set: archify (artifact), sideshow (live surface), plannotator (the feedback direction — human markup becoming agent instructions). Its “effective-html” skills repo pairs with the claude.dev HTML-effectiveness post.
• answer-me-with-html (OSS) (1.2k★, by QingYunA/smk7z) — the Karpathy visualization idea as a quantified skill: ask a hard question, get a one-page HTML you can actually read. The economic twist on the claude.dev thesis: hand-written HTML costs output tokens for every CSS line, wrapper div and SVG coordinate — the skill has the model write only the content (structured draft) and renders the chrome locally. Benchmarked (Sonnet 5.5, 3×3 medians): 6.1× fewer output tokens, 2.8× faster, 27% cheaper per answer. Two themes (blueprint / shadcn), ASD-STE100 simplified-technical-English writing check (“say it in the fewest words”, warn or refuse-to-render), optional video mode with synced narration (ElevenLabs / local OpenAI-compatible TTS via mlx-audio), always-on mode. Traction update (1k-star-day tweet, captured; repo 1.2k→1.3k★ within hours of the first capture): new flagship is the 3b1b-video mode — complex conclusions → 3Blue1Brown-style explainer videos in seconds, riding the same content/chrome split (agent emits Markdown, CLI renders — now to video, not just HTML). The steal: content/chrome separation is the answer to sideshow’s “viewer supplies the chrome” — same economics, achieved at render time instead of runtime.
• socratic-code-mentor skill (via ogzhanolguncu’s “How to keep learning in the age of LLMs, captured) — the anti-vibecoding skill: never hands the answer, asks the questions that make you reach it yourself (“How many items are in nums, and what is the last index?” → you find your own off-by-one). Grounded in Make It Stick’s desirable-difficulty finding: “when you’re asked to struggle with solving a problem before being shown how, the solution is better learned and more durably remembered.” Pairing pattern from the same post: LLM does the boring-but-necessary parts (tests, tooling, the client when you’re learning the server), you build the part you’re learning; PLAN.md with phase goals (“every phase ends with a working system and green tests”) + “Let’s continue” resumption — LLMs are “really, really good at making goal lists.” The hjkl trainer’s spaced drills and this skill are the same pedagogy: the machine holds the curriculum, the human holds the struggle.
• ponytail (OSS) (155k★, JS; via @santhosh_patell) — “makes your AI agent think like the laziest senior dev in the room. The best code is the code you never wrote.” One prompt (a single SKILL.md / AGENTS.md) implementing a 7-rung dependency ladder the agent must climb before writing anything: need-to-exist? (YAGNI skip) → already-in-codebase? (reuse) → stdlib? → native-platform? → installed-dependency? → one-line? → only then the minimum that works. Benchmark (honest framing): ~54% less code, ~20% cheaper, ~27% faster on 12 Haiku tasks in a real FastAPI+React repo — “only 12 tasks on Haiku, test on your own repo” (the tweeter’s caveat, echoed). v4.12 adds numbered review findings — “fix 2 and 4” as the whole review loop. The KISS preference and Musk process (“delete steps before optimizing them”) encoded as an agent skill; direct kin of the do-nothing-scripting arc’s minimal-core endpoint.
• jnsahaj/skills (102★; via @iamsahaj_xyz — “/explain-then-fix — reject non-understanding”, 162❤) — the understanding-first skill set. The flagship explain-then-fix workflow: pick ONE cause → reproduce on the reporter’s own case (“their data, their environment, their steps… a stand-in is labelled as a stand-in”) → explain in plain words with the cause drawn over the evidence (measured values marked on screenshots/traces, “from what the program computed, not eyeballed”) + a diagram of “what the code believes vs what the user sees” + file:line under the pictures → discuss fix options with recommendation → stop and wait for “go” → fix with tests that fail-before/pass-after on the reported case → show before/after. Rules: no code change before “go”, no push/close/publish without explicit yes every time. The repo’s other skills are the same philosophy at other seams: pit-of-success (correct behavior = the default path; kill footgun APIs), zero-tech-debt (rework as if intended UX/architecture existed from day one, “deleting compatibility cruft”), plus code-refactor-review / create-draft-pr / prepare-branch-context / ux-flow-plan. The kinship triangle: socratic-mentor for humans learning, retro for harnesses improving, explain-then-fix for agents fixing — “reject non-understanding” as the unifying rule across all three.
  Related: pstack (the skills-and-playbooks stack) · Agent tests (evals for agent behavior) · Golden repo (procedures as reviewable artifacts) · AI engineering

Deep Agents’ skill revamp: binding, pinning, reloading (2026-10-08)

sydneyrunkle (LangChain; tweet + quoted article captured): “skills are now the standard way to give agents domain knowledge — we’re seeing expansive skill registries (shared across agents/teams), enterprise registries growing to thousands of skills.” The three-level load model restated cleanly (discovery: name+description in system prompt → activation: read SKILL.md on task match → execution: scripts/references on demand — progressive disclosure keeping context small). The revamp, answering registry-scale needs: (1) bind tools to skills — tools load only when the agent reads that skill (tool bloat solved by the same disclosure gate); (2) pinned skills — explicit /meeting-prep-style requests load the skill before the next model call (deterministic activation alongside the model’s own matching); (3) skill reloading — a long-running thread picks up new/changed skills without starting over (registries are living; threads must see updates). Running example: LangChain’s GTM agent, 50+ skills covering a sales rep’s recurring work. For this note: the lifecycle gap this note had implicitly — at thousands-of-skills scale, skills need runtime semantics (binding, pinning, hot-reload), the same maturity curve skills-as-standard predicted.

Redline: the review loop lands natively in Hermes Desktop (2026-10-08)

HermesWatcher (37❤; quoting @3682539376x’s demo) → hermes-redline (OSS) (3★ JavaScript, day-old, catalog-submitted; tweet + repo captured): “guided Markdown review for Hermes Desktop — annotate passages, send batches back to the agent.” The loop: agent writes doc → ::redline{file=...} card appears → document opens in a docked pane → select any passage → ◆ comment / ◇ question / ✎ change request → queue a batch or fire one → the batch lands in chat as a numbered structured message (🔴 redline — review of <path> (N notes)) → agent edits → pane live-refreshes. Annotations persist in a doc.md.redline.json sidecar across restarts; three pieces, no core patches (Desktop plugin SDK + tiny FastAPI backend + sidecar). This is plannotator’s loop, native to Hermes — where plannotator is a browser surface hooking agent CLIs (Claude Code, Codex, Pi…), Redline is the same review protocol as a Desktop plugin speaking Hermes’ own composer. USER NOTE, verbatim: “Looks interesting reminds me of plannotator. We have to check whether plannotator works with Hermes desktop as well or if it’s possible to integrate with low to medium effort.” — open item: plannotator’s hook targets are CLI agents; the integration seam would be Hermes’ plugin/hook surface (Redline’s SDK path proves the pane+sidecar+structured-message pattern fits). Same author-of-loop as orca’s annotate-AI-diffs; the feedback-direction channel (Visualization family) now has three rungs: plannotator (browser, any CLI agent) → Redline (native Hermes pane) → orca (diff-annotation in the ADE).