PluginBench
Skill
Review
Audit score 70

explore-code

lllllllama/rigorpilot-skills

Auditable exploratory code modifications for deep learning research on isolated branches with rollback tracking.

SourceView on skills.sh

What is explore-code?

A leaf skill for bounded, source-anchored code changes in deep learning repositories when explicitly authorized by the researcher. Use it to transplant modules, adapt backbones, add LoRA/adapter layers, or stitch low-risk migrations with full rollback records—never for baseline reproduction, debugging, or end-to-end orchestration.

  • Isolate exploratory code work on separate branches or worktrees away from trusted baselines
  • Transplant modules, adapt backbones, and insert LoRA or adapter layers with minimal rewrites
  • Record candidate changes with rollback instructions and scientific justification in explore_outputs/
  • Generate CHANGESET.md, SCIENTIFIC_CHANGELOG.md, COMPARABILITY_REPORT.md, TOP_RUNS.md, and status.json
  • Hand off execution to minimal-run-and-audit or run-train when ready for validation

How to install explore-code

npx skills add https://github.com/lllllllama/rigorpilot-skills --skill explore-code
Prerequisites
  • Explicit researcher authorization for exploratory modifications
  • Isolated branch or worktree separate from current_research baseline
  • Access to explore_outputs/ directory for recording changes and results
Claude Code
Cursor
Windsurf
Cline

How to use explore-code

  1. 1.Confirm the researcher has explicitly authorized exploratory work on an isolated branch
  2. 2.Identify the source-anchored code to transplant, adapt, or combine (e.g., module, backbone, head)
  3. 3.Use scripts/plan_code_changes.py to outline the modification strategy
  4. 4.Apply minimal, focused changes—favor copying and adaptation over freeform rewrites
  5. 5.Document the change in explore_outputs/CHANGESET.md with rollback instructions and scientific rationale
  6. 6.Generate explore_outputs/SCIENTIFIC_CHANGELOG.md, COMPARABILITY_REPORT.md, and TOP_RUNS.md
  7. 7.Record status in explore_outputs/status.json and hand off to minimal-run-and-audit or run-train if execution is needed

Use cases

Good for
  • Adapt a pre-trained backbone for a new task while keeping the original research intact
  • Insert LoRA adapter layers into a frozen model to test parameter-efficient fine-tuning
  • Transplant a successful module from one codebase to another with documented migration steps
  • Combine multiple low-risk architectural changes and record which combinations are candidates vs. verified
  • Test a hypothesis-driven code change on an isolated branch before deciding to merge
Who it's for
  • Deep learning researchers conducting exploratory experiments on authorized branches
  • ML engineers adapting existing models with controlled, auditable modifications
  • Research teams needing rollback-aware candidate implementations with scientific justification

explore-code FAQ

When should I use explore-code vs. ai-research-explore?

Use explore-code for isolated code modifications only. Use ai-research-explore when the task spans both current_research coordination and exploratory runs across multiple components.

Can I use this skill for trusted baseline reproduction or conservative debugging?

No. This skill is only for explicitly authorized exploratory modifications. Use it for candidate implementations, not for reproducing baselines or debugging existing code.

What if the researcher hasn't explicitly authorized exploratory work?

Do not apply this skill. Wait for explicit authorization before making exploratory code changes on isolated branches.

How do I ensure rollback capability?

Document the original code location, the exact changes made, and step-by-step rollback instructions in explore_outputs/CHANGESET.md. Keep the isolated branch separate from the trusted baseline.

Should I use this for broad refactors or from-scratch implementations?

No. This skill is for source-anchored, minimal adaptations (module transplants, backbone tweaks, adapter insertion). For larger refactors, coordinate with the researcher on scope and approach first.

Full instructions (SKILL.md)

Source of truth, from lllllllama/rigorpilot-skills.

name: explore-code description: Rigor Improve implementation leaf skill for auditable candidate implementation in deep learning research repositories. Use when the researcher explicitly authorizes exploratory work on an isolated branch or worktree to transplant modules, adapt a backbone, add LoRA or adapter layers, replace a head, or stitch together meaningful low-risk migration ideas with rollback-aware records in explore_outputs/. Do not use for end-to-end exploration orchestration on top of current_research, trusted baseline reproduction, conservative debugging, environment setup, verified contribution claims, or default repository analysis.

explore-code

Use this as the Rigor Improve implementation leaf skill. The installed slug remains explore-code for compatibility.

Use the shared operating principles in ../../references/agent-operating-principles.md; this skill should guide bounded candidate code work without over-prescribing implementation details.

When to apply

  • When the researcher explicitly authorizes exploratory code changes on an isolated branch or worktree.
  • When the task is source-anchored module transplant, backbone adaptation, LoRA or adapter insertion, or low-risk module combination.
  • When summary-level recording is sufficient and the result is a candidate, not a trusted conclusion.

When not to apply

  • When the request is for trusted baseline work, conservative debugging, or normal training execution.
  • When the user did not explicitly authorize exploratory modifications.
  • When the task is a broad refactor or a from-scratch idea implementation.

Clear boundaries

  • This skill owns exploratory code modifications only.
  • It must keep work isolated from the trusted baseline.
  • Use ai-research-explore instead when the task spans both current_research coordination and exploratory runs.
  • It may hand off execution to minimal-run-and-audit or run-train.
  • It should favor source-anchored copying and minimal adaptation over freeform rewrites.
  • It should record why a candidate change is meaningful, how to roll it back, and why it remains a candidate rather than a verified contribution.

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/explore-policy.md, ../../references/research-rigor-principles.md, scripts/plan_code_changes.py, and scripts/write_outputs.py.

Related skills

More from lllllllama/rigorpilot-skills and the wider catalog.

AN

analyze-project

lllllllama/rigorpilot-skills

Read-only analysis of deep learning repositories to understand structure, configs, and suspicious patterns.

84k installsAudited
AI

ai-research-explore

lllllllama/rigorpilot-skills

Auditable deep learning research exploration with idea gating, fair comparison, and governed experiments.

84k installs
AI

ai-research-reproduction

lllllllama/rigorpilot-skills

README-first deep learning repository reproduction with auditable evidence and standardized outputs.

84k installsAudited
PA

paper-context-resolver

lllllllama/rigorpilot-skills

Resolve reproduction-critical paper details when README and repo files leave gaps.

84k installs
SA

safe-debug

lllllllama/rigorpilot-skills

Conservative diagnosis and minimal patching for deep learning training failures without automatic code mutation.

84k installsAudited
RU

run-train

lllllllama/rigorpilot-skills

Execute and document deep learning training runs with reproducibility and status tracking.

84k installs