little-loops 1.133.0

Development workflow toolkit for Claude Code with issue management, code quality commands, and automated processing

little-loops

The toolkit for long-horizon, eval-gated AI software development. Built as a Claude Code plugin.

Today's agents do small tasks well and ship features poorly. little-loops removes that ceiling with three things they're missing: durability (the run outlives the session), consistency (the toolbelt is the process), and verification (the harness is the spec).

Stop babysitting chats. Start shipping features.

1. Run agents until done

The unit of work is the feature, the sprint, or the overnight optimization — not a single chat. Runs survive terminal close, context exhaustion, and laptop sleep. Parallel sprints fan out across isolated worktrees and converge without you.

• ll-parallel — kick off N concurrent feature implementations in isolated worktrees. Walk away; they converge.
• --background + ll-loop resume — runs survive terminal close, sleep, and reboot. Resume picks up mid-trajectory, exactly where it stopped.
• harness-optimize — score-gated overnight optimization. Accept-or-revert each mutation; if interrupted, resume to the highest-scoring commit.
• Session handoff — a fresh context picks up mid-issue without losing the thread. Context limits stop being a planning constraint.

Ship features, not sessions.

2. Smart tools create smart processes

Raw agents re-derive the same structural moves differently each run. The ll- CLI removes the improvisation surface: context gathering, issue lifecycle, sprint moves, and worktree setup all run as typed commands. Two runs of the same feature land in the same shape — by construction, not by prompting.

• 36 typed CLI tools (ll-issues, ll-sprint, ll-loop, ll-parallel, ll-action, …) — structural work runs as commands, not improvised tool calls.
• /ll:manage-issue — composes the CLIs into a fixed plan → implement → verify → complete sequence. The agent reasons inside steps, not about which steps to take.
• Skill harnesses (/ll:ready-issue, /ll:wire-issue, /ll:confidence-check) — same inputs, same gates, same outputs.
• Worktree setup, branch naming, issue ID generation — mechanical operations that produce identical structure across runs.

Same feature, same shape, every run.

3. The harness is the spec

Harness-driven development is TDD's analog for agent-built software: define what "working" looks like first, then iterate until the harness passes. little-loops grades, writes, and improves the harness for you — removing the engineering tax that keeps most teams skipping evals entirely.

The harness grades:

• Thirteen layered gate types (exit code through full agentic simulation), cheapest first — failures route back to execution, not forward.
• Stall detection catches the "already done" no-op that silently burns through iteration budgets.

The harness writes itself:

• /ll:create-eval-from-issues — turn an issue's acceptance criteria into a runnable harness in under a minute.
• /ll:create-loop — auto-derive the full harness from your project config.
• ll-loop validate — dry-run the FSM before paying for a real run.

The harness improves itself:

• harness-optimize — hill-climbing on harness artifacts. One targeted edit per iteration, benchmark, accept on rising score, revert otherwise.
• Prompt optimization loops — point at a prompt, converge to a target score.
• /ll:audit-loop-run — four-valued verdict catches failure modes humans miss.

Point at context. Get a harness.

What's in the box

• 28 slash commands — issue discovery, refinement, planning, code quality, git, automation
• 9 specialized agents — codebase analysis, quality assurance, automation, and research
• 67 skills — deterministic harnesses for common workflows (confidence checks, issue wiring, loop creation)
• 36 CLI tools — ll-auto, ll-parallel, ll-sprint, ll-loop, ll-action, and more
• 96 FSM loops — recurring automation workflows (backlog triage, sprint building, eval harnesses)
• Configuration system — project-type templates for Python, JS/TS, Go, Rust, Java, .NET, and generic
• Design tokens — WCAG AA palette template set with FSM context injection for artifact-generating loops

---

Install

Prerequisites: Claude Code + Python 3.11+

# Add the GitHub repository as a marketplace
/plugin marketplace add BrennonTWilliams/little-loops

# Install the plugin
/plugin install ll@little-loops

# Install CLI tools (for ll-parallel, ll-loop, ll-auto, etc.)
pip install little-loops

Using Codex CLI? See docs/codex/getting-started.md — run ll-init --hosts codex and ll-adapt-skills-for-codex --apply to get started.

Alternative install methods

Local development install: see CONTRIBUTING.md.

Manual configuration — add to .claude/settings.local.json:

{
  "extraKnownMarketplaces": {
    "local": {
      "source": {
        "source": "directory",
        "path": "/path/to/little-loops"
      }
    }
  },
  "enabledPlugins": {
    "ll@local": true
  }
}

Quickstart

Four ways to feel the difference, top to bottom:

Scan and triage a codebase

ll-init                   # Auto-detect project type, generate config
/ll:scan-codebase         # Find issues (technical)
/ll:prioritize-issues     # Auto-assign P0–P5 priorities
/ll:map-dependencies      # Cross-issue dependency graph

Ship an issue end-to-end

/ll:manage-issue bug fix BUG-001   # Plan → implement → verify → complete

Fan out a parallel sprint

ll-sprint create v2-launch --issues FEAT-001,FEAT-002,FEAT-003
ll-parallel --workers 3            # Three isolated worktrees, three features, zero babysitting

Eval-driven development

/ll:create-eval-from-issues FEAT-001   # Turn acceptance criteria into a runnable harness
ll-loop validate harness-optimize      # Dry-run the FSM before paying for a real run
ll-loop run harness-optimize -b        # Score-gated hill climbing in the background

---

Documentation

• docs.little-loops.ai — hosted docs (searchable, dark mode, mobile)
• Command Reference — every /ll:* slash command
• CLI Reference — every ll-* command-line tool
• Configuration Reference — all options, variable substitution, overrides
• Loops Guide — FSM YAML authoring, gate types, loop patterns, practical examples
• Harness Optimization Guide — iteratively optimizing skills, commands, and configs against a benchmark
• Session Handoff Guide — context management and continuation
• Architecture Overview — system design and diagrams
• Troubleshooting — common issues and solutions
• Contributing — development setup, testing, guidelines

License

MIT