loop-constructor

Design gated sub-loop workflows with machine-verifiable definitions of done.

5|Updated Jun 5, 2026
One-click install
npx skills add https://github.com/VincentJiang06/skills --skill loop-constructor
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: loop-constructor
Source: https://github.com/VincentJiang06/skills/tree/main/skills/loop-constructor
Command: npx skills add https://github.com/VincentJiang06/skills --skill loop-constructor

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

Medium and large AI-coding tasks often fail because they lack structured verification, clear role separation, and machine-checkable completion criteria. Without these, agents loop endlessly, produce slop, or require constant human intervention. This skill solves that by providing a rigorous selection procedure and deterministic linter to design closed-loop workflows that run autonomously.

Core Features & Use Cases

  • D0-D6 Selection Procedure: A rigorous decision tree that derives loop shape from runnable checks, not vibes—covering decomposition, pattern selection, autonomy level, parallelism, guards, and iteration profile.
  • Staged Loop Design: Decomposes tasks into gated sub-loops with machine-verifiable definitions of done, contract negotiation, and adversarial evaluator roles to prevent sycophancy.
  • Deterministic Validation: A linter that rejects hollow checks, missing contracts, or cyclic dependencies, and a renderer that produces a runbook only for passing designs.
  • Use Case: A developer needs to implement a medium-complexity feature with rate limiting and load verification. They use this skill to design a three-stage loop with a negotiated contract, separate evaluator context, and restart logic for broken builds.

Quick Start

Use the loop-constructor skill to design a gated sub-loop runbook for your medium or large autonomous coding task, emitted as a .loop/ runbook with machine-verifiable checks and an adversarial evaluator role.

Frequently Asked Questions about loop-constructor

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

FAQPage Schema
How do I design autonomous agent loops for complex coding tasks?

Autonomous agent loops prevent endless looping and slop by decomposing coding tasks into gated sub-loops with machine-verifiable definitions of done. A deterministic linter validates the loop-design JSON to ensure clear role separation and deterministic completion criteria before rendering a runbook.

Why does my autonomous AI agent loop endlessly or produce slop?

Autonomous AI agents loop endlessly or produce slop when tasks lack structured verification, clear role separation, and machine-checkable completion criteria. Applying a gated sub-loop design with adversarial evaluator roles and deterministic validation prevents these failures during autonomous execution.

How to create machine-verifiable definitions of done for AI workflows?

Create machine-verifiable definitions of done by applying a rigorous D0-D6 decision tree to derive loop shape from runnable checks. This staged loop design process uses contract negotiation and adversarial evaluator roles to establish deterministic completion criteria validated by a linter.

What is the best way to structure semi-autonomous coding tasks?

The best way to structure semi-autonomous coding tasks is decomposing them into gated sub-loops with machine-verifiable definitions of done. This approach uses a D0-D6 selection procedure covering decomposition, pattern selection, autonomy level, parallelism, guards, and iteration profile for deterministic validation.

Can I use a linter to validate autonomous workflow loop designs?

Yes, you can use a deterministic linter to validate autonomous workflow loop designs. The linter rejects hollow checks, missing contracts, or cyclic dependencies in the loop-design JSON, ensuring only passing designs with proper adversarial verification are rendered into a .loop/ runbook.

When do I need a gated sub-loop runbook for agent orchestration?

You need a gated sub-loop runbook for agent orchestration scenarios requiring autonomous execution, adversarial verification, and deterministic validation of completion criteria. It is designed for medium and large semi-autonomous AI-coding tasks that fail without structured verification and clear role separation.