Claude Code Skill vs Loop: When to Encode Standing Jobs

Claude Code skill vs loop confuses teams that treat every reusable idea as a SKILL.md file or every long task as a /goal. Skills are standing instruction packs that load when a description matches. Loops are session runners that keep working until a condition passes or a schedule fires. This page separates those layers so you encode standing jobs in skills and finish-line work in loop commands. Soft skill drafts: https://promptmake.net/skills. Soft loop command text: https://promptmake.net/loop-prompt-generator. PromptMake generates config and command text only. It does not run Claude Code, upload skills, or execute loops. You leave with definitions, a picker, paste patterns, and an FAQ grounded in Anthropic’s mid-2026 docs.

Definitions: Skill and loop in Claude Code

A Claude Code Skill is a folder with a SKILL.md file. YAML front matter holds at least name and description. The markdown body holds steps, fences, and links to optional reference files. Claude loads a skill when your ask matches the description, or when you invoke /skill-name. Skills live under .claude/skills/ for a project or ~/.claude/skills/ for personal scope. As of September 2026, Anthropic documents progressive disclosure: name and description stay cheap in context until the skill activates.

A loop in Claude Code is a session control that continues work without you prompting every turn. Official docs distinguish /goal and /loop. /goal sets a completion condition; after each turn a small fast model (often Haiku-class) judges whether the condition holds from conversation evidence. /loop repeats a prompt on a time interval for polling and maintenance. Stop hooks are the deeper settings-file cousin when you need durable evaluators.

Skills teach how. Loops decide when to keep going. A skill can load inside a looping session. A loop can finish without any skill. Confusing the two produces either a bloated SKILL.md that tries to own a one-off migration, or a /goal with no playbook for house style.

This article is not claude-skills-vs-agents (skills versus broad autonomous agent framing) and not loop-engineering-explained (loop design theory). Stay here for skill versus loop encoding choices inside Claude Code.

When to encode a standing job as a Skill

Encode a skill when the same checklist will fire many times across weeks: release notes from merged PRs, PR summary against a house rubric, support reply draft from an approved FAQ, migration guards for a recurring API pattern. The job has stable steps and fences. Today’s ticket details change; the playbook does not.

Write a trigger-rich description. Anthropic’s authoring guidance asks for both what the skill does and when Claude should use it. Vague descriptions like "helps with code" cause false loads. Tight descriptions name verbs and scope: "Summarize merged pull requests into customer-facing release notes using the template in references/release.md."

Keep the body imperative and short. Put long tables in sibling files and link them. Add fences before destructive shell. Test with must-load and must-not-load prompts after every description edit.

Draft structure at https://promptmake.net/skills when blank folders stall you. Choose the Claude tab for SKILL.md-shaped text. Review paths and tool names before you commit. PromptMake does not push to Anthropic or create marketplace listings.

Skill signals that fit SKILL.md

Repeating weekly. Shared across the team via git. Needs examples of happy path and missing-info path. Benefits from progressive disclosure so idle context stays small. Works as a slash command teammates can invoke on purpose.

Optional front matter in current Claude Code docs can restrict auto-invocation (disable-model-invocation), limit tools, or point at supporting files. Verify field names against code.claude.com/docs skills pages when you upgrade Claude Code; fields evolve.

Skill anti-patterns

One giant essay that duplicates CLAUDE.md. Always-on stack facts belong in CLAUDE.md. Conditional playbooks belong in skills. Encoding a single ticket’s acceptance criteria as a skill creates dead files after merge. Encoding taste-only design review without fences creates noisy auto-loads.

When to use a Loop (/goal or /loop)

Use /goal when one session should keep working until a verifiable end state appears in the transcript: tests in a folder pass, lint is clean, a file count drops under a budget, a labeled queue is empty. Anthropic’s /goal docs stress measurable conditions the evaluator can judge from conversation evidence. The evaluator does not independently run shell; Claude must surface command results.

Write conditions with a stated check and a turn or time bound. Example shape: /goal npm test -- test/auth exits 0 and lint is clean, or stop after 20 turns. Include constraints that must not change. Clear with /goal clear when you need to stop early.

