Skip to content
Skills Library
Programming · Automation

micro-loop

/micro-loop

Execute a simple, low-risk phased plan from `.plans/{task}/` straight through with no builds, tests, or commits between phases; verify, lint, and commit once at the end. Use when the plan is straightforward and rebuilding per phase would only waste time.

Repository
skills ↗
Licence
MIT
Last repository change
12.11.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 12.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Execute a simple, low-risk phased plan from `.plans/{task}/` straight through with no builds, tests, or commits between phases; verify, lint, and commit once at the end. Use when the plan is straightforward and rebuilding per phase would only waste time.

Arguments

/micro-loop <.plans/task or slug>
Original author description

Execute a simple, low-risk phased plan from `.plans/{task}/` straight through with no builds, tests, or commits between phases; verify, lint, and commit once at the end. Use when the plan is straightforward and rebuilding per phase would only waste time.

How it works

  1. Constraints (on top of the shared ones)
  2. The Loop
  3. Final verification
Original SKILL.md headings · 57 lines, 418 words
SKILL.md preview
---
name: micro-loop
user-invocable: false
description: Execute a simple, low-risk phased plan from `.plans/{task}/` straight through with no builds, tests, or commits between phases; verify, lint, and commit once at the end. Use when the plan is straightforward and rebuilding per phase would only waste time.
argument-hint: "<.plans/task or slug>"
---

# Micro Task Loop

A fast path for simple phased plans. Trades per-phase safety checkpoints for wall-clock time: no builds, tests, or commits until every phase is done, then one verification pass and one commit. `tasks.md` tracks progress in real time.

**Arguments:** `$ARGUMENTS` — the plan (a `.plans/<task>/` path or slug). Always run the whole plan.

Picked by pick-tier when the tier is S or M.

**Read `task-loop-rules.md` in this skill's folder first.** It holds the project commands, constraints, concepts, task-list discipline, and finishing steps all three task loops share. This file adds only what is specific to this loop.

## Constraints (on top of the shared ones)

- **Edit-only until the end.** During phases, only edit files; `check` and `test` wait for **Final verification** — not per-package, not per-module, not "just this once." Avoiding rebuild-thrash is the entire point of this skill. Exception: an environment or toolchain failure that blocks editing itself.

---

## The Loop

**Repeat until every task is complete.** Work per phase, top to bottom.

1.  **Check status.** `Read` `tasks.md`. Every task `[x]` → go to **Final verification**. Otherwise start at the next task.

2.  **Gather** what the current task needs: the spec section it implements and the code it touches.

3.  **Implement, one task at a time:**

    a. **Restate** the current task in one sentence.

    b. **Do the work** — edits only (Constraint 2).

    c. **Tick it** in `tasks.md`.

    d. **Pick the next task** under the current phase header and repeat from (a). When the phase has no `- [ ]` left, go to 3.5.

3.5. **Audit.** Re-read `tasks.md`. Any task in this phase not `[x]` means you drifted: return to step 3 with it. The list must be clean before you move to the next phase.

4.  **Go to step 1.**

---

## Final verification

All phases are done and the list is clean. Run these in order without stopping, unless an unrecoverable error blocks progress:

1.  **Check.** Run `check` and fix until it passes. Failures can point at any phase — fix forward.

2.  **Test.** Run `test`; all tests pass.

3.  **Lint and format** as in **Finishing** step 1 of the rules file.

4.  **Commit once** with a Conventional Commit message, `<type>(<scope>): <summary>` (lowercase, imperative, 72 characters or fewer), only after check, tests and lints pass. If an unrecoverable failure blocks verification, stop and report instead of committing.

5.  **Sync.** Run `sync` once (resolve conflicts, re-test, commit the merge).

6.  **Hand back** as in **Finishing** step 2 of the rules file.
Files in this package (2)
  • SKILL.md 3 KB
  • task-loop-rules.md 4 KB

Versions

The database has no other skills named micro-loop.

Database snapshot: 13.11.2026 · package version 928d8b5d0bd7 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90simple-loop
    Execute a phased plan from `.plans/{task}/` task by task, using `check` output to steer edits, with tests and a commit per phase. Use for everyday multi-phase work, including large refactors where the build breaks between tasks.
  • 100phased-loop
    Execute a phased plan from `.plans/{task}/`, checking each phase's part of the plan against the code before building it, with a full test run, commit and sync at the end of every phase. Use for multi-phase work where later phases depend on what earlier ones discover.
  • 86team-shinchan:micro-execute
    Use when you need micro-task execution with per-task two-stage review.
  • 90implementation
    Execute an approved plan well — follow existing conventions, work phase by phase, batch verification to the end, keep the diff to the agreed scope, and hand back with an honest account of what ran. Use whenever editing code against a plan or an agreed change.
  • 100build-phases
    Execute a phased implementation plan (tasks.md) autonomously, one phase at a time: implement, then verify (static + dynamic + adversarial) before advancing. Use for a multi-phase build of one issue, attended or unattended.
  • 100superbuild
    Use when executing implementation plans phase-by-phase with strict enforcement of quality gates, tests, and Definition of Done. Triggers on "build this plan", "execute plan", "implement phases", or when user provides a plan document to execute.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.