ck:autoresearch

Run autonomous iterative optimization loops for measurable code metrics.

Updated May 10, 2026
One-click install
npx skills add https://github.com/dthuy62/kollet-app --skill ck-autoresearch-dthuy62
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ck:autoresearch
Source: https://github.com/dthuy62/kollet-app/tree/main/.opencode/skills/ck-autoresearch
Command: npx skills add https://github.com/dthuy62/kollet-app --skill ck-autoresearch-dthuy62

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps you improve a measurable code metric by running repeated, controlled experiments and keeping only changes that produce verified progress.

Core Features & Use Cases

  • Autonomous optimization loop: Plans one atomic change at a time, measures the result, and decides whether to keep or discard it.
  • Git-backed experimentation: Uses commits and reverts as a built-in rollback and history system for safe iteration.
  • Guarded verification: Supports a separate regression check so metric improvements do not break the rest of the project.
  • Use case: Raise test coverage, reduce bundle size, lower lint errors, or tune performance in a repository with a clear numeric success metric.

Quick Start

Give the Skill your goal, file scope, verification command, and optional guard so it can run an autonomous improvement loop.

Frequently Asked Questions about ck:autoresearch

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

FAQPage Schema
How do I automate test coverage improvement in a git repository?

Automate test coverage improvement by running an autonomous optimization loop that applies one atomic change at a time, measures the numeric result, and commits verified progress. It uses git commits and reverts as a built-in rollback system for safe iteration.

What is the best way to reduce bundle size without breaking existing functionality?

Reduce bundle size safely by running an autonomous iterative optimization loop with a guarded verification check. This ensures metric improvements are measured against a numeric target and a separate regression guard prevents breaking the rest of the project.

Can I use autonomous optimization for lint cleanup and performance tuning?

Yes, autonomous optimization applies to repository-scoped tasks like lint cleanup and performance tuning. It requires a numeric verification command to measure success and an optional regression guard to ensure changes do not break existing project functionality.

How does rollback-safe iteration logging work with git-tracked commits?

Rollback-safe iteration uses git commits and reverts as a built-in history system. The optimization loop plans a change, measures the result, and decides whether to keep the commit or revert it, ensuring only verified progress is saved.

Do I need a numeric verification command to start automating code metric improvements?

Yes, a numeric verification command is required to start automating code metric improvements. The optimization loop relies on this measurable target to evaluate each atomic change, alongside an optional regression guard and git-tracked file scope.

What are the limitations of using an autonomous optimization loop for code metrics?

The optimization loop is limited to repository-scoped tasks with clear numeric success metrics. It requires a measurable verification command and git-tracked commits, meaning tasks without quantifiable targets or non-repository file scopes are not suitable.