This source did not publish a separate summary. Review SKILL.md before using the skill.
SKILL.md
Workflow 1.5: Experiment Bridge
Implement and deploy experiments from plan: $ARGUMENTS
Overview
This skill bridges Workflow 1 (idea discovery + method refinement) and Workflow 2 (auto review loop). It takes the experiment plan and turns it into running experiments with initial results.
IDEA_CANDIDATES.md — compact idea summary (preferred when COMPACT = true)
IDEA_REPORT.md — fallback if refine-logs don't exist
If none exist, ask the user what experiments to implement.
Workflow
Phase 1: Parse the Experiment Plan
Read EXPERIMENT_PLAN.md and extract:
Run order and milestones — which experiments run first (sanity → baseline → main → ablation → polish)
For each experiment block:
Dataset / split / task
Compared systems and variants
Metrics to compute
Setup details (backbone, hyperparameters, seeds)
Success criterion
Priority (MUST-RUN vs NICE-TO-HAVE)
Compute budget — total estimated GPU-hours
Method details from FINAL_PROPOSAL.md — what exactly to implement
Present a brief summary:
📋 Experiment plan loaded:
- Milestones: [N] (sanity → baseline → main → ablation)
- Must-run experiments: [N]
- Nice-to-have: [N]
- Estimated GPU-hours: [X]
Proceeding to implementation.
Phase 2: Implement Experiment Code
If BASE_REPO is set — clone the repo first:
git clone <BASE_REPO> base_repo/
For each milestone (in order), write the experiment scripts:
Check existing code — scan the project (or cloned base_repo/) for existing experiment scripts, model code, and data loaders. Reuse as much as possible.
Implement missing pieces:
Training scripts with proper argparse (all hyperparameters configurable)
Evaluation scripts computing the specified metrics
Data loading / preprocessing if needed
Baseline implementations if not already present
Fixed random seeds for reproducibility
Results saved to JSON/CSV for later analysis
Proper logging (wandb if configured in AGENTS.md)
Follow the plan's run order — implement sanity-stage experiments first, then baselines, then main method, then ablations.
Self-review before deploying:
Are all hyperparameters from EXPERIMENT_PLAN.md reflected in argparse?
Is the random seed fixed and controllable?
Are results saved in a parseable format (JSON/CSV)?
Does the code match FINAL_PROPOSAL.md's method description?
CRITICAL: does evaluation compare predictions against dataset ground truth, never another model's output?
Phase 3: Sanity Check (if SANITY_FIRST = true)
Before deploying the full experiment suite, run the sanity-stage experiment:
/run-experiment [sanity experiment command]
Wait for completion. Verify:
Training loop runs without errors
Metrics are computed and saved correctly
GPU memory usage is within bounds
Output format matches expectations
If sanity fails → fix the code, re-run. Do not proceed to full deployment with broken code.
Phase 4: Deploy Full Experiments
Deploy experiments following the plan's milestone order:
/run-experiment [experiment commands]
For each milestone:
Deploy experiments in parallel (up to MAX_PARALLEL_RUNS)
Use /monitor-experiment to track progress
Collect results as experiments complete
🚦 Checkpoint (if AUTO_DEPLOY = false):
🔧 Code implementation complete. Ready to deploy:
Milestone 0 (sanity): [status — passed/pending]
Milestone 1 (baseline): [N experiments, ~X GPU-hours]
Milestone 2 (main method): [N experiments, ~X GPU-hours]
Milestone 3 (ablations): [N experiments, ~X GPU-hours]
Total estimated: ~X GPU-hours on [N] GPUs
Deploy now? Or review the code first?
Phase 5: Collect Initial Results
As experiments complete:
Parse output files (JSON/CSV/logs) for key metrics
Training quality check — if W&B data is available, invoke /training-check to detect NaN, loss divergence, plateaus, or overfitting. If W&B is not configured, skip silently.
Update refine-logs/EXPERIMENT_TRACKER.md — fill in Status and Notes columns
Check success criteria from EXPERIMENT_PLAN.md — did each experiment meet its bar?
Write initial results summary:
# Initial Experiment Results
**Date**: [today]
**Plan**: refine-logs/EXPERIMENT_PLAN.md
## Results by Milestone
### M0: Sanity — PASSED
- [result]
### M1: Baselines
| Run | System | Key Metric | Status |
|-----|--------|-----------|--------|
| R001 | baseline_1 | X.XX | DONE |
### M2: Main Method
| Run | System | Key Metric | Status |
|-----|--------|-----------|--------|
| R003 | our_method | X.XX | DONE |
### M3: Ablations
...
## Summary
- [X/Y] must-run experiments completed
- Main result: [positive/negative/inconclusive]
- Ready for /auto-review-loop: [YES/NO]
## Next Step
→ /auto-review-loop "[topic]"
Large file handling: If the Write tool fails due to file size, immediately retry using Bash (cat << 'EOF' > file) to write in chunks. Do NOT ask the user for permission — just do it silently.
CRITICAL — Evaluation must use dataset ground truth. Always compare model predictions against the dataset's actual labels/targets, never another model's output. If the task has official eval scripts, prefer them.
Follow the plan. Do not invent experiments not in EXPERIMENT_PLAN.md. If you think something is missing, note it but don't add it.
Sanity first. Never deploy a full suite without verifying the sanity stage passes.
Reuse existing code. Scan the project before writing new scripts. Extend, don't duplicate.
Save everything as JSON/CSV. The auto-review-loop needs parseable results, not just terminal output.
Update the tracker.EXPERIMENT_TRACKER.md should reflect real status after each run completes.
Don't wait forever. If an experiment exceeds 2x its estimated time, flag it and move on to the next milestone.
Budget awareness. Track GPU-hours against the plan's budget. Warn if approaching the limit.
Composing with Other Skills
/idea-discovery "direction" ← Workflow 1: find + refine + plan
/experiment-bridge ← you are here (Workflow 1.5: implement + deploy)
/auto-review-loop "topic" ← Workflow 2: review + iterate
/paper-writing "NARRATIVE_REPORT.md" ← Workflow 3: write the paper
Or use /research-pipeline for the full end-to-end flow (includes this bridge).
