use-loop

Runs verifiable goal-driven iteration loops with self-testing, state tracking, and structured closeout.

Updated Jul 3, 2026
One-click install
npx skills add https://github.com/alex-jordan547/agent-setup --skill use-loop-alex-jordan547
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: use-loop
Source: https://github.com/alex-jordan547/agent-setup/tree/main/archive/use-loop
Command: npx skills add https://github.com/alex-jordan547/agent-setup --skill use-loop-alex-jordan547

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Non-trivial coding and product tasks often end with unverified one-shot attempts. This Skill enforces a disciplined loop: define a verifiable goal, check tool access, iterate against a stable verifier, and only stop when the target is proven or a clear blocker is reported. ## Core Features & Use Cases - Loop Contract & State Machine: Declares goal, verifier, stop conditions, budget, and keep/revert rules before iterating, then records every attempt in a durable ledger. - Self-Test Enforcement: Requires checking tool access (tests, browser/app surfaces, credentials, APIs) and proof artifacts such as screenshots or recordings for visual work. - Structured Closeout: Finishes with simplify, self-test, and autoreview gates plus evidence, attempts kept/reverted, and residual risks. - Use Case: Ask the agent to fix a flaky UI flow; it sets a /goal with a browser-based verifier, iterates until the flow passes, captures screenshots as proof, and reports the final verified state. ## Quick Start Use the use-loop skill to implement and verify this task, iterating until the declared verifier passes or a blocker is found.

Frequently Asked Questions about use-loop

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

FAQPage Schema
How do I run an autonomous iteration loop for a coding task?

Define a verifiable goal with a target, verifier command, and stop conditions, then start a /goal continuation loop. Each attempt is measured against the verifier, kept if it improves the result, and recorded in a state ledger until the target is hit or a stop condition triggers.

What makes a good verifier for a goal loop?

A good verifier is a stable command, test suite, metric, browser check, eval, or explicit artifact inspection that acts as the source of truth. It must be accessible to the agent and consistent enough that repeated runs give trustworthy pass/fail signals.

When should I use a loop instead of a one-shot implementation?

Use a loop for implementation, product, QA, refactor, eval, performance, and cleanup work where progress can be measured. Skip it only when no verifiable target exists, and even then report the missing verifier as a blocker rather than silently downgrading.

What happens if the agent cannot self-test the goal?

The loop stops and reports the exact blocker, such as missing credentials, unavailable browser access, or absent test configs. It does not silently fall back to weaker proof; the tool-access check is mandatory before iterating.

How does the loop handle visual or UI verification?

For visual, animation, or multi-step interaction surfaces, proof artifacts are planned upfront: screenshots for final states and short screen recordings for flows. Artifacts are stored in durable paths and included in the final report.

What are the limitations of goal-loop workflows?

Loops require a verifiable target and tool access to self-test; without them the loop cannot run honestly. They also need explicit budgets and stop conditions to avoid unbounded iteration, and decision gates for destructive or product-judgment actions.