agent-skills

A collection of skills for agentic LLM tools, following the Agent Skills specification.

Installation

• Agent-specific
  • Claude Code
  • OpenCode
• Package managers
  • dotagents
  • OpenSkills
  • skills.sh

Agent-specific

Claude Code

Install from the plugin marketplace:

/plugin marketplace add joshuadavidthomas/agent-skills

Install an individual skill plugin (recommended). Plugin names match skill directory names (for example sveltekit, skill-authoring, writing-cli-skills):

/plugin install reducing-entropy@joshthomas-agent-skills

Or install the bundle with all skills:

/plugin install all@joshthomas-agent-skills

CLI equivalent:

claude plugin install reducing-entropy@joshthomas-agent-skills --scope project

Requires Claude Code v1.0.33 or later.

OpenCode

Clone this repo and symlink the skills you want:

git clone https://github.com/joshuadavidthomas/agent-skills.git
cd agent-skills
mkdir -p ~/.config/opencode/skills
ln -s "$PWD/reducing-entropy" ~/.config/opencode/skills/reducing-entropy

OpenCode also discovers skills from .opencode/skills, .claude/skills, and .agents/skills in your project.

Requires OpenCode v1.0.190 or later, which has native skill loading built in. opencode-agent-skills is still available if you are stuck on an older version or if you want its specific loading behavior.

Package managers

dotagents

Install with dotagents:

npx @sentry/dotagents add joshuadavidthomas/agent-skills

Or install an individual skill:

npx @sentry/dotagents add joshuadavidthomas/agent-skills --name reducing-entropy

OpenSkills

Install with OpenSkills:

npx openskills install joshuadavidthomas/agent-skills
npx openskills sync

Use --global to install into ~/.claude/skills.

skills.sh

Install with skills.sh:

npx skills add joshuadavidthomas/agent-skills

Usage

Skills are model-invoked—the agent decides when to use them based on your request and the skill’s description. You can also explicitly ask for a skill:

Use the reducing-entropy skill to review this refactor

or reference it by name when relevant to your task.

Skills

coding-standards

Language-agnostic coding standards for design-level code review and implementation judgment. Covers domain modeling, state, modules, boundaries, effects, error handling, verification, complexity, and maintainability.

coolify-compose

Convert Docker Compose files to Coolify templates for both raw-compose and repository deployment modes. Covers Coolify magic variables (SERVICE_URL_*, SERVICE_PASSWORD_*), health checks, and common conversion/troubleshooting patterns.

crafting-effective-readmes

Guides you through writing READMEs matched to your audience and project type. Different audiences need different information—a contributor to an OSS project needs different context than future-you opening a config folder.

Uses a structured process to identify task type (creating, adding, updating, or reviewing) and ask relevant questions before drafting.

Includes:

• Templates for open source, personal, internal, and config projects
• Section checklist showing which sections matter for each project type
• Style guide covering common mistakes
• Reference materials: Standard README spec (with examples), “Art of README”, and Make a README guide

diataxis

Apply the Diátaxis framework for documentation structure and writing. Helps classify and produce tutorials, how-to guides, reference, and explanation docs.

english-please

Quick corrective for over-compressed explanations: one idea per sentence, re-anchor coined terms, no notation in prose, restate reasoning the reader never saw. The fast call to distill after a long run; writing is the full doctrine.

frontend-design-principles

Design-focused frontend skill for producing intentional, non-generic interfaces. Includes required discovery gates, signature-definition workflow, and self-review checks before presenting UI output.

html-artifacts

Generate grounded, self-contained HTML explanations for codebases, features, PRs and diffs, implementation recaps, investigations, data, causal mechanisms, and presentations. Defaults to an offline visual document with purposeful interaction, source evidence, responsive and print behavior, accessibility, and browser validation—not a generic miniature website.

grug-brained-dev

Cognitive interrupt skill for code that looks clean but feels painful to change: too fancy, too abstract, too many files, too many helpers, too many layers, or too well-factored into the wrong boxes. Grug fights complexity demon by forcing big brain AI into smol brain posture: what thing, thing do what, where meat, why five caves?

Uses Grug voice, no-hard-pivot rules, cave-painting names, helper-rent tests, future-rock checks, Chesterton’s Fence, locality of behavior, real-seam testing, and near-shore refactoring to turn smart-looking architecture into boring code that tells the truth.

