The way you work with coding agents is shifting from prompting turn by turn to designing loops that prompt the agent for you - automations, worktrees, subagents, software factories in Claude Code and Codex. agent-skills is built for that shift. The skills are the verification you put inside the loop, so its output is evidence you can stand behind on the outside.
Boris Cherny, who leads Claude Code at Anthropic, put it bluntly: "I don't prompt Claude anymore. I have loops running that prompt Claude and figuring out what to do. My job is to write loops." A loop is one agent doing a single job on repeat: gather context, act, check the result, and go again until some condition is met. Stack loops and you get a software factory - many harnessed loops feeding a review gate, with a human owning the whole thing from above.
A loop needs five primitives plus somewhere to keep state, and Claude Code and Codex both ship all of them now. Skills are one of the five. Their job in the loop is specific and it is the reason this pack matters here: they encode the project knowledge the agent would otherwise guess, and the checks that make "done" mean something.
Inside the system there is one kind of thing: capability - investigate, implement, verify, repeat. Outside there is one kind of thing: agency - decide, verify, approve, own. The boundary between them is evidence.
Trusting the loop does not mean removing the human. It means the human does not need to be in the inner loop. You move to the loops only a person can hold: what constraints and invariants to set, how much output to sample and read, what evidence to keep and be able to explain, and which part of the production boundary you own. The agent can ship more than you can review, so the scarce resource is your judgment, informed by the quality signals the skills produce.
The rule for a factory: hand a loop only as much autonomy as you can cheaply and reliably verify, and not one inch more. The skill commands, and the loop primitives you wrap around them, map to rungs of that ladder. The skills are what make each rung safe, because they force the check that produces the evidence.
You drive each phase and approve at every step. The skills structure the work and force the verification; you read every result. This is where you build understanding of unfamiliar or high-stakes code.
You approve the plan once, then the agent implements every task in one pass. It stays test-driven and commits per task, and it pauses on failures or risky steps. You removed the stepping between tasks, not the verification.
A loop primitive in your harness, not part of this pack (Claude Code /loop, or a run-until-done /goal in Claude Code and Codex), runs the skills on a cadence or until a verifiable stop condition holds, with a separate checker grading the result. You review the evidence and give the verdict. Only earn this rung for loops you can cheaply and reliably verify.
A dark factory ships code no human has read, verified only by other machines. That is fine for some loops and dangerous for others. The skilled job is flipping each switch on purpose, not setting them all to the same mode.
The most useful structural move in a loop is splitting the agent that writes from the agent
that checks. The model that wrote the code grades its own homework too kindly. This is
exactly what /ship does when it fans out to review personas, and
what doubt-driven-development does to any confident decision.
incremental-implementation and test-driven-development - thin slices, each tested and committed.code-review-and-quality and, where it matters, the security-auditor persona, against the project skills and existing tests.You designed that once. You did not prompt any single step. And it runs the same in Codex or Claude Code, because the primitives are the same - the skills are the part that stays constant as you move between harnesses.
A loop running unattended is a loop making mistakes unattended. The skills give you back pressure, but "done" is a claim, not a proof. These three costs grow as the loop gets smoother, so design against them deliberately.
A loop that runs itself makes it tempting to accept whatever it returns. The skills’ anti-rationalization tables and verdict step exist to keep an opinion in the room. The output is still your answer, with all the accountability attached.
The faster the loop ships code you did not write, the wider the gap between what exists and what you understand. Sampling and reading are how you pay it down. A smooth loop grows the debt faster, with the tests green the whole way.
It is easy to spin up many agents; your review bandwidth does not parallelize. Your attention is the real ceiling on how many loops you can run, not the tooling. Spend it on the constraints and the dangerous assumptions.
This is how we suggest running the skills inside loops. It lines up with widely shared guidance on building agents, which is part of why the skills are shaped the way they are.
Use a predefined workflow or graph where you can, and reach for open-ended autonomy only when the task genuinely needs it. A skill is a workflow with a shape you can trust, not a free-running agent.
Effective agents check progress against the environment - tool results, test runs, code execution - rather than their own say-so. Every skill ends in exactly that: evidence, not "seems right."
Agents should stop for human feedback at checkpoints and on blockers. The verdict step and the human checkpoint between phases are those pauses, placed where a wrong call is expensive.
Anthropic’s own controlled trial found engineers who leaned on AI scored lower on comprehension of the resulting code. Reading what the loop makes is the antidote, and the reason to keep the lights on where it counts.
Informed by public guidance on agent design, including Anthropic’s Building effective agents, Effective harnesses for long-running agents, and research on AI assistance and coding skills. References, not endorsements.
Two people can build the same loop and get opposite results. One uses it to move faster on work they understand; the other to avoid understanding the work. The loop cannot tell the difference. You can.