Use /loop when time, not a finish line, should trigger the next run: poll CI every five minutes, watch a deploy, remind yourself mid-session. Interval plus prompt is the common form. Esc clears a waiting /loop in interactive sessions per current docs. Prefer /goal when you need "keep fixing until green."

Soft command drafts: https://promptmake.net/loop-prompt-generator. Select /goal, /loop, or turn-based. PromptMake returns command text, success criteria, turn cap, and abort notes. It never executes the loop or opens your repo.

/goal versus /loop in one glance

/goal: next turn after previous finishes; stops when evaluator says met, impossible, or you clear; best for migrations and test-driven finish lines. /loop: next turn after an interval; stops when you cancel or Claude ends the scheduled work; best for polling. Stop hooks: durable settings-file evaluators for teams that outgrow session-scoped /goal.

Auto mode approves tools within a turn but does not start the next turn. Pair auto mode with /goal when you want unattended turn starts plus tool approval relief, still with a human watching cost.

Loop anti-patterns

Conditions like "make the app better" with no evidence. Missing turn caps on long goals. Running /loop for a finish-line refactor. Treating PromptMake as a runner. Ignoring token burn when each cycle rereads a large repo.

Decision matrix: skill, loop, or both

Standing playbook, many future asks → Skill. One session, verifiable done → /goal. Recurring poll while session open → /loop. Risky change needing human approval each cycle → turn-based instructions from the loop generator, not a free-running goal.

Both: skill holds the release-note template; /goal keeps editing until CHANGELOG covers every merged PR this week and tests pass. The skill shapes format. The goal owns completion.

Neither: one-line edits you can verify in a single turn. Taste-heavy product decisions. Irreversible production changes without a human gate.

Cross-check related posts only for depth: claude-skills-vs-agents for skills versus agent framing; loop-engineering-explained for verify ladders; this page for encode-standing-job versus run-until-done.

Encode standing jobs checklist

1. Name the job in one line. 2. Ask if it repeats weekly. 3. If yes, draft SKILL.md description triggers and body steps. 4. If today’s ask is a finish line, draft /goal with proof and turn cap. 5. If the ask is a poll, draft /loop with interval. 6. Generate drafts at https://promptmake.net/skills and https://promptmake.net/loop-prompt-generator. 7. Test locally in Claude Code before sharing.

Combine without collision

Keep skill descriptions from matching every /goal you type. If a skill auto-loads on "fix tests" during unrelated goals, tighten the description or set manual invocation for that skill. Put shared verify commands in the goal condition; put house style in the skill body.

Paste patterns you can adapt today

Skill front matter sketch:

name: pr-release-notes

description: Draft customer-facing release notes from merged pull request titles and bodies using the house template. Use when the user asks for release notes, changelog customer copy, or ship notes from merged PRs.

Body sketch: Purpose, When to use, Steps, Fences (no pushing tags), Examples.

Goal sketch: /goal all tests under test/billing exit 0, no new files outside packages/billing, or stop after 15 turns.

Loop sketch: /loop 5m check whether the staging deploy finished and summarize the latest CI status without changing files.

Edit every path and command for your repo. Soft scaffolds: skills tab at https://promptmake.net/skills; loop text at https://promptmake.net/loop-prompt-generator.

Testing skills

Five prompts that must load. Five that must not. One missing-input case. One out-of-scope case. Update Examples when a failure repeats. Skills that never get tests rot after Claude Code upgrades.

Testing loops

Run a read-only /goal first ("report whether tests pass without editing"). Then allow edits on a branch. Watch evaluator reasons with the status views Claude Code provides. Abort on repeated identical failures.

Skills load; loops continue

Anthropic’s skills docs describe progressive disclosure and trigger-rich descriptions. Claude Code can also invoke a skill with /skill-name when you want manual control. Optional front matter such as disable-model-invocation keeps a workflow manual-only. Confirm current field names on code.claude.com/docs when you upgrade.

Anthropic’s /goal docs describe session-scoped completion conditions evaluated after turns. /loop is interval-based. PromptMake’s loop generator also offers turn-based text for hosts or moments when you want to approve each cycle yourself. That third pattern is still loop engineering, not a skill file.