jj

Jujutsu (jj) version control for Git-compatible repos. Covers the mental model (working copy as commit, change IDs, mutable history), agent-specific rules (always -m, no interactive commands), daily workflows, and progressive deep dives into revsets/filesets/templates, bookmarks and sharing, history rewriting, workspaces for parallel agents, and configuration.

Includes 13 reference files covering Git-to-jj command mapping, revset/fileset/template language specs, bookmark management, GitHub workflows, conflict handling, and more.

rust

Rust guidance for idiomatic API design and implementation across ownership, errors, traits, type design, async/Tokio, atomics, unsafe, macros, testing, performance, serde, interop, and project structure.

salsa

Salsa guidance for building incremental Rust systems: databases, tracked functions, input/tracked/interned structs, query pipelines, accumulators, cancellation, LSP integration, memory management, cycles, durability, and production architecture.

roadmap

Build evidence-backed software/product roadmaps from repo state, tickets, ideas, audit findings, design docs, and user goals. Gives a high-level view of what’s coming up, sequences work into Now/Next/Later, explains dependencies and tradeoffs, avoids fake dates, and routes each item to the next artifact owner (brainstorm, questions/research, design-discussion, writing-plans, or a user decision).

Defaults roadmap items to outcomes/capabilities/features, using epics, milestones, and phases only when they clarify sequencing or match project vocabulary. Writes the canonical project artifact as root ROADMAP.md, using docs/roadmaps/ only for scoped or alternate roadmaps, and stays above PR-level implementation planning.

strategic-roadmap

Generate and sequence high-leverage work inside one repository from user seed ideas, repo mining, old plans, branches/bookmarks, and architecture scans. Produces a strategic roadmap with generated opportunities, Now/Next/Later sequencing, architecture/deepening candidates, success criteria, rejected/not-now items, and next-artifact recommendations. Use this for repo-grounded opportunity discovery before plan banks or feature planning artifacts.

roadmap-to-improve-plans

Turn selected roadmap opportunities or accepted feature slices into grouped NNN-style improvement plan batches. Writes effort indexes, numbered plans, optional memos, verification gates, evals/regression checks, autonomy boundaries, drift checks, STOP conditions, rejected approaches, and executor handoff notes for this pipeline.

feature-planning-artifacts

Deepen a high-value feature, architecture candidate, or NNN plan into a feature planning bundle: README index, gated design discussion, structure outline, optional research, and final executor plan with success criteria, evals, and autonomy boundaries.

improve

Survey a codebase as a senior advisor — strictly read-only — and turn the highest-value findings into implementation plans for other agents to execute. Four phases: recon (including the project’s domain docs and ADRs), parallel category audits from a playbook, vetting every finding against the actual code, then handing the selected findings to the writing-plans skill for the plan artifacts.

Supports effort levels (quick/standard/deep), single-category focus, branch-scoped audits, and a roadmap/direction mode. Findings are evidence-backed (file:line), ordered by leverage, and “not worth doing” is a recorded verdict.

improving-prompts

Apply Anthropic’s documented Claude 4.5 best practices to CLAUDE.md, AGENTS.md, custom commands, and skill files. Uses actual guidance from Anthropic instead of inventing improvements.

The key constraint: don’t change anything until you understand what specific behavior is failing. Provides a quick reference table mapping common issues to fixes, plus defensive tables of rationalizations and red flags to prevent agents from bypassing the requirement for concrete issues.

reducing-entropy

Helps you evaluate designs, review code, and refactor with a bias toward deletion. The core question: “What does the codebase look like after?”

Uses a “Three Questions” framework: What’s the smallest codebase that solves this? Does the change result in less total code? What can we delete?

Includes “mindsets” with references of ideas and writings from Rich Hickey (simplicity vs. ease), Simon Willison (PAGNI—what’s expensive to add later), and data-oriented design principles. Loads at least one mindset before starting.

researching-codebases

Coordinate parallel sub-agents to answer complex codebase questions that span multiple files or require tracing through code. Supports checking existing research before starting new investigations.

Includes:

• Agent definitions for code-locator (fast/cheap), code-analyzer (thorough), code-pattern-finder, and web-searcher
• Agent selection guide with cost/performance tradeoffs
• Scripts for managing research memory in .research/ or ~/.research/: list, search, read, promote
• Output format specification for research documents

