autoresearch

Automate iterative code-quality improvement with metric evaluation and Git rollback.

Updated May 30, 2026
One-click install
npx skills add https://github.com/alexica00/claude-code-ultimate-guide --skill autoresearch-alexica00
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: autoresearch
Source: https://github.com/alexica00/claude-code-ultimate-guide/tree/main/examples/skills/autoresearch
Command: npx skills add https://github.com/alexica00/claude-code-ultimate-guide --skill autoresearch-alexica00

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Automates iterative code-quality improvement by measuring metrics, scaffolding experiments, and executing autonomous iterations that keep changes only if metrics improve.

Core Features & Use Cases

  • Automated measurements: collect and compare code metrics to identify improvement opportunities.
  • Experiment scaffolding: generate loop structures and necessary files to run autonomous iterations.
  • Agent-driven iterations: perform controlled changes and revert if metrics do not improve; loop repeats until target is reached.
  • Use Case: A software project wants to steadily reduce a specific quality metric (e.g., complexity, churn, or lint violations) through automated experiments with deterministic evaluation and rollback.

Quick Start

Scaffold a loop with --scaffold, then write program.md and run with --run loop-name.

Frequently Asked Questions about autoresearch

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

FAQPage Schema
How do I automate iterative code-quality improvement in my software project?

Automated iterative code-quality improvement is achieved by measuring metrics, scaffolding experiments, and executing autonomous iterations that only keep changes if the measured metrics improve. You can scaffold a loop with the --scaffold command and run it using --run loop-name.

What is autonomous code-quality experimentation with Git rollback?

Autonomous code-quality experimentation is an agent-driven loop that performs controlled code changes to reduce specific quality metrics like complexity or lint failures. It uses Git rollback to automatically revert any changes that do not deterministically improve the defined metrics.

How do I scaffold and run an autonomous loop to reduce code complexity?

To scaffold and run an autonomous loop, use the --scaffold command to generate the necessary file structures, write your constraints in program.md, and execute the loop with --run loop-name. The loop repeats until your target quality metric is reached.

Do I need specific configuration files to run autonomous code-quality iterations?

Yes, running autonomous code-quality iterations requires a defined skill contract including a frontmatter name and description in SKILL.md, a measure script under scripts/autoresearch, and a program.md file encoding the constraints for the evaluation loop.

What code-quality metrics can I reduce using automated experimentation?

Automated experimentation can target various code-quality metrics for steady reduction, including code complexity, duplication, churn, and lint violations. The agent-driven loop measures these metrics deterministically and keeps changes only when the chosen metric improves.

When should I not use an autonomous agent-driven loop for code refactoring?

You should avoid using an autonomous agent-driven loop when your project lacks a deterministic measure script for quality metrics or cannot support Git rollback for reverting failed experiments, as the loop relies entirely on these mechanisms to evaluate and retain changes.