ck:autoresearch

Automate iterative code changes to optimize measurable development metrics.

1|Updated Mar 6, 2026
One-click install
npx skills add https://github.com/quanganh208/cookmate --skill ck-autoresearch-quanganh208
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: ck:autoresearch
Source: https://github.com/quanganh208/cookmate/tree/main/.opencode/skills/ck-autoresearch
Command: npx skills add https://github.com/quanganh208/cookmate --skill ck-autoresearch-quanganh208

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Autonomous iterative experimentation to improve a single, measurable development metric (for example test coverage, bundle size, lint error counts, or build time) without manual trial-and-error, preserving a complete git history for analysis and rollback.

Core Features & Use Cases

  • Iterative optimization loop: Run N sequential iterations where each iteration makes one atomic change, commits it, verifies a numeric metric, and decides to keep or revert based on configurable thresholds.
  • Guarded safety checks: Optional guard commands prevent regressions by making guard-scoped files read-only and triggering rework or reversion when guards fail.
  • Logging and analysis: Records a TSV loop-results.tsv with iteration, commit, metric, delta, and decision to enable pattern recognition and strategy pivots.
  • Use Cases: Increase unit test coverage in a module, reduce main bundle size, eliminate ESLint errors in a directory, or iteratively lower build time while preserving test/guard invariants.

Quick Start

Run ck:autoresearch by providing a Goal, a Scope glob, and a Verify command that prints a single numeric value so the loop can iteratively improve that metric.

Frequently Asked Questions about ck:autoresearch

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

FAQPage Schema
How do I autonomously improve test coverage in a git-tracked codebase?▼

Autonomous test coverage improvement is achieved by applying an iterative optimization loop to a git-tracked codebase, making atomic code changes and verifying a numeric metric to decide whether to keep or revert each commit.

Can I automatically reduce bundle size without manual trial-and-error?▼

You can automatically reduce bundle size by running sequential iterations that make focused edits within a declared file scope, verify the size metric, and revert changes that do not meet a configurable minimum delta threshold.

What do I need to set up before running autonomous code optimization?▼

You need a clean git working tree, a declared file scope glob, and a Verify shell command that prints a single numeric value within 30 seconds to enable the automated loop to evaluate each iteration.

How does the iterative optimization loop handle regressions?▼

Iterative optimization handles regressions by using optional Guard commands that make guard-scoped files read-only, triggering automatic reversion of commits if the guard checks fail or the metric does not improve.

Does the optimization loop work with lint error reduction?▼

The optimization loop works with lint error reduction by running a Verify command that outputs the error count, iteratively editing scoped files, and committing only changes that lower the numeric lint error metric.

When should I not use autonomous iterative code changes?▼

You should not use autonomous iterative code changes if your git working tree is not clean, your metric cannot be printed as a single numeric value by a shell command, or verification takes longer than 30 seconds.