MMCPMarkets
JA

joshuadavidthomas/agent-skills

Developer tools
51 stars Качество 45 Тренд 45
Repository Install

A collection of skills for agentic LLM tools

Обзор

A collection of skills for agentic LLM tools, following the Agent Skills specification. Install an individual skill plugin (recommended). Plugin names match skill directory names (for example sveltekit, skill-authoring, writing-cli-skills): Clone this repo and symlink the skills you want: 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. Use --global to install into ~/.claude/skills. 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

README

agent-skills

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

Installation

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:

diataxis

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

frontend-design-principles

Adapted from:

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:

salsa

References code and patterns from:

researching-codebases

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

skill-authoring

Synthesizes skill-authoring guidance from:

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

svelte5 and sveltekit

Reference and guidance adapted from:

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.

View this README on GitHub

Рекомендуемые инструменты

Попробуйте другой запрос или уберите фильтр.

Установка

npx skillfish add joshuadavidthomas/agent-skills