loopkit

   ▄█        ▄██████▄   ▄██████▄     ▄███████▄  ▄█   ▄█▄  ▄█      ███
  ███       ███    ███ ███    ███   ███    ███ ███ ▄███▀ ███  ▀█████████▄
  ███       ███    ███ ███    ███   ███    ███ ███▐██▀   ███▌    ▀███▀▀██
  ███       ███    ███ ███    ███   ███    ███ ▄█████▀   ███▌     ███   ▀
  ███       ███    ███ ███    ███ ▀█████████▀ ▀▀█████▄   ███▌     ███
  ███       ███    ███ ███    ███   ███         ███▐██▄  ███      ███
  ███▌    ▄ ███    ███ ███    ███   ███         ███ ▀███▄███      ███
  █████▄▄██  ▀██████▀   ▀██████▀   ▄████▀       ███   ▀█▀ █▀     ▄████▀

30-second quickstart

# 1. drop the harness into your project (safe: skips existing files)
curl -fsSL https://raw.githubusercontent.com/Archive228/loopkit/main/install.sh | bash

# 2. open Claude Code / Cursor / Codex in the same directory
claude

# 3. write a one-line spec, then let the loop drive
echo "STATUS: not-started" > IMPLEMENTATION_PLAN.md
./run.sh

That's it. Skills load only when a task triggers them. The verifier subagent closes the loop.

Existing files are kept by default. Pass FORCE=1 to overwrite, or BACKUP=1 to snapshot your current .claude/ to .claude.bak-<timestamp>/ before writing.

What loopkit is (and isn't)

Straight from my own .claude/ directory. This is the loadout I actually reach for — not a methodology, not a lifecycle, not a framework.

loopkit is:

• A working harness: settings, hooks, verifier subagent, loop runner. Files on disk, no runtime.
• 49 small skills that load only when relevant, so the agent specializes instead of guessing.
• Cross-agent. Every skill is a plain markdown doc with a YAML header — nothing Claude-specific inside the skill body.

loopkit isn't:

• A new methodology to learn. No BMAD, no Prime Radiant, no 6-phase lifecycle. If a skill doesn't help the loop advance, it isn't here.
• A wrapper CLI. No daemon, no server, no runtime state. run.sh is 8 lines.
• A vendor lock-in. Fork it, gut it, keep the three skills you like. MIT.

The loop

Every skill fires inside this shape. The harness enforces it.

  PLAN ──▶  ACT  ──▶  VERIFY
    ▲                    │
    └────── revise ──────┘

• PLAN — spec-first, context-budget, tool-restraint, planner-spec-expand, sprint-contract load here.
• ACT — domain skills load here (debug, security, testing, refactor, docs, data, git-ops).
• VERIFY — adversarial-verify + evaluator-calibration + the verifier subagent close the loop before anything ships.

Full theory: Loop and Harness engineering: 7 files, 5 steps.

File-by-file: what you get

your-project/
├── .claude/
│   ├── CLAUDE.md          # 60-line standing context (edit for your stack)
│   ├── settings.json      # permission allowlist + format-on-write hook
│   ├── agents/
│   │   └── verifier.md    # adversarial verifier subagent (Haiku, JSON-out)
│   ├── hooks/             # session-start bootstrap
│   └── skills/            # 49 skills, symlinked or copied
├── .mcp.json              # MCP server wiring (github, context7)
├── MEMORY.md              # cross-session memory index (keep terse)
└── run.sh                 # Plan → Act → Verify loop runner

Every file below is opinionated on purpose. Change what doesn't fit; the loop still works.

.claude/CLAUDE.md — standing context

60 lines, no more. The tax on every turn. Stack, layout, commands, conventions, the three things the agent must never do. Prune weekly.

.claude/settings.json — permissions + hooks

Allowlist for read-only Bash and Read; deny-list for rm -rf and force-push. PostToolUse hook runs Prettier on every Edit/Write so the diff stays reviewable.

.claude/agents/verifier.md — the adversarial subagent

Runs on Haiku. Reads the diff assuming it's broken. Checks the 11 "fake done" shortcuts (see skills/adversarial-verify). Returns JSON. Does not propose fixes, does not run code, does not be polite. This is the load-bearing piece.

.claude/hooks/ — session-start bootstrap

Fires when the agent opens the project. Reminds it of the loop shape and points at CLAUDE.md. Zero runtime cost.