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.