Skip to main content
skill Claude Code CX Codex Cursor GitHub Copilot

explore-run — Claude Code skill: what it does, how to install

Plans bounded exploratory machine learning runs with comparability caveats and saves summaries to explore_outputs.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add lllllllama/RigorPilot-Skills --skill explore-run -a claude-code
Open on GitHub

What explore-run does

This skill guides exploratory execution planning in deep learning repositories. It handles small-subset validations, short-cycle training probes, batch sweeps, and quick transfer-learning trials. Experiments stay isolated from the trusted baseline to prevent accidental pollution of main research results.

Planning relies on helper scripts scripts/plan_variants.py and scripts/write_outputs.py. The selection phase scores candidates using cost and expected gain while enforcing variant limits. When execution begins, the skill delegates commands to tools such as minimal-run-and-audit or run-train.

Summaries are saved directly into explore_outputs/. Running exploratory probes without explicit researcher permission breaks protocol, so this skill stays dormant until authorized.

What it helps with

  • plan candidate parameter grids for quick exploratory training
  • run validation checks on small dataset subsets
  • generate comparability reports in explore_outputs
  • rank experiment candidates using cost and expected gain

Example prompts for the agent

  • Plan a quick transfer learning probe on a small subset using explore-run
  • Run a short-cycle batch sweep and rank candidate variants
  • Prepare exploratory run configs and save summaries into explore_outputs

How to install explore-run

1Skills CLI (Vercel)

npx skills add lllllllama/RigorPilot-Skills --skill explore-run -a claude-code

2Manually: put the files in place

~/.claude/skills/explore-run/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/explore-run/

From the same set9

The whole set →
repo-intake-and-plan lllllllama Scans a repository through its README and project files, then builds a small reproduction plan. Use it before running experiments. Claude Code CX Codex Cursor +1 474,500installs minimal-run-and-audit lllllllama Captures and normalizes execution evidence from deep learning smoke tests and inference commands into standardized repro_outputs/ files. Claude Code CX Codex Cursor +1 474,400installs env-and-assets-bootstrap lllllllama Prepares environment and checkpoint/dataset paths before the first run of a README-documented repo. Claude Code CX Codex Cursor +1 474,300installs ai-research-explore lllllllama Governs deep learning research exploration on top of an existing baseline. It isolates candidate experiments and generates structured comparison reports. Claude Code CX Codex Cursor +1 335,600installs analyze-project lllllllama Reads a deep learning repository and maps its structure, entrypoints and suspicious spots. Changes nothing, runs no heavy jobs. Claude Code CX Codex Cursor +1 335,500installs ai-research-reproduction lllllllama This skill guides a repository-grounded reproduction run from its README to an evidence bundle. Use it to test a documented model run without quietly changing the experiment. Claude Code CX Codex Cursor +1 335,300installs explore-code lllllllama A skill for cautious code experiments in deep learning repositories: it transplants modules and adapts architectures on an isolated branch, with rollback-aware records. Claude Code CX Codex Cursor +1 335,000installs run-train lllllllama Runs a selected training command and organizes the resulting evidence. Use it for startup checks, short-run verification, full training kickoff, or resume handling. Claude Code CX Codex Cursor +1 334,700installs

Similar

eval-harness affaan-m A skill for eval-driven development: it sets pass/fail criteria before you write code and tracks agent reliability with pass@k and pass^k. Claude Code CX Codex Cursor +1 4,700installs agent-architecture-audit affaan-m This skill checks agent and LLM applications across 12 layers. Use it when an agent degrades and the failing layer is hard to locate. Claude Code CX Codex Cursor +1 4,700installs pytorch-patterns affaan-m This skill guides PyTorch model, training-loop, and data-loading work with practical patterns. Use it when reviewing code or tracking down runs that fail to reproduce. Claude Code CX Codex Cursor +1 4,700installs skill-creator official anthropics Creates and refines skills, then tests them with prompts, evaluations, and performance checks. Claude Code Claude.ai 414,180installs writing-for-agents Matt Pocock Guidance for writing skills and agent-facing documents. Use it when editing AGENTS.md, CLAUDE.md, or reference files reached from them. Claude Code 466,719installs media-use heygen-com Finds or generates media for HyperFrames videos, including voiceovers, music, cutouts, and color grades. Stores files locally in assets. Claude Code CX Codex Cursor +1 1,100,000installs mcp-builder official anthropics This skill walks through building an MCP server in TypeScript or Python, from reading the protocol spec to writing tests and evaluation questions. Claude Code Claude.ai 130,949installs subagent-driven-development Jesse Vincent This skill runs an implementation plan through fresh subagents for independent tasks and reviews each result. Use it for multi-step work in one session. Claude Code CX Codex 237,746installs

