New: 97,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Rigor Plugin Author

by rigortype in rigortype/rigor

Author a new Rigor plugin, choosing plugins/ for production support or examples/ for a contract walkthrough.

MPL-2.0Auto-check: notesDevelopment

Install Rigor Plugin Author

skills CLI
$ npx skills add rigortype/rigor --skill rigor-plugin-author -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install rigortype/rigor rigor-plugin-author --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/rigortype/rigor.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/rigor-plugin-author .claude/skills/rigor-plugin-author && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
rigor-plugin-author
GitHub stars
106
Token cost
~3.3k tokens
SKILL.md length
1,450 words
Files
5 (incl. references)
Skills in repo
36
Repo updated
First seen
Licence
MPL-2.0

At a glance

Author a new Rigor plugin, choosing plugins/ for production support or examples/ for a contract walkthrough.

  • Works in 2 steps: Decide where the plugin lands → 5 — Where this plugin will live (per…
  • Extending Rigor for a DSL
  • SKILL.md covers Phase 0 — Decide where the…, Phase 0.5 — Where this plugin…, Reading order — modules and… and Worked examples to copy from, plus 3 more sections
  • Calls make, git and gem

What it does

Rigor Plugin Author is an agent skill from rigortype/rigor. Author a new Rigor plugin, choosing plugins/ for production support or examples/ for a contract walkthrough. Use when extending Rigor for a DSL, framework, or macro; not for editing an existing plugin or the analyzer engine.

Its SKILL.md is about 3.3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files, including reference files (for example `references/01-requirements-and-templates.md`, `references/02-scaffold-walker-demo.md` and `references/03-test-and-ship.md`).

It sits in Development. The repository describes itself as: Inference-first static analysis for Ruby. The licence is MPL-2.0.

When your agent uses it

  • Extending Rigor for a DSL
  • Not for editing an existing plugin
  • The analyzer engine

Example prompts

  • “/rigor-plugin-author”

Workflow steps

2 steps, taken from the step headings in SKILL.md.

  1. Decide where the plugin lands
  2. 5 — Where this plugin will live (per ADR-31)

What it can do on your machine

Read from SKILL.md and the folder at commit c7b6b60. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • make
    • git
    • gem
    • nix
    • bundle

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Rigor Plugin Author loads about 3.3k tokens when it runs, and up to ~12k if it reads all its reference files. Until then it costs about 62 tokens; SKILL.md has 1,450 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~62
When it runs · the whole SKILL.md, loaded when a task matches
~3.3k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~12k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NoteMentions a .env fileSKILL.md:105
    (`Dotenv.load(path)` call), Q2=E (reads `.env` file), Q3=A (known finite set of variable names), Q4=B (error on missing

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from rigortype/rigor at commit c7b6b60, republished under its MPL-2.0 licence (© rigortype). 1,450 words, ~3,311 tokens.

Download SKILL.mdSave it as .claude/skills/rigor-plugin-author/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.
name
rigor-plugin-author
description
Author a new Rigor plugin, choosing `plugins/` for production support or `examples/` for a contract walkthrough. Use when extending Rigor for a DSL, framework, or macro; not for editing an existing plugin or the analyzer engine.
license
MPL-2.0
metadata.internal
true
metadata.version
0.1.0
metadata.homepage
https://github.com/rigortype/rigor

Rigor Plugin Author

Decide placement first (Phase 0 below), then load the four reference files in order. All commands run through the Nix Flake (nix develop --command ...) per AGENTS.md.

Phase 0 — Decide where the plugin lands

Trigger this skill when the user requests a new plugin: "Create a Rigor plugin that catches Y", "Extend Rigor to understand our DSL Z", "Write a plugin similar to rigor-units but for currency", or Japanese equivalents.

Do NOT trigger for:

  • Edits / bug-fixes / new diagnostics on an existing plugin under plugins/<id>/ or examples/<id>/ — these are ordinary edit tasks; modify the plugin in place and add a changelog.d/ fragment.
  • Analyser-engine work in lib/rigor/inference/ / lib/rigor/analysis/ / lib/rigor/plugin/ — that's core development.
  • Post-landing maintenance (refactor / rename / dependency bump on an already-shipped plugin) — these don't need the 10-phase pipeline; they're scoped per task.
SignalLands under
Real gem / framework (Rails, RSpec, dry-rb, Sorbet, Devise, Sidekiq, GraphQL, …)plugins/<id>/
User's in-house DSL on a real projectplugins/<id>/
Installed via Gemfile, activated in .rigor.yml against real sourceplugins/<id>/
Deliberately fictional / virtual domain (tiny Lisp, units-of-measure, fake route YAML)examples/<id>/
Authored to demonstrate one architectural surface of the contractexamples/<id>/
Referenced by the handbook / ADRs as a teaching referenceexamples/<id>/

Default to plugins/. The walkthroughs under examples/ are a curated set; adding to that tree requires a positive teaching reason.

Mechanical differences: production specs live at spec/integration/plugins/<id>_plugin_spec.rb; walkthrough specs at spec/integration/examples/<id>_plugin_spec.rb. Both auto-include spec/integration/support/plugin_helpers.rb. RuboCop excludes plugins/**/* and examples/**/* but lints the specs.

Phase 0.5 — Where this plugin will live (per ADR-31)

Phase 0's table assumes you are a Rigor maintainer authoring directly inside the monorepo. The placement table above applies to monorepo-internal authoring only — typical paths: a new bundled plugin Rigor team adds to support a real framework, or a new examples/ walkthrough teaching an architectural surface.

If you are not a Rigor maintainer (i.e. you don't have commit rights to rigortype/rigor), or you are authoring a plugin in response to an external author's proposal, the plugin's home is outside this monorepo per ADR-31 (project-wide contribution policy). Note: a new bundled plugin is treated as a sweeping change under ADR-31 WD1 and follows the issue-first path; small bug fixes to existing bundled plugins are minor PRs and welcome directly per ADR-31 WD1's minor-PR path:

SituationPath
Authoring a plugin you'll consume yourselfThird-party rigor-<gem> gem in your own repo depending on gem "rigortype" (ADR-31 WD4). For FFI bindings, also see rigor-ffi-plugin-author which adds an upstream coverage-assessment phase to talk users out of plugin work when core suffices.
Want the plugin officially bundled with RigorFile an issue at the rigor repo with the ADR-31 WD2 fields: wrapped gem identity, evidence of community adoption (ADR-31 WD3 keeps the criterion deliberately vague), pointer to your working third-party plugin (as reference implementation), upstream-effort confirmation. The Rigor team re-implements from scratch; you are credited via Co-authored-by: on the implementation commit(s).
You ARE a Rigor maintainer and the plugin's authorship matches the bundled-plugins disciplineProceed with Phase 0's table above (monorepo placement).

Why there is no PR path for new bundled plugins. A new bundled plugin defines ecosystem identity (plugins/rigor-foo/ carries an implicit "this is the official rigor plugin for foo" signal), a project-governance concern beyond per-PR review. ADR-31 WD1 classifies new bundled plugins as sweeping changes that take the issue-first path; the Rigor team implements with Co-authored-by: attribution on the proposer. Bug fixes to existing bundled plugins are minor PRs and follow ADR-31 WD1's direct-PR path — they don't need this SKILL's full pipeline either, just clear-scope edits. This SKILL's procedural shape (Phases 1–10 below) supports both the monorepo path and the third-party-repo path identically — only the destination directory tree differs.

Reading order — modules and their outputs

Load each reference when you reach its phase. The phases assume prior context, so backwards skipping is fine but forward skipping leaves gaps.

ModuleReadCoversOutput of this module
1references/01-requirements-and-templates.mdPhases 1–2. Five-question scope check (trigger surface / look at / prove / diagnostic / config). Picks ADR-16 macro-substrate tier (A/B/C, declarative) or a node_rule template from six worked examples.Five Q&A answers + one template name from the table.
2references/02-scaffold-walker-demo.mdPhases 3–5. Directory tree, gemspec, plugin class skeleton, per-template node_rule patterns (engine owns the walk; node_file_context / NodeContext for two-pass / lexical context), calling the target library directly instead of reimplementing it (ADR-39: Plugin::Inflector, Base.suggest, the plugins_isolation: strategy), IoBoundary + cache producer rule (ADR-60 WD3 record-and-validate: read inside the block, declare watch: for directory globs; producer_value / producer_error for the lazy-load + error surface), demo project with tmp/-anchored cache + per-demo .gitignore.Working plugin directory + runnable demo/ whose rigor check diagnostic stream matches expectations.
3references/03-test-and-ship.mdPhases 6–10. RSpec integration helpers, README sections, changelog fragment, local gate and CI expectations, commit subject convention.Passing integration spec + README + changelog fragment + make verify-changed + green CI on the Draft PR + one commit.
4references/04-appendix.mdSide material. Common pitfalls (top 10), real-Rails alignment for rigor-rails-* plugins, post-ADR-9 services.fact_store cross-plugin pattern, reading list, closing checklist.Reference-only — no fixed output. Consult per the surface the plugin touches.

Worked examples to copy from

Map the Phase 1 answers to one of these:

text
ADR-16 substrate (declarative, no walker):
  Tier A  → plugins/rigor-sinatra/        (block-as-method)
  Tier B  → plugins/rigor-devise/         (trait registry)
  Tier C  → plugins/rigor-dry-struct/     (heredoc template)

Node-rule templates (engine owns the walk, ADR-37):
  Q1=A/B Q2=A Q3=A Q5=C        → examples/rigor-deprecations/  (~80 lines; config-driven)
  Q1=A   Q2=A Q3=E Q5=A/B      → examples/rigor-lisp-eval/     (literal AST recursion)
  Q1=D   Q2=B Q3=C Q5=A        → examples/rigor-units/         (local-variable flow)
  Q1=C/E Q2=C Q3=A Q5=A/B      → plugins/rigor-statesman/      (two-pass collect → validate)
  Q1=B   Q2=A/B Q3=B Q5=C      → examples/rigor-pattern/       (asks Scope#type_of)
  Q1=A/B/C Q2=E Q3=A/D Q5=C/D  → examples/rigor-routes/        (IoBoundary + cache)

If the requirement fits neither substrate nor template, stop and ask the user — the current plugin contract may not yet expose what they need. Check the per-library survey before inventing a workaround.

Show full SKILL.md (582 more words)Show less

What "done" looks like

The plugin is shippable when all of these hold:

  • bundle exec exe/rigor check against the plugin's demo/ prints the diagnostic stream documented in the plugin's README.md § "What the plugin recognises" — verbatim, no drift.
  • spec/integration/plugins/<id>_plugin_spec.rb (or examples/) covers every diagnostic shape the plugin emits, passing in CI.
  • make verify-changed passes locally and CI is green on the Draft PR: rspec 0 failures, rubocop 0 offenses on the spec file (the plugin source itself is excluded from rubocop), rigor check lib baseline unchanged.
  • git status is clean (tmp/-anchored cache + per-demo .gitignore keep build artefacts out of the index).
  • A changelog.d/added/<branch-slug>.md fragment carries one sentence naming the plugin; Rigor::VERSION is not bumped (the user drives release cuts per docs/agents/contribution-flow.md § "Release Cadence").
  • One commit, subject following docs/agents/contribution-flow.md style (Add rigor-<id> plugin (<facet>) or Add rigor-<id> walkthrough (<facet>)).

Publishing to RubyGems is out of scope for this skill. A bundled plugin ships inside the single rigortype gem (per ADR-31's single-bundled-gem distribution model — there are no per-plugin gemspecs and no git subtree split); it reaches users when a maintainer cuts the next rigortype release (.claude/skills/rigor-release-prep/SKILL.md). A third-party plugin (ADR-31 WD4) instead lives in the author's own repo with its own gemspec depending on gem "rigortype".

Example walkthrough

Concrete trace through a fictional request — "Create a Rigor plugin for the dotenv gem" — to anchor expectations:

  1. Phase 0 — dotenv is a real gem → plugins/rigor-dotenv/. (Not a fictional teaching domain.)
  2. Phase 1 (Module 1) — user answers narrow the surface: Q1=A (Dotenv.load(path) call), Q2=E (reads .env file), Q3=A (known finite set of variable names), Q4=B (error on missing var), Q5=D (external file path config).
  3. Phase 2 — answers match the rigor-routes template row (Q1=A/B/C, Q2=E, Q3=A/D, Q5=C/D). Copy the rigor-routes directory layout.
  4. Phases 3–5 (Module 2) — scaffold plugins/rigor-dotenv/{lib,demo}/, add the cache-producer + IoBoundary pattern verbatim from Module 2, demo with tmp/-anchored cache.
  5. Phases 6–10 (Module 3) — write spec/integration/plugins/dotenv_plugin_spec.rb, README, changelog fragment, run make verify-changed, single commit, Draft PR.

If the request shifts mid-flow (e.g. user later says "and also error when the value is empty"), restart from Phase 1 Q3 — the requirements gathering is the gate that prevents accidental scope creep.

Troubleshooting (most common at landing time)

  • CI fails on the new spec, though it passes alone — the spec doesn't Rigor::Plugin.unregister! in before + after. See references/04-appendix.md § Common pitfalls #2.
  • A newly-added file isn't picked up by a glob producer — the producer reads files in-block (captured by ADR-60 WD3 record-and-validate) but did not declare watch:, so a new file the prior run never read reads as fresh. Add watch: -> { [[@search_paths, "**/*.rb"]] }. See references/02-scaffold-walker-demo.md Phase 4.5.
  • Diagnostics don't appear in the demo output — source_family: was passed to the Diagnostic constructor. Don't — the runner overwrites it. See pitfall #7.
  • Prism::CallNode#name == "foo" always false — node.name returns a Symbol. Use == :foo. See pitfall #4.
  • Plugin's lib/ not on load path in tests — spec needs $LOAD_PATH.unshift(...) before require "rigor-<id>". See pitfall #10.
  • git status shows leaked .rigor/cache/ — demo .rigor.yml didn't set cache.path: tmp/.rigor/cache or missing per-demo /tmp/-only .gitignore. See pitfall #1.
  • Read the target library's source before modelling it. A plan written from the symptom gets the mechanism wrong (names built from a runtime table call for an open namespace, not name generation). Treat a "blocked on X" code comment as a hypothesis and probe it before sizing a slice.
  • Activating a previously-inert path surfaces a long tail of FP classes. Every latent FP downstream of it fires at once — adjudicate every new firing against a second corpus project before shipping.

© rigortype, MPL-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 4 other files (references) in .claude/skills/rigor-plugin-author of rigortype/rigor.

  • SKILL.md
  • references/01-requirements-and-templates.md
  • references/02-scaffold-walker-demo.md
  • references/03-test-and-ship.md
  • references/04-appendix.md

Open the folder on GitHubat commit c7b6b60

Compare with similar skills

Rigor Plugin Author next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Rigor Plugin Author compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Rigor Plugin Author this skillrigortype/rigor106—~3.3kAutomated safety check: NotesMPL-2.0
Finishing a Development Branchobra/superpowers296k5 repos~1.9kAutomated safety check: PassMIT
Typescript Advanced Typesrolling-scopes/rsschool-app10k24 repos~4.2kAutomated safety check: PassMPL-2.0
PR Babysitteropeninterpreter/openinterpreter69k3 repos~4.2kAutomated safety check: PassApache-2.0
Code Review ChecklistshareAI-lab/learn-claude-code78k5 repos~1.1kAutomated safety check: PassMIT
Greplooponyx-dot-app/onyx32k4 repos~3.3kAutomated safety check: PassMIT

Similar skills

  • Finishing a Development Branch

    obra/superpowers

    Walks the last step of a branch: confirm tests pass, detect the git environment, ask how to integrate, carry out your choice and clean up the worktree.

    296k GitHub starsUsed in 5 repos~1.9k tokens
    DevelopmentAuto-check passed

  • Typescript Advanced Types

    rolling-scopes/rsschool-app

    Master TypeScript's advanced type system including generics, conditional types, mapped types, template literals, and utility types for building type-safe applications.

    10k GitHub starsUsed in 24 repos~4.2k tokens
    DevelopmentAuto-check passed

  • PR Babysitter

    openinterpreter/openinterpreter

    Watches an open GitHub pull request until it merges, handling review comments, diagnosing CI failures and retrying flaky checks along the way.

    69k GitHub starsUsed in 3 repos~4.2k tokens
    DevelopmentAuto-check passed

  • Code Review Checklist

    shareAI-lab/learn-claude-code

    Reviews code against a five-part checklist covering security, correctness, performance, maintainability and testing, and reports findings in a fixed format.

    78k GitHub starsUsed in 5 repos~1.1k tokens
    DevelopmentAuto-check passed

  • Greploop

    onyx-dot-app/onyx

    Iteratively improves a PR (GitHub), MR (GitLab), or shelved changelist (Perforce) until Greptile gives it a 5/5 confidence score with zero unresolved comments.

    32k GitHub starsUsed in 4 repos~3.3k tokens
    DevelopmentAuto-check passed

  • Guidelines

    akash-network/node

    Behavioral guidelines to reduce common LLM coding mistakes. An agent skill from akash-network/node.

    1.1k GitHub starsUsed in 22 repos~577 tokens
    DevelopmentAuto-check passed

More from rigortype/rigor

All 36 skills in this repo

  • Rigor Regression Sweep

    rigortype/rigor

    Measure Rigor's baseline drift across the tagged history of a real OSS Ruby project.

    106 GitHub stars~2.9k tokensUpdated 5 days ago
    Auto-check passed

  • Rigor Unused Adjudicate

    rigortype/rigor

    Adjudicate a rigor unused report safely before proposing dead-code removal.

    106 GitHub stars~1.1k tokensUpdated 5 days ago
    Auto-check passed

  • Rigor Baseline Reduce

    rigortype/rigor

    Reduce an existing .rigor-baseline.yml rule by rule by triaging sites, fixing or intentionally suppressing them, and regenerating the baseline.

    106 GitHub stars~1.3k tokensUpdated 5 days ago
    Auto-check passed

  • Rigor Doctor

    rigortype/rigor

    Validate that a project's Rigor configuration, plugins, paths, and baseline are actually healthy.

    106 GitHub stars~767 tokensUpdated 5 days ago
    Auto-check passed

  • Rigor Plugin Author

    rigortype/rigor

    Author a Rigor plugin in an adopting project or standalone rigor- gem for a DSL, framework, or metaprogramming pattern.

    106 GitHub stars~1.9k tokensUpdated 5 days ago
    Auto-check passed

  • Rigor Plugin Review

    rigortype/rigor

    Audit an existing Rigor plugin against the current authoring contract and produce a prioritized upgrade path.

    106 GitHub stars~1.9k tokensUpdated 5 days ago
    Auto-check passed

Categories

Questions about Rigor Plugin Author

What does Rigor Plugin Author do?

Author a new Rigor plugin, choosing plugins/ for production support or examples/ for a contract walkthrough. Rigor Plugin Author is an agent skill from rigortype/rigor. Author a new Rigor plugin, choosing plugins/ for production support or examples/ for a contract walkthrough.

When should I use Rigor Plugin Author?

Rigor Plugin Author fits situations like: extending Rigor for a DSL; not for editing an existing plugin; the analyzer engine.

How do I install Rigor Plugin Author in Claude Code?

Run `npx skills add rigortype/rigor --skill rigor-plugin-author -a claude-code`. Or copy the skill folder (.claude/skills/rigor-plugin-author in rigortype/rigor) into .claude/skills/rigor-plugin-author in your project. Claude Code loads it when a task matches its description.

How do I install Rigor Plugin Author in Codex?

Run `npx skills add rigortype/rigor --skill rigor-plugin-author -a codex`. Or copy the skill folder (.claude/skills/rigor-plugin-author in rigortype/rigor) into .agents/skills/rigor-plugin-author in your project. Codex loads it when a task matches its description.

Can I use Rigor Plugin Author in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add rigortype/rigor --skill rigor-plugin-author -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/rigor-plugin-author, .gemini/skills/rigor-plugin-author, .github/skills/rigor-plugin-author and .opencode/skills/rigor-plugin-author in your project.

What does Rigor Plugin Author need to run?

Going by SKILL.md and its folder, Rigor Plugin Author needs the command-line tools its instructions call (make, git, gem, nix and bundle).

Does Rigor Plugin Author access the network?

SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Rigor Plugin Author safe to install?

Our automated static check of SKILL.md found notes only (mentions a .env file), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Rigor Plugin Author use?

Rigor Plugin Author is published under the MPL-2.0 licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Rigor Plugin Author use?

About 3.3k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 8.8k tokens, read only when the agent opens those files.

What are the alternatives to Rigor Plugin Author?

Skills that share tags, products or a category with Rigor Plugin Author: Finishing a Development Branch (obra/superpowers, 296k stars), Typescript Advanced Types (rolling-scopes/rsschool-app, 10k stars), PR Babysitter (openinterpreter/openinterpreter, 69k stars) and Code Review Checklist (shareAI-lab/learn-claude-code, 78k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Rigor Plugin Author?

rigortype (a GitHub organization) maintains it in rigortype/rigor, which has 106 GitHub stars. The repository holds 36 skills in this directory. The repository was last updated on October 2, 2026.

Source: rigortype/rigor on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.