[!NOTE] Requires installing agent definitions to your CLI tool. See the agents README.

skill-authoring

Create, synthesize, test, debug, review, and refine agent skills. Uses a job-selection table to route agents to the right workflow, covers high-signal descriptions, progressive disclosure, source-backed synthesis, provenance, activation testing, and failure-driven refinement.

svelte5

Svelte 5 guidance covering runes ($state, $derived, $effect, $props, $bindable), class-based state patterns, context API usage, and Svelte 4→5 migration defaults.

sveltekit

SvelteKit routing, layouts, data loading, actions, authentication patterns, form validation, and remote functions (command(), query(), form()).

writing

General prose doctrine for anything a human will read, built on Orwell’s “Politics and the English Language”: let the meaning choose the word, never reach for the ready-made phrase. Ten rules merging Orwell and Strunk, both reader-side questions (what they know, what they came for), tone-to-stakes discipline, and a catalog of AI writing tropes with examples and fixes. Includes the full Orwell essay as a reference and a distilled snippet for pasting into AGENTS.md/CLAUDE.md.

writing-error-messages

Write and review human-facing software error messages: UI failures, form validation, auth and account-recovery copy, retry/support paths, CLI errors, and API errors humans will read.

Focuses on making errors specific, actionable, non-blaming, accessible, and safe. Includes the important security exception for authentication and recovery flows, where generic messages may be required to avoid account enumeration.

writing-cli-skills

Guide for building high-quality skills around CLI tools. Emphasizes hands-on tool usage, practical command organization, progressive disclosure, and review checklists.

writing-plans

Write self-contained implementation plan files that a fresh, possibly weaker executor can run without the author’s context. Splits decided work into PR-sized, independently-landable plans — intent-based (sketches over implementations), with verification gates, STOP conditions, drift checks, and maintenance notes.

Includes templates for individual plans, the effort-level index (status table, dependency notes, bounded reconciliation log), and design-fork memos — the round-trip where an executor hits an unanticipated fork, hands back a description of the state and desired outcome, and the planner answers with a researched, evidence-backed verdict.

Acknowledgements

This collection includes and adapts work from several sources.

crafting-effective-readmes

Reference materials include:

• Art of README by Kira (CC BY 2.0)
• Standard README by Richard Littauer (MIT)
• Make a README by Danny Guo (MIT)

diataxis

Reference content derived from the Diátaxis documentation framework (repo) by Daniele Procida (CC BY-SA 4.0).

frontend-design-principles

Adapted from:

• The frontend-design skill in anthropics/skills (Apache 2.0)
• Dammyjay93/interface-design (MIT, Damola Akinleye)
• Teaching Claude to Design Better: Improving Anthropic’s Frontend Design Skill (relevant PR) by Justin Wetch

html-artifacts

Synthesizes Anthropic’s Artifact documentation and example skills; Thariq Shihipar’s “The unreasonable effectiveness of HTML” and example gallery; Matt Pocock’s HTML architecture report guidance; writings by Bret Victor, Distill, C4, GOV.UK, Datawrapper, and The Pudding; WCAG and MDN accessibility guidance; and open-source work from visual-explainer, visualise, SocratiCode, and Microsoft’s a11y-llm-eval. See html-artifacts/references/research-basis.md for source-level notes and caveats.

grug-brained-dev

Inspired by The Grug Brained Developer, a funny-looking but painfully useful guide to fighting complexity demons with smol brain humility, plain names, saying no, delayed factoring, real cut points, small refactors, and suspicion of premature abstraction. This adaptation aims to make coding agents inhabit the Grug posture, not just summarize the article.

improve

Adapts the advisor workflow and audit playbook from shadcn’s improve skill (MIT), with the domain-docs/ADR awareness and module-depth framing (deletion test, shallow vs. deep modules) of Matt Pocock’s improve-codebase-architecture. The depth vocabulary traces to John Ousterhout’s A Philosophy of Software Design.

improving-prompts

Includes best practices from Anthropic’s Claude documentation.

jj

Synthesizes guidance from:

