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:
| Question | Why 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 8am0 9 * * 1— Mondays at 9am0 9 * * 5— Fridays at 9am0 */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 range | Use for | Cache impact |
|---|---|---|
| 60s–270s | Active work — polling build, waiting for state that's about to change | Stays in 5-min prompt cache — fast + cheap |
| 300s ❌ | DON'T USE THIS | Worst of both worlds — pay cache miss without amortizing |
| 300s–3600s | Waiting on something that takes minutes to change | Pay cache miss but justified |
| 1200s–1800s (20–30 min) | Idle ticks with no specific signal | Default 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.txtwith 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-out | When 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 |
| * |