Skill Refiner, the eval-guided improvement loop for SKILL.md files.

Apache-2.0Auto-check passedAgent Workflows

Install J Rig

skills CLI
$ npx skills add jeremylongshore/tons-of-skills-marketplace --skill j-rig -a claude-code

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

GitHub CLI
$ gh skill install jeremylongshore/tons-of-skills-marketplace j-rig --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/jeremylongshore/tons-of-skills-marketplace.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/.curated/j-rig .claude/skills/j-rig && 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
j-rig
GitHub stars
2.8k
Token cost
~2.7k tokens
SKILL.md length
1,139 words
Files
1
Skills in repo
3,342
Repo updated
First seen
Licence
Apache-2.0

At a glance

Skill Refiner, the eval-guided improvement loop for SKILL.md files.

  • Improving an existing skill
  • SKILL.md covers Overview, Prerequisites, Instructions and Output, plus 3 more sections
  • Calls git, npm and pnpm; needs ANTHROPIC_API_KEY
  • Refining a SKILL.md against measured behavior

What it does

J Rig is an agent skill from jeremylongshore/tons-of-skills-marketplace. Skill Refiner, the eval-guided improvement loop for SKILL.md files. Runs the bootstrap, score, propose, apply, and status cycle as a thin wrapper over the published @intentsolutions/refiner CLI, proposing safe, minimal, bounded SKILL.md edits and accepting an edit only when a held-out eval score strictly improves with no regression on any other case. Ships a 3-layer cost-tiered hook architecture (sinker, line, hook) that gates skill quality at edit time, end of turn, and commit time. Use when improving an…

Its SKILL.md is about 2.7k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts. Compatibility notes: Designed for Claude Code; the refine subcommands wrap the published @intentsolutions/jrig-cli binary and run anywhere that CLI installs

It sits in Agent Workflows, covering Skill authoring. The repository describes itself as: Model-agnostic agent-skills platform with a harness-free canonical layer, verified adapters, and the ccpi package manager. Explore at tonsofskills.com. The licence is Apache-2.0.

When your agent uses it

  • Improving an existing skill
  • Refining a SKILL.md against measured behavior
  • Bootstrapping an eval set for a skill
  • Gating skill edits before they ship

Example prompts

  • “/j-rig”
  • “refine this skill”
  • “bootstrap an eval set”
  • “/j-rig”

Requirements

  • Node.js
  • A credential in ANTHROPIC_API_KEY
  • Compatibility (from SKILL.md): Designed for Claude Code; the refine subcommands wrap the published @intentsolutions/jrig-cli binary and run anywhere that CLI installs
  • Pre-approved tools (allowed-tools): Read, Write, Edit, Glob, Bash(j-rig:*), Bash(git:*), Bash(python:*)

What it can do on your machine

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

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Write
    • Edit
    • Glob
    • Bash(j-rig:*)
    • Bash(git:*)
    • Bash(python:*)

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git
    • npm
    • pnpm

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

  • Network

    Links to these hosts (documentation or services it may open):

    • npmjs.com

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

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • ANTHROPIC_API_KEY

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

  • Compatibility

    Designed for Claude Code; the refine subcommands wrap the published @intentsolutions/jrig-cli binary and run anywhere that CLI installs

    From compatibility in the SKILL.md frontmatter.

Context cost

J Rig loads about 2.7k tokens when it runs. Until then it costs about 201 tokens; SKILL.md has 1,139 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~201
When it runs · the whole SKILL.md, loaded when a task matches
~2.7k

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 passed

The automated check found no risky patterns in SKILL.md.

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 jeremylongshore/tons-of-skills-marketplace at commit cfae287, republished under its Apache-2.0 licence (© jeremylongshore). 1,139 words, ~2,712 tokens.