• Jujutsu — official documentation used for reference material (Apache-2.0)
• Steve Klabnik’s Jujutsu Tutorial — narrative tutorial providing mental model and conceptual grounding
• jujutsu-skill by Dan Verbraganza — agent-specific workflow patterns and environment rules (MIT)
• dot-claude jj-workflow by TrevorS — concise AI-focused daily workflow patterns (ISC)
• agent-skills working-with-jj by Yves Parès — version-aware command syntax and JJ_CONFIG agent configuration pattern (MIT)
• jjtask by Alexander Ryzhikov — anti-patterns and gotchas for agent use (MIT)
• sgai by Sandgarden — Git-to-jj command mapping table (modified MIT)
• dotfiles jj-history-investigation by Edmund Miller — history investigation techniques (MIT)

reducing-entropy

Reference mindsets summarize and cite works by Rich Hickey, Simon Willison, Luke Plant, Jacob Kaplan-Moss, and others. See individual reference files for source links.

rust

References and adapts guidance from:

• Actors with Tokio by Alice Ryhl
• Aiming for correctness with types by Amos Wenger (fasterthanlime)
• Async: What is blocking? by Alice Ryhl
• Common Rust Lifetime Misconceptions by pretzelhammer (CC BY-SA 4.0)
• Rust Atomics and Locks by Mara Bos
• Effective Rust by David Drysdale (CC BY 4.0)
• Error Handling Survey by Yoshua Wuyts
• Error Handling in Rust by Andrew Gallant (BurntSushi)
• Error handling in Rust by Luca Palmieri
• Making Illegal States Unrepresentable by corrode.dev
• Modular Errors in Rust by Sabrina Jewson
• Parse, Don’t Validate by Alexis King
• Pin by Without Boats
• Rust API Guidelines (MIT OR Apache-2.0)
• Rust Design Patterns (MPL-2.0)
• The Rust Programming Language (MIT OR Apache-2.0)
• The Rust Reference (MIT OR Apache-2.0)
• The Rustonomicon (MIT OR Apache-2.0)
• The Typestate Pattern in Rust by Cliff L. Biffle

salsa

References code and patterns from:

• BAML (Apache-2.0)
• Cairo (Apache-2.0)
• Fe (Apache-2.0)
• Mun (MIT OR Apache-2.0)
• Salsa (MIT OR Apache-2.0)
• WGSL Analyzer (MIT OR Apache-2.0)
• django-language-server (Apache-2.0)
• rust-analyzer (MIT OR Apache-2.0)
• stc (Apache-2.0)
• ty / Ruff monorepo (MIT)

researching-codebases

Adapted from the commands and agents in HumanLayer (Apache 2.0).

skill-authoring

Synthesizes skill-authoring guidance from:

• Agent Skills specification and docs
• anthropics/skills skill-creator (Apache 2.0)
• EveryInc/compound-engineering-plugin create-agent-skills
• obra/superpowers writing-skills
• pproenca/dot-skills skill-authoring
• pytorch/pytorch .claude/skills/skill-writer
• getsentry/skills skill-writer (Apache 2.0)
• David Cramer’s Skill Synthesis

See skill-authoring/README.md for the detailed source inventory and synthesis decisions.

svelte5 and sveltekit

Reference and guidance adapted from:

• svelte-claude-skills by Scott Spence (MIT)
• Svelte documentation (MIT)
• Modern SvelteKit Tutorial by Scott Tolinski
• Svelte Stores Streams Effect by Ben Davis (video)

writing

Built on George Orwell’s “Politics and the English Language” (1946), included in full as a reference. Strunk’s composition rules are distilled from the public-domain 1918 Elements of Style (Project Gutenberg, via obra/the-elements-of-style). The trope catalog is adapted and merged from the ai-writing-tropes skill in Xe/site (zlib, Christine Dodrill; content from tropes.fyi) and Wikipedia’s Signs of AI writing (CC BY-SA 4.0).

writing-error-messages

Synthesizes product writing and UX guidance from Wix UX, GOV.UK Design System, Nielsen Norman Group, Atlassian Design, Microsoft Learn, Shopify Polaris, and OWASP Authentication Cheat Sheet.

writing-plans

Adapts the handoff plan template and advisor-for-a-cheaper-executor framing from shadcn’s improve skill (MIT), with inspiration from obra/superpowers writing-plans and the planning stages of HumanLayer’s research/plan/implement workflow.

License

Licensed under the MIT license. See the LICENSE file for more information.