跳至正文
OpenAgentSkill
浏览已开放 · 目录记录日期 2026-11-21 · 自动更新和账户服务暂时关闭。
浏览器与自动化

loopify

When you want to set up an agent loop, cron-scheduled task, or recurring workflow that runs autonomously in Claude Code. Judgment layer on top of ScheduleWakeup, CronCreate, and the /loop skill — decides whether to use dynamic pacing (self-scheduling wake-ups), cron scheduling (fixed intervals), or a one-shot loop; tunes delay to avoid the 5-minute cache-miss cliff; designs idempotent loop bodies; sets bail-out conditions so loops don't run forever. Examples of loops to loopify — weekly review pulse, daily brief generation, hourly monitoring of a metric, periodic vault compilation, upstream-check for an adapted skill, sponsorship-pipeline refresh, YouTube-transcript-batch-download, morning startup routine. Triggers on "/loopify," "set up a loop," "schedule this task," "run this daily," "run this weekly," "cron this," "make this recurring," "automate this on a schedule," "keep this running until X." Part of the -ify trifecta (skillify / toolify / loopify) for extending Claude Code. NOT

coreyhaines31 · 已有 AI 审核记录

安装与使用

运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。

npx skills add coreyhaines31/makerskills --skill loopify

技能说明


name: loopify description: When you want to set up an agent loop, cron-scheduled task, or recurring workflow that runs autonomously in Claude Code. Judgment layer on top of ScheduleWakeup, CronCreate, and the /loop skill — decides whether to use dynamic pacing (self-scheduling wake-ups), cron scheduling (fixed intervals), or a one-shot loop; tunes delay to avoid the 5-minute cache-miss cliff; designs idempotent loop bodies; sets bail-out conditions so loops don't run forever. Examples of loops to loopify — weekly review pulse, daily brief generation, hourly monitoring of a metric, periodic vault compilation, upstream-check for an adapted skill, sponsorship-pipeline refresh, YouTube-transcript-batch-download, morning startup routine. Triggers on "/loopify," "set up a loop," "schedule this task," "run this daily," "run this weekly," "cron this," "make this recurring," "automate this on a schedule," "keep this running until X." Part of the -ify trifecta (skillify / toolify / loopify) for extending Claude Code. NOT for authoring a new skill — that's skillify. NOT for adding a tool/integration — that's toolify. metadata: version: 0.1.0

/loopify — Set up an agent loop

Wizard for going from "this task should run periodically" to a working loop with the right pacing, idempotency, and bail-out. Reference: ScheduleWakeup (dynamic pacing), CronCreate (fixed schedule), and the built-in /loop (dynamic self-paced re-entry).

Step 0 — Confirm what you're looping

Ask if not obvious from context: "What task should this loop do each iteration?"

Then get the essentials:

QuestionWhy it matters
How often?Determines cron vs dynamic vs one-shot
When to stop?Bail-out condition — loops must have one
What's the loop body doing?Determines idempotency requirements
Where does output go?File / notification / commit / nothing
What's the failure mode if it runs twice?Idempotency validation

Step 1 — Pick the pattern

Three primary patterns. Route by the answer to "how often":

Pattern A — Cron (fixed schedule)

Use when: task runs at predictable intervals — daily at 8am, weekly on Fridays, hourly on the hour.

Tool: CronCreate — schedules a recurring task with a cron expression.

CronCreate({
  schedule: "0 8 * * *",           // daily at 8am local
  prompt: "<loop body prompt>",
  timezone: "America/Los_Angeles"
})

Common cron patterns:

  • 0 8 * * * — daily at 8am
  • 0 9 * * 1 — Mondays at 9am
  • 0 9 * * 5 — Fridays at 9am
  • 0 */2 * * * — every 2 hours
  • */15 * * * * — every 15 minutes

Trade-offs:

  • ✅ Predictable, human-readable, easy to reason about
  • ✅ Best for time-of-day-dependent tasks (morning brief, EOD summary)
  • ❌ Runs at the scheduled time even if the last run isn't done — need idempotent body
  • ❌ No self-pacing — over-schedules if the task duration varies wildly

Pattern B — Dynamic pacing (self-scheduled)

Use when: task should react to state, not the clock. Monitor-until-condition-met patterns. Waiting on an external event.

Tool: ScheduleWakeup — the current run schedules its own next wake-up.

ScheduleWakeup({
  delaySeconds: 270,               // stay in cache window (< 5min)
  reason: "checking build status; sleeping under 5min to stay cache-warm",
  prompt: "<same task, re-entered>"
})

Critical delay rules (from ScheduleWakeup docs — internalized in the wizard):

Delay rangeUse forCache impact
60s–270sActive work — polling build, waiting for state that's about to changeStays in 5-min prompt cache — fast + cheap
300s ❌DON'T USE THISWorst of both worlds — pay cache miss without amortizing
300s–3600sWaiting on something that takes minutes to changePay cache miss but justified
1200s–1800s (20–30 min)Idle ticks with no specific signalDefault for autonomous loops

Never pick 300s literally — either drop to 270 (cache stays warm) or commit to 1200+ (cache miss buys longer wait).

Trade-offs:

  • ✅ Adaptive — sleeps longer when idle, shorter when active
  • ✅ Cache-optimal when tuned right
  • ❌ Requires the loop body to know when to schedule next (extra logic)
  • ❌ Harder to reason about when it'll run

Pattern C — One-shot loop (until-condition)

Use when: task runs until a condition is met, then stops. No recurrence after that.

Tool: /loop (built-in) with an exit condition in the prompt itself.

/loop
Check if the deploy is healthy. If yes → stop. If no → wait 5 min and check again.
Max 10 iterations. If still failing after 10, alert and stop.

Trade-offs:

  • ✅ Simplest for check-until-condition
  • ✅ Bounded — always eventually terminates
  • ❌ Not for indefinite recurrence — that's Pattern A or B

Step 2 — Design the loop body for idempotency

Idempotent = running the loop twice produces the same result as running it once. Non-negotiable for cron and dynamic patterns because they'll fire while the previous iteration is still running or partially complete.

Idempotency patterns:

  • Use "already done" markers: e.g., commit a state file <vault>/.loopify/<name>-last-run.txt with the timestamp of last successful run. Loop body checks the timestamp before doing work.
  • Use dedupe keys: if the loop writes to a DB or file, key by content-hash or timestamp so re-runs are no-ops.
  • Use transactions: DB writes in the loop body should be atomic — either all commit or all roll back.
  • Query before mutate: check current state before applying the change. If already applied, skip.

Show the user the loop body draft, highlighting the idempotency check. If none exists, add one.

Step 3 — Bail-out condition

Every loop needs one. Options:

Bail-outWhen to use
Max iterations (e.g., stop after 100 runs)Cron loops — prevents runaway
State-based (e.g., stop when metric X drops below Y)Monitoring loops
*
阅读完整来源 ↗