ck:loop

Run N autonomous iterations optimizing a measurable metric with git history.

Updated Apr 9, 2026
One-click install
npx skills add https://github.com/DatTran26/KienTruThiHanh --skill ck-loop-dattran26
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ck:loop
Source: https://github.com/DatTran26/KienTruThiHanh/tree/main/.agents/skills/ck-loop
Command: npx skills add https://github.com/DatTran26/KienTruThiHanh --skill ck-loop-dattran26

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Autonomous iterative optimization loop that runs N iterations against a measurable metric, learns from git history, and auto-keeps or discards changes, enabling repeatable improvement with traceable experiments.

Core Features & Use Cases

  • Autonomous iteration: executes a sequence of isolated changes, each evaluated against a defined metric, with per-iteration commits.
  • Git-as-memory: maintains a history of experiments in git for rollback and analysis.
  • Guarded verification: supports an optional guard step to protect against regressions.
  • Use Case: improving a measurable code quality metric (e.g., test coverage, performance, bundle size) across a project while preserving a detailed experiment log.

Quick Start

Configure a Goal and Scope to start an autonomous optimization loop targeting your metric.

Frequently Asked Questions about ck:loop

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

FAQPage Schema
How do I automate iterative optimization for code metrics like test coverage?

Autonomous iterative optimization executes isolated code changes against a measurable metric, committing each iteration to git. It learns from experiment history, auto-keeping improvements or rolling back regressions to ensure traceable metric gains.

How does the git history rollback mechanism work during automated experimentation?

Git-as-memory logs each guided experiment as a per-iteration commit. If an isolated change fails verification or optional guard checks, the loop discards it and rolls back to the previous committed state to preserve baseline stability.

Can I use guard checks to protect against performance regressions during automated code changes?

Guarded verification runs an optional guard step before keeping isolated code changes, protecting against performance regressions. This deterministic protocol evaluates each iteration against baseline metrics, preventing degradation across the codebase.

What is the best way to run guided experiments for reducing bundle size?

Configuring an autonomous loop with a defined Goal and Scope executes isolated changes targeting bundle size. It applies per-iteration verification and auto-discards changes that fail to improve the target metric, ensuring guided experimentation.

Does autonomous iteration require a specific testing framework to verify code quality improvements?

Autonomous iteration uses a deterministic protocol with per-iteration verification rather than mandating a specific testing framework. Users configure the measurable mechanical metric and optional guard checks to evaluate code quality improvements.

Why does my automated optimization loop fail to keep changes that improve the target metric?

An autonomous optimization loop discards changes that improve the target metric if they fail optional guard checks or per-iteration verification. This deterministic protocol prevents secondary regressions, maintaining overall codebase stability.