Download SKILL.mdSave it as .claude/skills/j-rig/SKILL.md (or your agent's skills folder).
name
j-rig
description
Skill Refiner, the eval-guided improvement loop for SKILL.md files. Runs the bootstrap, score, propose, apply, and status cycle as a thin wrapper over the published @intentsolutions/refiner CLI, proposing safe, minimal, bounded SKILL.md edits and accepting an edit only when a held-out eval score strictly improves with no regression on any other case. Ships a 3-layer cost-tiered hook architecture (sinker, line, hook) that gates skill quality at edit time, end of turn, and commit time. Use when improving an existing skill, refining a SKILL.md against measured behavior, bootstrapping an eval set for a skill, or gating skill edits before they ship. Trigger with "/j-rig", "refine this skill", "bootstrap an eval set", "propose a skill edit", "promote the candidate", or "skill refiner status".
allowed-tools
Read, Write, Edit, Glob, Bash(j-rig:*), Bash(git:*), Bash(python:*)
compatibility
Designed for Claude Code; the refine subcommands wrap the published @intentsolutions/jrig-cli binary and run anywhere that CLI installs
version
0.1.0
author
Jeremy Longshore <jeremy@intentsolutions.io>
license
Apache-2.0
argument-hint
[refine bootstrap|score|propose|promote|status] <skill-dir>
tags
skill-refiner, eval-guided, skill-md, meta-tooling, hooks

j-rig — Skill Refiner

Overview

The Skill Refiner is the eval-guided improvement loop for SKILL.md files. It analyzes an existing skill against measured behavior, proposes safe, minimal, bounded edits, and accepts an edit only when it strictly improves. It is the second product in the Intent Solutions agent-rig stack:

J-Rig Skill Binary Eval   ->   Skill Refiner   ->   Rollout Gate
      (test)                     (improve)             (ship)

The refiner proposes bounded edits (add, delete, or replace operations on the SKILL.md text) and accepts an edit only if a held-out eval score strictly improves with no regression on any other case. It never rewrites a skill wholesale, and it never lets a skill judge itself; scoring is delegated to the separate j-rig eval harness.

This plugin is a thin wrapper. The refiner logic lives in the published @intentsolutions/refiner package and is exposed through the j-rig refine command group in the @intentsolutions/jrig-cli binary. This skill invokes that CLI; it does not reimplement any refiner logic.

Use this skill when:

  • Improving an existing skill whose behavior you can measure.
  • Bootstrapping a held-out eval set for a skill so you have something to score against.
  • Proposing a bounded SKILL.md edit and checking whether it strictly improves.
  • Gating skill edits before they ship (the 3-layer hooks do this automatically).

Do NOT use it to hand-author a brand-new skill from scratch; use /skill-creator for that. The refiner improves skills that already exist and already have measurable behavior.

Prerequisites

The subcommands wrap the published j-rig binary. Install it once:

bash
# Global — gives you the `j-rig` command everywhere
npm install -g @intentsolutions/jrig-cli

# Or per-repo (recommended for CI version-pinning)
pnpm add -D @intentsolutions/jrig-cli   # then: pnpm exec j-rig --help

The refine command group is contributed by @intentsolutions/refiner, which ships as a dependency of the CLI. Model-backed steps (score, propose) require the ANTHROPIC_API_KEY environment variable; the deterministic steps (bootstrap, apply, status) run fully offline.

Instructions

Each /j-rig subcommand maps one-to-one onto a j-rig refine verb. Run them against a skill directory (the folder containing the SKILL.md).

/j-rig subcommandUnderlying CLIWhat it doesCost
refine bootstrap <skill-dir>j-rig refine bootstrapSynthesize a held-out eval set from the SKILL.md and store it (content-addressed).$0 (deterministic)
refine score <skill-dir>j-rig refine scoreDelegate scoring to j-rig eval (Haiku or Sonnet tier; never Opus, which is validation-only).$
refine propose <skill-dir>j-rig refine proposePropose one bounded add/delete/replace edit via the tiered refiner model and store the proposal. Shadow-validation happens here: the candidate is scored against the held-out set before it is ever applied.$$
refine promote <skill-dir>j-rig refine applyApply a stored, accepted proposal to the SKILL.md, producing a new immutable candidate version, then move the best pointer. Human-gated: you decide to promote.$0 (deterministic)
refine status <skill-id>j-rig refine statusShow the refiner store state plus the append-only event log for a skill.$0 (deterministic)

Naming note: this skill's user-facing verbs follow the ratified plan (bootstrap, propose, shadow, promote, status). On the published CLI, shadow-validation is the acceptance gate inside propose, and promote is j-rig refine apply plus the human-gated best-pointer move. The wrappers call the real CLI verbs (bootstrap, score, propose, apply, status).

The 3-layer hook architecture (sinker, line, hook)

The plugin ships three hooks that automatically gate skill quality at three points in the Claude Code lifecycle. They are cost-tiered: the cheapest layer fires most often, the most expensive layer fires least and is rate-limited. This mirrors Anthropic's security-guidance hook pattern.

LayerHook eventFires whenMechanismCost / model
Sinker (L1)PostToolUse matcher Edit|Writeany SKILL.md is editedDeterministic validate-skillmd Tier-2 frontmatter check (agentskills.io plus Claude Code extension-layer compliance). Advisory: surfaces warnings, never blocks.$0 (no model call)
Line (L2)Stopend of turn, if a skill was invoked and its rollouts are scoredAppend the rollout to .j-rig/refiner/log.jsonl; once N rollouts accumulate on one skill, fire the refiner in the background and surface the candidate next turn.$ (Haiku scores, Sonnet refines, paid off-turn)
Hook (L3)PreToolUse matcher Bashbefore a git commit / git push whose staged diff touches a SKILL.mdAgentic gate: read the surrounding skills directory, check the edit against the rejected-edit buffer, optionally shadow-validate against the held-out set. Can block the commit via exit code 2.$$ (Opus agentic gate, rate-limited)

Why L3 is PreToolUse:Bash, not PostToolUse:Bash (the plan's v4.1 mechanism fix): PreToolUse is in the Anthropic hooks "Can block" allowlist, so exiting with code 2 (or emitting permissionDecision: deny) blocks the bash call before it runs. PostToolUse fires after the bash has already executed, so it cannot prevent the commit or push that triggered it. Only PreToolUse can actually gate the commit.

L3 rate limit: the Opus agentic gate is the most expensive layer, so it is rate-limited to at most once per JRIG_HOOK_RATELIMIT_SECONDS (default 300s / 5 min) via a stamp file at .j-rig/refiner/.hook-last-run. Inside the window the gate is skipped with an advisory note; it only ever blocks on a real regression finding, never on a cost-control skip.

Show full SKILL.md (364 more words)Show less
Design principles inherited from j-rig
  • Criteria are binary: an edit strictly improves the held-out score or it is rejected. No fuzzy gradients.
  • The evaluator is always separate: the skill under test never scores itself.
  • Observed behavior outranks claimed behavior: grade what the skill does, not what its description says.
  • One change at a time: each proposal is exactly one atomic edit.
  • Promotion is human-gated: the refiner proposes and validates; a human moves the best pointer.

Output

Every refiner pass writes to two places under the working directory:

  • The append-only event log at .j-rig/refiner/log.jsonl (one value-record per line: rollout captures, stored versions, best-pointer moves).
  • The content-addressed store under .j-rig/refiner/store/ (immutable eval sets, score records, edit proposals, and skill versions keyed by SHA-256).

Read the trajectory any time with j-rig refine status <skill-id>. The refiner also renders a signed Evidence Report (markdown plus self-contained HTML) via j-rig refine render-report <report-md-path>.

Error Handling

  • propose / score fail without a key: both require ANTHROPIC_API_KEY. They fail loudly with guidance rather than fabricating a result. Set the key, or run the deterministic verbs (bootstrap, apply, status) offline.
  • apply rejects a proposal: apply throws on a parent-hash mismatch or a bad anchor. This is the immutability guard, not a bug. Re-run propose against the current version.
  • Non-strict edit rejected: if a proposed edit does not strictly improve the held-out score, the acceptance gate rejects it and logs it to the rejected buffer. That is the intended behavior; refine again with a different strategy.
  • L3 hook blocks a commit: the commit-time agentic gate exits 2 when a staged SKILL.md regresses the held-out set. Fix the regression, or run /j-rig refine status <skill-id> to inspect what tripped it.
  • CLI not installed: the hooks degrade to advisory notes when the j-rig binary is absent. Install @intentsolutions/jrig-cli to enable the model-backed layers.

Examples

A full refine loop against a skill directory:

bash
# 1. Create a held-out eval set for the skill (deterministic, offline).
j-rig refine bootstrap skills/my-skill

# 2. Establish the baseline score (Sonnet tier).
j-rig refine score skills/my-skill --model sonnet

# 3. Propose one bounded edit; the acceptance gate shadow-validates it.
ANTHROPIC_API_KEY=... j-rig refine propose skills/my-skill --strategy skill-opt-style

# 4. If accepted, apply it, producing a new candidate version (human-gated promote).
j-rig refine apply skills/my-skill --proposal "<hash>"

# 5. Inspect the trajectory, best pointer, and event log any time.
j-rig refine status my-skill

Render the Evidence Report for a completed pass:

bash
j-rig refine render-report .j-rig/refiner/report.md --output report.html

Resources

© jeremylongshore, Apache-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

Just SKILL.md in skills/.curated/j-rig of jeremylongshore/tons-of-skills-marketplace.

Open the folder on GitHubat commit cfae287

Compare with similar skills

J Rig 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.

J Rig compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
J Rig this skilljeremylongshore/tons-of-skills-marketplace2.8k—~2.7kAutomated safety check: PassApache-2.0
Skill CreatorAzure/azqr79689 repos~8.2kAutomated safety check: PassApache-2.0
Claude Code Skill Developer Guidediet103/claude-code-infrastructure-showcase10k11 repos~3.5kAutomated safety check: PassMIT
Darwin Skill Optimizeralchaincyf/darwin-skill6.2k1 repos~4.7kAutomated safety check: PassMIT
Claude Code Command Developmentanthropics/claude-plugins-official38k10 repos~4.8kAutomated safety check: PassApache-2.0
Claude Code Plugin Structureanthropics/claude-plugins-official38k10 repos~3.4kAutomated safety check: PassApache-2.0

Similar skills

  • Skill Creator

    Azure/azqr

    Official

    Create new skills, modify and improve existing skills, and measure skill performance.

    796 GitHub starsUsed in 89 repos~8.2k tokens
    Agent WorkflowsAuto-check passed
  • Claude Code Skill Developer Guide

    diet103/claude-code-infrastructure-showcase

    A guide to creating and managing Claude Code skills with auto-activation: skill-rules.json triggers, hooks, enforcement levels, YAML frontmatter and progressive disclosure.

    10k GitHub starsUsed in 11 repos~3.5k tokens
    Agent WorkflowsAuto-check passed
  • Darwin Skill Optimizer

    alchaincyf/darwin-skill

    Scores SKILL.md files on a nine-dimension rubric, then improves them in a keep-or-revert loop with independent judge agents, test prompts, git history and human checkpoints.

    6.2k GitHub starsUsed in 1 repo~4.7k tokens
    Agent WorkflowsAuto-check passed
  • Claude Code Command Development

    anthropics/claude-plugins-official

    Official

    Explains how to write Claude Code slash commands: Markdown files with YAML frontmatter, arguments, file references, bash context and interactive prompts.

    38k GitHub starsUsed in 10 repos~4.8k tokens
    Agent WorkflowsAuto-check passed
  • Claude Code Plugin Structure

    anthropics/claude-plugins-official

    Official

    Explains the directory layout, plugin.json manifest and component organization of a Claude Code plugin, including auto-discovery and portable paths.

    38k GitHub starsUsed in 10 repos~3.4k tokens
    Agent WorkflowsAuto-check passed
  • Skill Release Gate

    rohitg00/ai-engineering-from-scratch

    Evaluates an Agent Skill bundle before release for structure, trigger quality, artifact improvement, script correctness, safety, installed-tree integrity and host portability.

    67k GitHub stars~1k tokensUpdated today
    Agent WorkflowsAuto-check passed

More from jeremylongshore/tons-of-skills-marketplace

All 3,342 skills in this repo
  • Performing Security Code Review

    jeremylongshore/tons-of-skills-marketplace

    Execute this skill enables AI assistant to conduct a security-focused code review using the security-agent plugin.

    2.8k GitHub starsUsed in 2 repos~1.3k tokens
    Auto-check: notes
  • Adapting Transfer Learning Models

    jeremylongshore/tons-of-skills-marketplace

    Build this skill automates the adaptation of pre-trained machine learning models using transfer learning techniques.

    2.8k GitHub stars~1.1k tokensUpdated today
    Auto-check passed
  • Agent Context Loader

    jeremylongshore/tons-of-skills-marketplace

    Execute proactive auto-loading: automatically detects and loads agents.md files.

    2.8k GitHub stars~1.1k tokensUpdated today
    Auto-check passed
  • Aggregating Performance Metrics

    jeremylongshore/tons-of-skills-marketplace

    Aggregate and centralize performance metrics from applications, systems, databases, caches, and services.

    2.8k GitHub stars~1.2k tokensUpdated today
    Auto-check passed
  • Analyzing Capacity Planning

    jeremylongshore/tons-of-skills-marketplace

    Execute this skill enables AI assistant to analyze capacity requirements and plan for future growth.

    2.8k GitHub stars~947 tokensUpdated today
    Auto-check passed
  • Analyzing Database Indexes

    jeremylongshore/tons-of-skills-marketplace

    Process use when you need to work with database indexing. An agent skill from jeremylongshore/tons-of-skills-marketplace.

    2.8k GitHub stars~2k tokensUpdated today
    Auto-check passed

Categories

Questions about J Rig

What does J Rig do?

Skill Refiner, the eval-guided improvement loop for SKILL.md files. J Rig is an agent skill from jeremylongshore/tons-of-skills-marketplace.md files.

When should I use J Rig?

J Rig fits situations like: improving an existing skill; refining a SKILL.md against measured behavior; bootstrapping an eval set for a skill; gating skill edits before they ship.

How do I install J Rig in Claude Code?

Run `npx skills add jeremylongshore/tons-of-skills-marketplace --skill j-rig -a claude-code`. Or copy the skill folder (skills/.curated/j-rig in jeremylongshore/tons-of-skills-marketplace) into .claude/skills/j-rig in your project. Claude Code loads it when a task matches its description.

How do I install J Rig in Codex?

Run `npx skills add jeremylongshore/tons-of-skills-marketplace --skill j-rig -a codex`. Or copy the skill folder (skills/.curated/j-rig in jeremylongshore/tons-of-skills-marketplace) into .agents/skills/j-rig in your project. Codex loads it when a task matches its description.

Can I use J Rig 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 jeremylongshore/tons-of-skills-marketplace --skill j-rig -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/j-rig, .gemini/skills/j-rig, .github/skills/j-rig and .opencode/skills/j-rig in your project.

What does J Rig need to run?

Going by SKILL.md and its folder, J Rig needs the command-line tools its instructions call (git, npm and pnpm) and credentials named ANTHROPIC_API_KEY. Our summary lists: Node.js; A credential in ANTHROPIC_API_KEY. Its frontmatter pre-approves these tools: Read, Write, Edit, Glob, Bash(j-rig:*), Bash(git:*), Bash(python:*). Compatibility (from SKILL.md): Designed for Claude Code; the refine subcommands wrap the published @intentsolutions/jrig-cli binary and run anywhere that CLI installs.

Does J Rig access the network?

SKILL.md names 1 domain. As links in the text: npmjs.com. This is read from the text; nothing was executed.

Is J Rig safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does J Rig use?

J Rig is published under the Apache-2.0 licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does J Rig use?

About 2.7k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to J Rig?

Skills that share tags, products or a category with J Rig: Skill Creator (Azure/azqr, 796 stars), Claude Code Skill Developer Guide (diet103/claude-code-infrastructure-showcase, 10k stars), Darwin Skill Optimizer (alchaincyf/darwin-skill, 6.2k stars) and Claude Code Command Development (anthropics/claude-plugins-official, 38k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains J Rig?

jeremylongshore (a GitHub user) maintains it in jeremylongshore/tons-of-skills-marketplace, which has 2,827 GitHub stars. The repository holds 3,342 skills in this directory. The repository was last updated on October 10, 2026.

Source: jeremylongshore/tons-of-skills-marketplace on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.