ank-loop
/ank-loop
Work through the open tasks in .ank/ without supervision, one claim at a time. Use when asked to work the backlog, chain tasks, or run autonomously in a repository with a .ank/ directory.
- Author
- haksolot ↗
- Repository
- ank ↗
- Licence
- Apache-2.0
- Last repository change
- 27.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.
Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.
What it does and when to use it
Work through the open tasks in .ank/ without supervision, one claim at a time. Use when asked to work the backlog, chain tasks, or run autonomously in a repository with a .ank/ directory.
Original author description
Work through the open tasks in .ank/ without supervision, one claim at a time. Use when asked to work the backlog, chain tasks, or run autonomously in a repository with a .ank/ directory.
How it works
- One pass
- Every turn under a claim
- Picking
- When a task is not ready
- Reviewing your own diff
- Never in the loop
SKILL.md preview
---
name: ank-loop
description: Work through the open tasks in .ank/ without supervision, one claim at a time. Use when asked to work the backlog, chain tasks, or run autonomously in a repository with a .ank/ directory.
metadata:
revision: "9ac4936e7eb1"
---
# ank-loop
The backlog was planned so this loop would not have to think about
architecture. Consume tasks. Never redesign them.
The ank skill is the contract and applies here in full: own worktree, fresh
branch from the default branch, ANK_AGENT set, criterion frozen at claim.
This file adds the loop policy only.
## One pass
ank status where you are, what others hold
ank graph what is genuinely unblocked
ank find --status open --free open tasks no live claim overlaps
pick one task see below
ank claim <id>
ank log --method loop record that this policy was loaded, once
ank show <id> the body carries the reasoning; read it first
ank context --since at the top of every turn while the claim is held
work; ank log "<discovery>" as you learn, not when you finish
review your own diff two axes, below; ank log what it found
ank done the close; it measures the tree, you never report it
next pass
## Every turn under a claim
Other agents keep working while you do. Once the claim is held, start every
turn with `ank context --since`: the entities whose file changed, and the
claims and completions recorded, since your last work on the task. Names by
id and never by content, so `ank show <id>` whatever you need to read whole.
Your last work is the claim's last renewal, so the cursor moves whenever the
claim is renewed, and reading `--since` is one of those renewals: two calls in
a row answer differently. Without a claim it is refused, because the cursor is
the lease.
It does not replace the full `ank context <path>` taken before the claim. That
one says what binds the perimeter and what is claimable; `--since` says only
what moved, and a constraint never read in full is not one a diff of changes
teaches you.
## Picking
Three tests, all mandatory: unblocked in the graph, criterion executable as
written, scope clear of every live claim. When no open task passes all three,
stop and say so. An idle loop is cheaper than two agents rewriting one
perimeter.
## When a task is not ready
A task is underplanned when its criterion is ambiguous, rests on a false
premise, or needs a decision no ADR has made. Do not invent the architecture.
Do not soften the criterion.
one clause rests on a false premise ank log "discrepancy: <assumed> vs <measured>", finish the rest
the whole criterion is wrong ank release --reason "<why>", move on
a decision is missing ank release --reason "<which>", flag it for planning, move on
it names work your scope cannot reach do the part you can, file the rest, then
ank release --reason "<what is left, and where>"
That last row is not a failure and is the commonest of the four. A criterion
that is right about the work and wrong about who can do it is answered by
releasing it, not by widening a scope you were not given: say what you measured,
what you finished, and which task carries the remainder.
Work you discover is a new task with blocked_by, left for a later pass. Never
a detour in this one.
## Reviewing your own diff
Before `ank done`, never after it, read the diff you are about to close on two
axes.
against the criterion every clause answered, and nothing it did not ask for
against the constraints every ADR that binds the paths the diff touches
The first axis takes the frozen criterion clause by clause and points each one
at a hunk. A clause you cannot point at is not done. A hunk no clause asked for
is scope you took without being given it, and it comes back out.
The second axis takes the constraints, not your memory of them: run `ank
context <path>` again over the paths the diff actually touches, which is rarely
the set you ran it on at the start of the pass, and read the diff against what
comes back.
Then `ank log` the outcome, whichever way it came out: the two axes, what each
one found, and nothing found where nothing was. The log is what outlives the
session, and a review nobody can read afterwards was not one.
A finding is acted on in the pass that found it. A constraint the diff breaks
is fixed before the close; scope the criterion never asked for comes back out
of the diff; a clause left unanswered is the release of the table above, and
never a smaller criterion.
The review is not a grade and does not replace one. `ank done` still runs the
verifiers and still measures. What the two axes catch is what a green suite
cannot: a criterion answered beside the point, and a constraint no test
encodes.
## Never in the loop
No questions to a human. No new ADRs or specs. No edit to any criterion.
The loop ends when nothing claimable is safe or the human returns. Leave the
report: what finished, what was released and why, and what planning owes the
backlog.
Versions
The database has no other skills named ank-loop.
Database snapshot: 13.11.2026 · package version c4559ac0a8b7 (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
- 85ank
Read a repository's tasks and binding constraints, claim work, and finish it with proof. Use when working in a repo that has a .ank/ directory. - 85ank-plan
Interview a goal into decisions and tasks recorded in .ank/. Use when someone brings a feature, change, or problem to plan before implementation in a repository with a .ank/ directory. - 92b00t-ooda
Run an autonomous OODA (Observe-Orient-Decide-Act) loop via ralph to execute task queues with a chosen AI executor. Use when asked to run autonomously, start an agent loop, execute pending tasks without supervision, or run OODA cycles. Activates on "run ooda", "autonomous loop",… - 86loop
Work through the taskboard unattended for hours, pacing against the usage limits and filling the gap before a reset with CPU-only jobs. Use when asked to run all day, work unattended, or loop over tickets. - 100loop-designer
Compile a goal into a durable, file-backed agent loop — a .loop/<name>/ charter any coding agent (Claude Code, Codex, Gemini, Grok) can execute unattended. Use when the user wants to "build a loop", "design a loop", "run X continuously/24-7", "make an agent keep working on Y",… - 100fanout
Orchestrate an unattended multi-task session for one legwork project. Loads everything queued (roadmaps, next prompt, open PRs), plans PR-sized tasks, dispatches each to a Herdr pane or a subagent at the orchestrator's judgement, runs the gate and the review loop (/pr-review) on…