autoresearch-code

Optimize codebases through baseline-first experiments and binary evaluation.

3|Updated Nov 30, 2025
One-click install
npx skills add https://github.com/alpoxdev/hypercore-skills --skill autoresearch-code
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: autoresearch-code
Source: https://github.com/alpoxdev/hypercore-skills/tree/main/skills/autoresearch-code
Command: npx skills add https://github.com/alpoxdev/hypercore-skills --skill autoresearch-code

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires bun, and includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill solves the problem of inefficient, manual code optimization by replacing guesswork with a systematic, evidence-based experiment loop that ensures only performance-improving changes are kept.

Core Features & Use Cases

  • Baseline-First Optimization: Captures current performance metrics before any changes are made to ensure a reliable point of comparison.
  • Binary Evaluation Loop: Uses strict yes/no evaluations to score code mutations, preventing subjective bias in optimization.
  • Use Case: When a codebase suffers from slow build times or memory leaks, this Skill runs repeated experiments to isolate bottlenecks, applies one mutation at a time, and keeps only the changes that demonstrably improve performance without breaking existing functionality.

Quick Start

Use the autoresearch-code skill to optimize the current repository by running experiments to reduce build times based on the provided test pack.

Frequently Asked Questions about autoresearch-code

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I optimize codebase performance without guessing what to change?

Codebase optimization requires a baseline-first experiment loop that captures current metrics, applies one mutation at a time, and uses binary evaluation to keep only changes that demonstrably improve performance. This replaces guesswork with measurable, iterative refactoring.

What's the best way to reduce performance bottlenecks in a large codebase?

Reducing performance bottlenecks involves running repeated experiments to isolate issues, applying single mutations, and verifying improvements through benchmarking. This systematic approach ensures changes address actual bottlenecks without breaking existing functionality.

Does codebase refactoring with experimentation require specific runtime environments?

Codebase experimentation requires the Bun runtime and local read, edit, and shell access to execute proof commands. This environment allows the iterative optimization process to record experiment artifacts and validate mutations directly within your repository.

How does binary evaluation work for codebase optimization?

Binary evaluation scores code mutations using strict yes/no evaluations, preventing subjective bias during optimization. It ensures only changes that demonstrably improve performance metrics compared to the baseline are kept, making refactoring results measurable.

Can I use this approach for codebase cleanup and reliability improvements too?

Yes, baseline-first experimentation applies to measurable codebase cleanup and reliability improvements, not just performance. By isolating variables and testing one mutation at a time, you can systematically enhance codebase stability and reduce bottlenecks.