Remember the honesty line in every handoff doc: PromptMake produces SKILL.md-shaped text and /goal command text. Claude Code runs them after you paste. No marketplace upload. No remote loop runner.

Product honesty and cost

PromptMake guests get about three text generations per day per path. Free accounts get about five. Pro removes the small daily cap for regular use. Those limits cover PromptMake generation only. Claude Code token spend, evaluator Haiku-class calls, and Anthropic plan rules are separate.

Skills and loops both cost context. Skills cost little until loaded, then body tokens. Loops cost every turn plus evaluator tokens on /goal. Narrow directory scope and targeted tests cut burn.

Never invent a PromptMake runtime. The product writes text. You paste into Claude Code under your permissions.

Workflow example: release notes skill plus changelog goal

A concrete week shows the split. Monday you commit a skill that drafts customer release notes from merged PR titles using a house template. The description lists triggers: release notes, changelog customer copy, ship notes. The body points at references/release.md and fences pushing tags.

Thursday you open Claude Code on the release branch and run a /goal: CHANGELOG.md has a customer section for every PR merged this week, npm test exits 0, or stop after 12 turns. The skill may load when you ask for release wording. The goal owns completion proof.

If the evaluator keeps saying notes are incomplete, check whether Claude surfaced the PR list in the transcript. /goal judges conversation evidence. Ask Claude to list merged PRs and paste the CHANGELOG diff before the next turn.

Friday you tweak the skill Examples with the missing-info case from Thursday. You leave the /goal text in the team wiki beside the PromptMake loop draft link so the next release reuses both layers.

Soft scaffolds stay separate on purpose: https://promptmake.net/skills for the standing playbook, https://promptmake.net/loop-prompt-generator for the finish-line command. Mixing them into one file is how standing jobs become one-off ticket sludge.

Encode standing jobs in git

Store skills under .claude/skills/ with the folder name matching the slash command. Review description diffs like API changes. A looser description is a silent behavior change for everyone on the repo.

Cap loops in the ticket template

Add turn cap and abort rules to every ticket that asks for a /goal. "Until it works" is not a condition. "Exit code 0 on package tests, no files outside packages/foo, or stop after 10 turns" is a condition teammates can supervise.

FAQ

What is the difference in claude code skill vs loop?

A skill is a SKILL.md playbook that loads on trigger or slash invoke and shapes how Claude works. A loop is session control (/goal or /loop) that keeps the session running until a condition or schedule says stop. Skills encode standing jobs. Loops run a finish line or a poll. PromptMake drafts both as text at /skills and /loop-prompt-generator.

Should I put acceptance criteria in a Skill or a /goal?

Put durable house rules in a skill. Put this ticket’s measurable finish line in /goal. Acceptance criteria that die after merge belong in the goal condition or a one-off prompt, not a permanent skill file.

How is this different from claude-skills-vs-agents?

Claude-skills-vs-agents compares skills to broader autonomous agent sessions. This claude code skill vs loop page compares skills to /goal and /loop control surfaces. Read agents when you debate playbook versus open-ended tool use. Stay here when you choose SKILL.md versus session runners.

Does PromptMake run /goal for me?

No. https://promptmake.net/loop-prompt-generator writes command text, verify criteria, and turn-cap guidance. You paste into Claude Code. PromptMake does not access your repository or schedule jobs.

Can a Skill and a /goal work together?

Yes. Load or invoke a skill for format and fences, then set /goal for completion proof. Keep skill triggers narrow so they do not fire on unrelated goals. Combine when the standing playbook and the finish line are both clear.

What does Anthropic document for /goal evaluation?

As of September 2026, /goal wraps a session-scoped prompt-based Stop hook. A small fast model judges the condition from conversation evidence after turns. Verdicts include not yet met, met, and impossible. Write conditions Claude can prove in the transcript. Check code.claude.com/docs/en/goal for current behavior when you upgrade.

How do I start encoding a standing job on PromptMake?

Open https://promptmake.net/skills, describe the recurring job, generate a Claude SKILL.md draft, and edit triggers. If the next task is a finish line, open https://promptmake.net/loop-prompt-generator for /goal text. Guests get about three generations per day per path; free accounts about five.