Questions about explore-run

How to install explore-run in Claude Code?

Run npx skills add lllllllama/RigorPilot-Skills --skill explore-run -a claude-code in your terminal.

What does explore-run do?

It plans exploratory runs for deep learning repositories, scores candidate variants, and documents bounded evidence without overclaiming.

Where does explore-run store its artifacts?

Generated files such as comparability reports and changelogs are written to explore_outputs/.

Source text

SKILL.md · MIT
---
name: explore-run
description: Rigor Improve / Rigor Explore run leaf skill for bounded exploratory evidence in deep learning research repositories. Use when the researcher explicitly authorizes exploratory runs such as small-subset validation, short-cycle guess-and-check, batch sweeps, idle-GPU search, or quick transfer-learning trials, with fair-comparison caveats and no-overclaim summaries in `explore_outputs/`. Do not use for end-to-end exploration orchestration on top of `current_research`, trusted baseline execution, conservative training verification, default routing, verified SOTA claims, or implicit experimentation.
---

# explore-run

Use this as the Rigor Improve / Rigor Explore run leaf skill. The installed slug
remains `explore-run` for compatibility.

Use the shared operating principles in
`../ai-research-reproduction/references/agent-operating-principles.md`; this skill should guide
candidate run planning while preserving model judgment about the active repo.

## When to apply

- When the researcher explicitly authorizes exploratory runs.
- When the task is a small-subset validation, short-cycle training probe, batch sweep, idle-GPU search, or quick transfer-learning trial.
- When the output should rank candidate runs rather than certify trusted success.

## When not to apply

- When the user wants trusted training execution or conservative verification.
- When there is no explicit exploratory authorization.
- When the task is repository setup, intake, or debugging.

## Clear boundaries

- This skill owns exploratory execution planning and summary only.
- Use `ai-research-explore` instead when the task spans both current_research coordination and exploratory code changes.
- It may hand off actual command execution to `minimal-run-and-audit` or `run-train`.
- It should keep experiment state isolated from the trusted baseline.
- It should prefer small-subset and short-cycle checks before heavier exploratory runs.
- It should label run results as bounded evidence and explain when a comparison
  is not directly fair.

## Ranking Semantics

- Pre-execution candidate selection uses three factors: `cost`, `success_rate`, and `expected_gain`.
- Default weights should stay conservative unless the researcher explicitly provides `selection_weights`.
- Budget pruning still applies after scoring through `max_variants` and `max_short_cycle_runs`.
- If runs are executed later, downstream ranking should switch to real execution evidence, not stay purely heuristic.

## Variant Spec Hints

- Use `variant_axes` to define the candidate dimension grid.
- Use `subset_sizes` and `short_run_steps` to express exploratory run scale.
- Use `selection_weights` to rebalance `cost`, `success_rate`, and `expected_gain`.
- Use `primary_metric` and `metric_goal` so downstream ranking can order executed candidates consistently.

## Output expectations

- `explore_outputs/CHANGESET.md`
- `explore_outputs/SCIENTIFIC_CHANGELOG.md`
- `explore_outputs/COMPARABILITY_REPORT.md`
- `explore_outputs/TOP_RUNS.md`
- `explore_outputs/status.json`

## Notes

Use `references/execution-policy.md`, `../ai-research-reproduction/references/explore-variant-spec.md`, `../ai-research-reproduction/references/deep-learning-experiment-principles.md`, `scripts/plan_variants.py`, and `scripts/write_outputs.py`.

© lllllllama · MIT · lllllllama/RigorPilot-Skills

See also

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor