msewell
UserLike everyone else, I'm sharing my agent stuff.
Categories
Indexed Skills (48)
applying-tcr-with-agents
Applies TCR (test && commit || revert) discipline as a workflow and guardrail for AI-assisted software development. Sets up TCR scripts, selects revert strategies, integrates with tool-specific hooks, and configures guardrails for autonomous agent loops. Use when implementing test-and-commit-or-revert workflows, adding automatic revert on test failure, setting up agent coding loops with safety nets, enforcing small steps via automatic commit on green and revert on red, or when the user mentions TCR, test && commit || revert, automatic revert on failing tests, or coding loop guardrails.
designing-event-models
Designs and reviews Event Models — the visual blueprint for information systems using events, commands, read models, and screens. Produces structured YAML artifacts (swimlanes, slices, events, commands, read models, Given/When/Then specifications). Use when designing a new system or feature with Event Modeling, reviewing an existing event model for anti-patterns or completeness gaps, defining slices and GWT scenarios, or creating an event model from a system description.
generating-marp-slides
Generates professional slide decks as Marp Markdown from source material (memos, documents, notes, bullet points). Produces assertion-titled, visually consistent presentations with speaker notes, exportable to PDF, PPTX, and HTML via Marp CLI. Use when creating presentations, generating slides, building a slide deck, making a pitch deck, converting a document to a presentation, or when the user mentions Marp, slides, or slide decks.
stripping-ai-tells
Detects and removes AI writing tells (ChatGPT-isms, Claude-isms) from text using a three-pass editing workflow: vocabulary sweep, structural cleanup, and voice/tone adjustment. Identifies flagged words (delve, tapestry, robust, pivotal), structural patterns (tricolon abuse, synonym cycling, trailing participles, em-dash overuse), and tonal issues (sycophancy, hedging, importance puffery). Use when the user asks to remove AI tells, humanize AI text, make writing sound less like AI, edit for ChatGPT-isms or Claude-isms, strip AI language, clean up AI-generated content, or review text for machine-generated patterns.
applying-composition-over-inheritance
Evaluates object-oriented designs to choose composition, inheritance, or algebraic data types. Produces decision rationales, refactoring plans, and review guardrails that reduce fragile base classes and subclass explosion. Use when reviewing class hierarchies, deciding between extends vs interfaces, refactoring inheritance-heavy code, introducing dependency-injected collaborators, or defining team conventions for object modeling.
applying-practical-typography
Applies and reviews professional typography rules based on Butterick's Practical Typography. Covers characters and symbols (curly quotes, dashes, ellipses, nonbreaking spaces), text formatting (bold/italic, caps, kerning, letterspacing, color), body text settings (point size, line spacing, line length, indents, hyphenation), page layout (margins, headings, tables, lists, columns), font selection (professional vs system fonts, mixing, alternate figures), and document-specific guidance (emails, presentations, résumés, research papers, business cards, letterhead, websites). Use when generating or reviewing text for documents, web pages, presentations, or any formatted output, when the user asks about typography rules, when checking for common typography mistakes (straight quotes, double spaces, bad fonts, improper dashes), or when setting up document styles and layouts.
applying-vertical-slice-architecture
Designs, reviews, and migrates codebases using Vertical Slice Architecture (VSA) — organizing by business capability instead of technical layer. Produces slice boundaries, folder structures, sharing strategies, and migration plans. Use when designing a new VSA codebase, reviewing an existing VSA codebase for anti-patterns, migrating from layered architecture to vertical slices, deciding slice granularity or folder organization, handling shared code across slices, or when the user mentions vertical slices, feature folders, or organizing by use case.
arazzo-specification
Guides writing, reviewing, and modifying Arazzo workflow specifications (OpenAPI Initiative standard for multi-step API workflows). Use when creating Arazzo documents from scratch, adding steps or workflows to existing specs, reviewing Arazzo files for correctness, or generating API workflow definitions. Covers document structure, runtime expressions, success criteria, control flow, data threading, reusable components, workflow composition, AI agent integration, and validation.
assessing-platform-scalability
Performs end-to-end platform scalability assessments using a phased methodology, maturity scoring model, risk classification, and prioritized remediation planning. Produces structured scalability reports with evidence, scorecards, and actionable roadmaps, plus optional executive summaries and incident runbook drafts. Use when evaluating whether a system can handle growth, diagnosing scaling bottlenecks, preparing technical due diligence, designing load or resilience validation plans, or building a scalability improvement strategy.
auto-improving-agents-md
Sets up, structures, and auto-improves AGENTS.md files for coding agent projects. Bootstraps new AGENTS.md with self-improvement meta-rules, structures sections for clean rule placement, audits and prunes existing files against an instruction budget, performs end-of-session reflection to capture learnings, and proactively proposes AGENTS.md updates when corrections or conventions are discovered mid-session. Use when setting up AGENTS.md, adding auto-improvement to an existing AGENTS.md, pruning or auditing AGENTS.md, performing end-of-session reflection, or when the user mentions auto-improving, self-improving, or maintaining agent instructions.
balancing-coupling
Analyzes codebases and software designs for unbalanced coupling, classifies coupling by strength, distance, volatility, and connascence, identifies when not to decouple, and produces prioritized refactoring or enforcement plans. Use when reviewing coupling, decoupling modules, reducing dependencies, improving modularity, setting module or service boundaries, untangling legacy systems, addressing shared databases, synchronous call chains, circular dependencies, or adding TypeScript/JavaScript dependency-boundary checks.
benchmarking-with-hyperfine
Designs, runs, interprets, and reports trustworthy command-line benchmarks using hyperfine. Chooses warmups, run counts, lifecycle hooks, shell control, parameter sweeps, exports, noise controls, and CI/Bencher integration. Use when benchmarking CLI commands or builds, comparing implementations, checking performance regressions, tuning hyperfine flags, or interpreting hyperfine JSON/Markdown results.
building-tuning-panels
Builds live parameter tuning panels as floating developer overlays with sliders, toggles, color pickers, dropdowns, and spring controls wired to app values for real-time visual exploration. Selects suitable panel libraries by stack (DialKit, Leva, Tweakpane, lil-gui, native HTML), maps hardcoded values to controls with sensible ranges, adds export/presets, and strips panel code from production builds. Use when users ask to add debug sliders, a variables panel, a tuning panel/GUI, or live tweak controls for animation, styling, layout, typography, color, physics, or chart parameters.
commenting-code
Writes and reviews code comments that preserve non-obvious intent, contracts, invariants, and failure semantics without narrating the code. Uses clear layer placement (interface, implementation, cross-module) and lightweight review checks to keep comments accurate over time. Use when adding or reviewing inline comments, docstrings, API docs, or design notes for behavior that could be misunderstood.
creating-c4-diagrams
Creates, reviews, and interprets C4 software architecture diagrams (System Context, Container, Component, Dynamic, Deployment). Produces Structurizr DSL or Mermaid C4 diagram code following C4 model best practices. Use when the requested output is explicitly C4, when reviewing existing C4 diagrams for correctness and anti-patterns, when generating Structurizr DSL workspaces, when producing Mermaid C4 diagrams for READMEs, or when using C4 diagrams as context for design decisions, code generation, risk analysis, or onboarding.
designing-backend-error-messages
Designs backend API error contracts with a REST-default approach using RFC 9457 Problem Details, stable machine-readable codes, retry semantics, validation error payloads, observability, and security-safe messaging. Reviews existing error handling against a binary rubric and proposes concrete fixes. Produces optional artifacts such as errors.yaml entries, Problem Details examples, OpenAPI fragments, and runbook templates. Use when creating or revising backend error responses, auditing API error quality, mapping status/code behavior, or documenting error handling for REST, gRPC, GraphQL, and async services.
designing-deep-modules
Guides designing, reviewing, and refactoring modules for depth — maximizing functionality hidden behind minimal interfaces. Analyzes module boundaries, identifies shallow modules and classitis, applies deep module heuristics (pull complexity downward, define errors out of existence, design for the common case), and produces refactoring plans. Covers information hiding, leaky abstractions, and abstraction boundaries based on Ousterhout's A Philosophy of Software Design. Use when designing module interfaces, reviewing code for shallow abstractions, refactoring pass-through layers, evaluating API surface area, reducing interface complexity, or applying deep module principles at any scale (functions, classes, packages, services, APIs).
designing-rest-apis
Guides designing, reviewing, and governing RESTful APIs — resource modeling, URL structure, HTTP methods, status codes, error handling (RFC 9457), pagination, versioning, security, authentication, caching, idempotency, bulk operations, async patterns, file uploads, OpenAPI documentation, API-first process, and AI-agent consumers. Use when designing new REST API endpoints, reviewing existing API designs, adopting API-first development, running API design sessions, enforcing API contracts in CI/CD, governing an API program, choosing between REST patterns (cursor vs offset pagination, PUT vs PATCH, polling vs webhooks), writing OpenAPI specs, designing for AI-agent consumers (MCP), or making API evolution and deprecation decisions.
explaining-code-changes
Creates self-contained HTML learning walkthroughs of code changes with background, intuition, code walkthroughs, embedded diagrams, and a self-check quiz. Use when the user asks to explain a diff, branch, commit, pull request, PR, or code change for learning, onboarding, or handoff. Not for code review, approval/readiness verdicts, or merge decisions.
humanizing-prose
Rewrites and reviews prose so it sounds written by a specific human rather than generic AI output. Preserves meaning, facts, language, and audience while removing common AI tells and improving voice, specificity, restraint, rhythm, and reader trust. Use when humanizing AI-generated text, editing drafts, matching a writing sample, checking for AI-sounding prose, or revising essays, posts, docs, reports, emails, documentation copy, product copy, and multilingual prose in the source language.
kotlin-functional-programming
Guides writing idiomatic, functional-style Kotlin code using built-in language features. Use when asked to write, review, or refactor Kotlin code for immutability, pure functions, sealed types, error handling, collections, coroutines, or functional architecture patterns.
making-invalid-states-unrepresentable
Analyzes existing code and guides new type design to make invalid states unrepresentable using type system techniques such as sum types, newtypes, typestate, branded types, and parse-don't-validate. Use when reviewing code for invalid-state bugs, refactoring types to eliminate impossible states, designing domain models, or applying compile-time correctness patterns. Language-agnostic.
markdown-section-summarizer
Summarizes Markdown files section-by-section with strict sentence budgets derived from source section length. Use when you need deterministic per-section summary quotas, inventory-first workflows, and mechanical verification that each section has exactly floor(sqrt(n)) summary sentences.
mermaid-sequence-diagrams
Generates, reviews, and fixes Mermaid-only sequence diagrams following syntax rules and best practices. Use when creating Mermaid sequence diagrams from system descriptions, reviewing existing Mermaid sequence diagrams for correctness, fixing parse errors, or refactoring large Mermaid sequence diagrams into focused sub-diagrams. Covers participants, arrows, activations, control flow, notes, styling, and common anti-patterns.
obsidian-best-practices
Guides setting up, configuring, and organizing Obsidian vaults for software engineers — folder structure, plugins, templates, Git backup, Dataview queries, and AI integrations. Also creates and edits Obsidian vault files following best practices for frontmatter schemas, wikilinks, Templater syntax, Dataview code blocks, and Canvas JSON. Use when setting up a new vault, recommending plugins, creating note templates, writing Dataview queries, configuring Git sync, advising on vault organization, or generating Obsidian-compatible Markdown files.
property-based-testing-with-kotest
Writes property-based tests using Kotest's kotest-property module. Identifies testable properties, designs generators, and configures PBT for Kotlin/JVM projects. Use when writing property-based tests, creating custom Arb generators, choosing property patterns (roundtrip, invariant, idempotence, oracle), debugging shrunk counterexamples, or integrating PBT into a Kotlin test suite alongside example-based tests.
quizzing-before-approving
Administers a structured comprehension quiz on a scoped code change to verify the reviewer genuinely understands it before approving or merging. Generates 5–7 questions in three batched rounds using a fixed rubric (restatement, alternatives, invariant, failure-mode, scope, targeted trickiest lines), grades strictly, provides context without revealing answers on failures, and loops until the user passes. Use when the user wants to be quizzed on a diff, wants to verify their understanding before merging or approving AI-generated code, wants a comprehension check before approving, or says things like "quiz me on this change", "test my understanding of this diff", "quiz before approve", or "quiz me before I merge."
rendering-clean-diagrams
Generates clean, readable general-purpose diagrams from text DSLs (Mermaid, D2, Graphviz, PlantUML), chooses suitable layout engines, and runs validation/render loops to produce embeddable SVG/PNG/Markdown outputs. Use when a user asks for a flowchart, ERD, state machine, dependency graph, mindmap, network graph, architecture sketch, or basic sequence diagram that must render reliably. Not for explicit C4 modeling or deep Mermaid sequence-specific syntax work.
reviewing-pull-requests
Reviews GitHub pull requests end-to-end using gh CLI. Gathers PR metadata, diff, linked issues, and CI status. Analyzes code for bugs, security risks, performance issues, and goal alignment against repo conventions. Runs available lint, type-check, and test commands locally. Produces a prioritized report with severity-classified feedback (blocking, suggestion, nit, praise) and an approve/request-changes verdict. Optionally posts the review to GitHub after user confirmation. Use when asked to review a PR, check a pull request, audit code changes, evaluate if a PR is ready to merge, provide code review feedback, assess PR quality, or when the user says review PR #N, is this PR ready, look at this pull request, or code review.
searching-and-extracting-web-with-parallel-cli
Runs Parallel CLI web search and URL extraction in non-interactive, text-first mode for AI agents. Chooses between `parallel-cli search` and `parallel-cli extract`, applies fast defaults, and adds source/date filters when needed. Use when the user asks to discover current web sources, gather citations from specific domains, or extract targeted information from known URLs.
slicing-pbis
Slices, reviews, and writes product backlog items (PBIs) using priority-ordered quality characteristics (Valuable > Completable > Negotiable > Independent > Commensurate > Small), vertical slicing, and the splitting meta-pattern. Produces well-formed, commensurately sized PBIs with binary acceptance criteria. Use when splitting large PBIs or user stories, reviewing backlog items for quality, writing new PBIs from requirements, refining a product backlog, decomposing epics into stories, or when the user mentions PBI slicing, story splitting, backlog refinement, or vertical slices.
specifying-by-example
Writes, reviews, and refines Specification by Example (SBE) artifacts — Gherkin scenarios, example mappings, rule-example tables, and scenario outlines. Produces declarative, single-behavior specifications using ubiquitous language. Use when writing acceptance criteria, Given-When-Then scenarios, feature files, BDD specifications, or executable specifications, when reviewing Gherkin for anti-patterns, when running Example Mapping or Three Amigos sessions, or when the user mentions SBE, BDD, specification by example, or spec-driven development.
tdd-with-llm-agents
Enforces strict red/green/refactor TDD discipline when writing code. Guides the agent through one-test-at-a-time cycles, prevents test subversion, and ensures minimal implementation. Use when writing code with TDD, doing test-driven development, implementing features test-first, or when the user mentions red/green TDD, failing tests first, or test-driven workflow.
threat-modeling
Produces structured threat models for software systems using STRIDE on data flow diagrams. Generates DFDs with trust boundaries, identifies threats per element, scores risks, and defines concrete mitigations. Outputs a complete threat model Markdown document through phased, interactive delivery. Use when threat modeling a system, analyzing security threats, identifying attack surfaces, performing STRIDE analysis, assessing security risks in architecture, creating a threat model document, or when the user mentions threat model, attack surface, trust boundaries, STRIDE, or security risk analysis.
toon-format
Instructs an LLM agent when and how to use TOON (Token-Oriented Object Notation) for encoding and generating structured data. Use when injecting structured data into context, encoding tool results, preparing RAG documents, producing structured output, or advising on TOON integration.
tweet-review
Reviews draft tweets and provides engagement optimization recommendations with improved alternatives. Use when the user has a draft tweet or thread and wants feedback on how to maximize reach, replies, and engagement on Twitter/X. Primarily niche-agnostic with additional guidance for tech Twitter.
using-git-notes-for-ai-context
Reads, writes, and configures git notes and trailers for AI agent context — attribution, decision reasoning, prompts, and CI/CD metadata. Sets up namespace conventions, hook automation, team sync, and compliance. Use when storing AI attribution in git, setting up git notes for AI tracking, querying constraints or directives before modifying code, configuring notes sync for a team, choosing between git notes and trailers, or when the user mentions git notes, git trailers, AI attribution, AI provenance, Lore protocol, or decision context in commits.
using-lightpanda
Operates Lightpanda, a Zig-based headless browser with no rendering pipeline, as an AI agent's browser tool via native MCP or CDP. Covers MCP tool selection (goto, markdown, semantic_tree, interactiveElements, structuredData, click, fill), output mode strategy, the observe-decide-act loop, actions grounded in node IDs, token-efficient page reading, and Chrome fallback triggers. Use when tasks require interactive or stateful web navigation on JS-heavy sites (multi-step flows, form fill/click actions, DOM-aware extraction by node ID), or when the user explicitly asks to use Lightpanda.
using-markit
Converts known files and URLs to markdown with markit for agent workflows. Selects deterministic modes (--json for machine-readable parsing, -q for raw markdown output), handles installation and conversion failures, and applies safe defaults for optional AI description/transcription. Use when users already have specific sources and ask to convert or extract text, turn a document or webpage into markdown, transcribe audio, or describe images from PDF, DOCX, PPTX, XLSX, HTML, EPUB, CSV, JSON, XML, ZIP, URL, image, or audio sources.
writing-agent-skills
Creates, reviews, and iterates on Agent Skills (the open, cross-platform format for extending AI agents). Scaffolds new skill directories, writes SKILL.md files with proper frontmatter and body structure, applies progressive disclosure, reviews existing skills for anti-patterns, and guides testing workflows. Use when the user asks to create a skill, write a SKILL.md, review or improve an existing skill, or structure agent instructions.
writing-anki-cards
Generates high-quality Anki flashcards from source material and adds them directly to Anki via AnkiConnect. Produces atomic cloze and Q/A cards, skips duplicates safely, and returns a succinct run report. Use when the user asks to create Anki cards, flashcards, or spaced-repetition prompts from notes, articles, docs, or text.
writing-checklist-communications
Writes and improves checklist-based professional communications -- requests for action, handoffs, meeting agendas/follow-ups, and process runbooks. Applies structured templates, item-writing rules (verb + object + criteria), and anti-pattern checks to produce clear, actionable checklists. Use when drafting a request for action, creating a handoff document, preparing a meeting agenda, writing meeting follow-up notes, building a runbook, delegating work, asking for specific action by a deadline, or reviewing and improving an existing checklist-based communication.
writing-git-commit-messages
Writes and reviews git commit messages following Conventional Commits and the seven fundamental rules. Produces well-formatted, atomic, automation-friendly commit messages. Use when writing a commit message, reviewing commit messages, committing code changes, or when the user mentions git commits, commit messages, or changelogs.
writing-okrs
Writes, refines, and evaluates Objectives and Key Results (OKRs) for any team or org size. Applies a structured quality rubric (6 Objective dimensions, 8 Key Result dimensions), enforces committed vs. aspirational tagging, catches the necessary-but-not-sufficient trap, detects 20 named anti-patterns by severity, and produces complete OKR documents with baselines, targets, metric definitions, and initiative separation. Use when drafting new OKRs, improving or refining draft OKRs, scoring OKRs against a quality rubric, auditing an OKR program for anti-patterns, running planning-week reviews, or when the user mentions OKRs, key results, quarterly goals, objectives, Q1/Q2/Q3/Q4 goal-setting, or OKR planning.
writing-persuasive-documents
Writes and reviews persuasive professional documents — reports, proposals, memos, briefs, articles, and recommendations — using reader-centered principles: value-first openings, problem framing, tension language, cost of inaction, argument over explanation, and evidence building. Produces documents that change what readers think rather than showing what the writer knows. Use when drafting proposals, executive summaries, recommendations, business cases, or position papers, when reviewing or improving drafts for persuasiveness and impact, when restructuring a document to lead with the problem and stakes, or when the user mentions persuasive writing, making a case, or influencing a decision.
writing-project-status-reports
Writes and reviews high-signal project status reports using RAG indicators, layered structure, and exception-based reporting. Produces weekly, monthly, milestone, and sprint status reports in Markdown. Use when drafting a project status report, reviewing an existing status report for quality, creating executive summaries, setting up RAG health indicators, or advising on reporting cadence and format.
writing-wiki-content
Drafts, rewrites, copy-edits, and reviews English-language wiki content. Produces clear, neutral, accessible prose and concrete recommendations for structure, language, punctuation, dates, links, lists, quotations, and formatting. Use when writing or reviewing a wiki article, knowledge-base page, Markdown wiki page, or documentation page.
testing-with-nullables
Guides writing fast, reliable, refactoring-friendly tests using the Nullables pattern language (James Shore's 'Testing Without Mocks'). Produces narrow, sociable, state-based tests with production code that has an infrastructure 'off switch' — no mock frameworks needed. Use when writing tests, replacing mocks with Nullables, making infrastructure code testable, adding createNull() factories, implementing output tracking, wrapping external dependencies, or adopting testing-without-mocks patterns. Covers embedded stubs, configurable responses, behavior simulation, A-Frame architecture, and incremental migration from mock-based test suites.
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.