Loop directory

34 loops match your filters.

Marketing, content, research, product and operations.

Including grade C — stops on its own, but runs fewer checks than A or B. Back to A and B →

/goalProducthigh risknew

Ship P2-2 perception node end-to-end

Take story P2-2 from spec through implementation, Codex dev, and T11 code review until it commits green to fidelity-perception-arc-2026-06-19.

prompt
→ Claude Code
/goal Take Story P2-2 (PNG-grounded PerceptionArtifact + standalone vision node) of Epic P2 from current state through full implementation, testing, and validation. Use spawned bmad-party-mode for the mandatory Tier-3 pre-dev green-light and for any major decision/impasse. Pre-author the spec + Codex dev-prompt; hand dev+test creation to the Codex agent; then run Claude T11 (bmad-code-review 3-lane + remediation + commit + flip done). The goal is accomplished when P2-2 is committed done on branch fidelity-perception-arc-2026-06-19 with the validation gates below all green

A second, read-only loop that babysits a first one. Every ten minutes it reads the run's state file and latest log, runs the test suite so its evidence is an exit code rather than a self-report, and applies four explicit escalation triggers (no progress across two checks, repeated identical stack trace, budget exceeded, merge-queue conflict). On any trigger it prints ESCALATE and stops so a human looks; it never restarts, edits, merges, or pushes. Exits when the state file reports PASS or DONE, and after twelve checks regardless. Adapted from ECC's loop-operator agent (affaan-m/ECC, MIT), which lists the same triggers but has no cadence, cap, check command, or exit.

prompt
→ Claude Code
/loop every 10 minutes act as the loop operator for the autonomous run in this repo: run `cat state/loops/*.md`, `tail -100 logs/latest.log`, and `npm test` each pass, then report the active loop pattern, current phase, last successful checkpoint, the npm test exit code, failing checks, and cost drift against the budget in the state file. Print ESCALATE and stop this loop if any of these is true: no progress across two consecutive checks, the same stack trace repeats, cost exceeds the budget, or a merge conflict is blocking the queue — escalate to me, never fix it yourself. Otherwise print CONTINUE with one line of evidence. Report-only: never edit code, never restart or kill processes, never merge or push — any PR the run opens waits for me. Exit when the state file says Status: PASS or DONE. Stop after 12 checks regardless.
/goalResearchlow risk

Source-verified brief loop

Write a one-page brief where every claim has three or more sources and every link is opened and confirmed to support the claim — the loop that catches hallucinated citations a single prompt never can.

prompt
→ Claude Code
/goal write a one-page brief on [TOPIC] where every claim has at least three sources and every link opens to a real page that supports the claim. Open each link to confirm it before you call it done. Replace any source that is dead or does not back up the claim. Done when every source check passes on every claim — maximum 30 iterations.
/loopResearchlow risk

Repeat-offender digest

Read every loop's run ledger and find the one root problem showing up across multiple workflows.

prompt
→ Claude Code
/loop cadence: weekly. Read every loop's state/ledger file [DIR]. Append recurring failure patterns (which loops, symptom, frequency) to state-file repeat-offenders.md. Each round, identify the SINGLE root problem appearing across the most workflows and draft a fix-once recommendation. Read + own-file writes only; change no other loop. Stop after one root problem; log errors and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
/goalResearchlow risk

Kill-criteria loop

Make every live option declare the single fact that would disqualify it upfront, then hunt for that evidence.

prompt
→ Claude Code
/goal for each live option [LIST], state its ONE disqualifying condition upfront, then run an evidence hunt for that disqualifier. Done when: for every option, the state-file kill-criteria.md contains either PASTED evidence the disqualifier is true (kill it) or a documented search showing it isn't (keep it). No option stays undecided. Paste the evidence table as proof, or paste what's still missing and stop. Judge: a second smaller model checks each verdict cites evidence. Budget: cap $[X]. Hard cap: stop after 1 iteration per run.
/loopResearchlow risk

Hard-question escalation queue

Send every question to a cheap model first; escalate to Fable only on a logged failure.

prompt
→ Claude Code
/loop cadence: on-demand queue. For each incoming question in the queue, a cheap model attempts an answer and self-checks against [CRITERIA]. Append (question, cheap-model verdict, pass/fail) to state-file escalation-log.md. Escalate to Fable ONLY where the cheap model logged a failure; Fable answers just those. Read + own-file writes only. Stop when the queue is empty; log errors and stop. Budget: cheap-first, cap $[X]/run. Hard cap: stop after 1 iteration per run.
/loopResearchlow risk

Regulatory / source digest

Digest only what materially changed in the sources you must track, each with a plain-language 'so what.'

prompt
→ Claude Code
/loop cadence: weekly. Using the Firecrawl MCP, diff tracked regulatory/authoritative sources [LIST] against the last snapshot. Append only material changes to state-file source-digest.md. Each round, write a plain-language 'what changed / so what / who it affects' for each material change; ignore cosmetic edits. Read + own-file writes only. Stop after the digest; log errors and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
/loopResearchlow risk

Overnight intel refresh

A cheap model watches your tracked sources nightly; the expensive model writes only the monthly synthesis.

prompt
→ Claude Code
/loop cadence: nightly (synthesis monthly). Using Exa MCP + a Firecrawl monitor on tracked sources [LIST], have a cheap model log what materially changed to state-file intel-feed.md each night. Route to Fable only for the monthly synthesis: read the month's log and write ONE briefing of what changed and why it matters. Read + own-file writes only. Stop nightly after logging / monthly after the brief; log errors and stop. Budget: cheap-first, cap $[X]/run. Hard cap: stop after 1 iteration per run.
/loopOperationshigh risk

Unpaid-invoice chaser

Keep an aging ledger of unpaid invoices and draft the next nudge at each threshold — you send it.

prompt
→ Claude Code
/loop cadence: daily or weekly. Using the Stripe API (read), maintain an aging ledger of unpaid/overdue invoices. Append (customer, invoice, days overdue, threshold hit) to state-file invoice-aging.md. When an invoice crosses a threshold [7/14/30d], draft the appropriate reminder in the right tone — DRAFT ONLY. Never send outbound, never touch charges or refunds. Stop after drafting due nudges; log errors and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
/loopOperationslow risk

KPI anomaly watch

Stay silent on normal days and page you with a pre-investigated cause only when a metric breaks its expected band.

prompt
→ Claude Code
/loop cadence: daily. Using the PostHog MCP and Stripe (read), check my key metrics [LIST] against their normal bands. Append daily readings to state-file kpi-watch.md. On a normal day, do nothing but log. When a metric breaks its band, pre-investigate (segment, correlate, likely cause) and draft an alert with the diagnosis. Never change data or send customer-facing messages. Stop after the check; log errors and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
Sponsored · ConnectMyEmail

Loops that read your inbox.

Email is the missing tool in your harness. ConnectMyEmail gives Claude Code and Codex a clean MCP into Gmail, iCloud and IMAP — triage, drafts, follow-ups, on a loop.

connectmyemail.com →
/loopOperationsmedium risk

Proposal / RFP backlog drafter

Draft the repeated 80% of a proposal or RFP from your answer library and flag the new 20% for a human.

prompt
→ Claude Code
/loop cadence: on-demand or weekly. From my answer library [SOURCE] and the incoming RFP/proposal [DOC], draft the reusable ~80% (boilerplate, standard answers, past-response matches). Append (RFP, sections drafted, novel questions flagged) to state-file proposal-backlog.md. Each round, complete ONE proposal's reusable portion and list the new-20% questions a human must answer. Draft only; submit nothing. Stop after one; log and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
/loopOperationslow risk

SOP-drift catcher

Each week, compare how work actually happened against the written SOP and flag where they've drifted apart.

prompt
→ Claude Code
/loop cadence: weekly. Using the Notion MCP (read), compare recent task/project records against the documented SOP pages [LINKS]. Append drift findings (step, written vs actual, evidence) to state-file sop-drift.md. Each round, draft ONE SOP update proposal for the biggest drift — propose only, edit no live SOP. Stop after one proposal; log errors and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
/loopOperationsmedium risk

Month-close reconciliation prep

Categorize transactions against history and hand a human a clean exception list — it never files anything.

prompt
→ Claude Code
/loop cadence: monthly. Using the QuickBooks API (read), categorize the period's transactions against historical patterns. Append matches + anomalies to state-file month-close.md. Each round, build/refresh the exception list (uncategorized, unusual, likely-miscoded) for a human to review. Never post, file, or reconcile anything in QuickBooks. Stop when the exception list is complete; log errors and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
/loopOperationsmedium risk

Inbox-to-decision triage loop

Turn every unread email into a decision — do, delegate, defer, or drop — with the top reply already drafted.

prompt
→ Claude Code
/loop cadence: daily. Using the Gmail MCP (read + draft), process each unread thread and classify it decide / delegate / defer / drop. Append (thread, classification, rationale) to state-file inbox-triage.md. For 'decide' and 'delegate' threads, save a draft reply — draft only, send nothing, archive nothing. Stop after the unread batch; log errors and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
/loopProductmedium risk

Drop-point copy loop

Let analytics find the exact moment users give up, then rewrite the words on that one screen.

prompt
→ Claude Code
/loop cadence: weekly. Using the PostHog MCP (read), find the funnel step with the steepest drop-off. Append (step, drop rate, hypotheses) to state-file drop-points.md. Each round, draft rewritten copy/microcopy for the single worst drop screen — draft only, ship nothing to production. Stop after one screen; log analytics errors and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
/loopProductlow risk

Review-mine to roadmap

Compile app-store reviews and support into a roadmap ranked by how much pain each issue causes.

prompt
→ Claude Code
/loop cadence: weekly. Using the app store review APIs [STORES], pull new reviews + support exports. Append (issue, frequency, severity, star-impact) to state-file review-roadmap.md. Each round, re-rank the backlog by pain and draft a one-paragraph problem statement for the top unaddressed item. Write to the file only; change no roadmap tool live. Stop after one; log errors and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
/loopProductlow risk

Brand-mention feature radar

Sweep where people talk about you each week, cluster the complaints and asks, and deliver the loudest one as a drafted implementation plan.

prompt
→ Claude Code
/loop cadence: weekly. Using the Reddit API, HN Algolia, and Exa, sweep mentions of [BRAND / PRODUCT]. Append (source, mention, sentiment, feature ask/complaint) to state-file mention-radar.md. Each round, cluster and surface the single loudest theme, then draft an implementation plan for it — plan only, build nothing. Stop after one plan; log source errors and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
/loopMarketinglow risk

Presale questions loop

Turn the pre-purchase questions people ask in DMs, comments, and emails into a reusable, deduplicated answer bank.

prompt
→ Claude Code
/loop cadence: weekly. From my pasted/exported pre-sale questions [SOURCE], cluster recurring pre-purchase questions and objections. Append (question cluster, frequency, best current answer) to state-file presale-bank.md. Each round, write or improve ONE canonical answer for the most-asked unanswered question. Write to the bank file only; send nothing to any customer. Stop after one answer; log and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
/loopMarketinglow risk

Expectation-gap audit

Start from 'I thought it did X' support tickets and walk back to the exact page sentence that over-promised.

prompt
→ Claude Code
/loop cadence: weekly. Using the Zendesk MCP (read), pull tickets expressing a mismatch between expectation and reality ('I thought it...', 'the site said...'). Append (ticket theme, misread feature, suspected source page) to state-file expectation-gaps.md. Each round, trace the single most common gap back to the exact page sentence and draft a clarifying rewrite — draft only, edit nothing live. Stop after one; log errors and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
/loopMarketingmedium risk

Ad-creative fatigue drafting loop

Draft the next batch of ad creative before your current set fatigues — nothing launches without you.

prompt
→ Claude Code
/loop cadence: every [N] days. Using the Meta Marketing API (read), watch frequency, CTR decay, and CPA drift on active creatives. Append fatigue signals to state-file ad-fatigue.md. When a creative crosses [THRESHOLD], draft the next creative variant batch (hooks, angles, copy) — draft only, launch nothing, touch no budget. Stop after drafting one batch; log API errors and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
Sponsored · ConnectMyEmail

Loops that read your inbox.

Email is the missing tool in your harness. ConnectMyEmail gives Claude Code and Codex a clean MCP into Gmail, iCloud and IMAP — triage, drafts, follow-ups, on a loop.

connectmyemail.com →
/loopMarketingmedium risk

X content-idea miner

Watch a curated list on X each morning, rank what's actually working, and draft your take in your own voice ready to review.

prompt
→ Claude Code
/loop cadence: daily (morning). Using twitterapi.io to read my curated X list [LIST ID] and Typefully to hold drafts, rank the last 24h of posts by engagement-per-follower. Append top themes to state-file x-ideas.md. Each round, draft ONE post in MY voice [VOICE NOTES] on the strongest theme as a Typefully draft — never publish. Stop after one draft; log API errors and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
/loopMarketinglow risk

Content-brief backlog loop

Keep your content pipeline stocked with fully-specified briefs mined from your own search traffic, so writers never start from a blank page.

prompt
→ Claude Code
/loop cadence: weekly. Using the Search Console MCP, mine my own impressions/clicks for queries with demand but weak coverage. Append candidate topics (query, intent, current page, gap) to state-file brief-backlog.md. Each round, expand the single highest-opportunity topic into ONE fully-specified brief (angle, outline, target terms, internal links). Draft only. Stop after one brief; log GSC errors and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
/loopMarketinglow risk

Competitor-content watch loop

Read competitors' newly published articles and the keywords they target, then plan your moves against the gaps they leave open.

prompt
→ Claude Code
/loop cadence: weekly. Using DataForSEO MCP for keyword/SERP data and a Firecrawl monitor on competitor blogs [LIST], detect new competitor articles and the terms they target. Append (competitor, URL, target terms, gap vs our coverage) to state-file competitor-content.md. Each round, draft ONE counter-move brief against the largest open gap. Read + draft only; publish nothing. Stop after one brief; log source errors and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
/loopMarketinglow risk

Share-of-model brand watch

Every week, ask the AI engines the same 'best [category]' questions your buyers ask, log where your brand ranks, and track the trend over time instead of guessing.

prompt
→ Claude Code
/loop cadence: weekly. Using the Perplexity API, run my fixed list of 'best [category]' / buyer-intent queries [PASTE QUERIES]. Append each result (query, my rank/mention, competitors named, date) to state-file share-of-model.md as a time series. Each round, draft ONE action for the query where I dropped the most. Never message anyone or change any page. Stop after logging the week; if a query errors, log the failure and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
/loopMarketingmedium risk

Programmatic-page quality gate

Catch thin or duplicate template-generated pages and flag them for a human before Google penalizes the set.

prompt
→ Claude Code
/loop cadence: weekly. Using the Search Console MCP, pull my programmatic/template page set and check each for thin content, near-duplicate bodies, and impressions-without-clicks. Append flags (URL, issue, evidence) to state-file pseo-quality.md. Each round, draft a fix or consolidation recommendation for the WORST page only — recommend, never edit or deindex. Stop after one recommendation; log GSC errors and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
/loopMarketingmedium risk

Answer-engine gap loop

Each week, find the buyer questions people ask ChatGPT and Perplexity that your site doesn't answer yet, and close exactly one of those gaps.

prompt
→ Claude Code
/loop cadence: weekly. Using the Exa MCP, search for buyer-intent questions in [MY CATEGORY] that AI answer engines field but my site [DOMAIN] does not rank for or answer. Append findings (question, current answer source, whether we cover it) to state-file answer-engine-gaps.md. Each round, draft ONE page/section outline to close the single biggest gap — draft only, publish nothing. Stop after drafting one gap; if Exa errors, log it and stop. Budget: cap $[X]/run. Hard cap: stop after 1 iteration per run.
/goalContent & SEOlow risk

Fact-check before you publish

Inventory checkable claims, verify them against primary sources, repair high-risk mismatches, and log what stays unresolved.

prompt
→ Claude Code
Before publishing [draft], inventory every factual, statistical, quoted, or attributed claim a reader could verify. Find the best current primary source for each and label it supported, outdated, misattributed, unsupported, or unverifiable. Fix the riskiest mismatch, then recheck that claim and anything depending on it. Repeat until no high-risk unsupported claim remains or five rounds are exhausted. Never invent a source, cite evidence that does not support the claim, or alter a quotation. Ask before changing a named person’s quote or a legal, medical, or financial statement. Stop without changes if there are no checkable claims; stop as blocked when adequate evidence is unavailable. Finish with the claim-to-source table, corrections made, unresolved claims, and decisions requiring an editor.
/loopContent & SEOlow risk

Draft a LaTeX preprint, claim by claim

Build a seven-section LaTeX preprint with native figures, traceable claims, repeated compilation, and stated weaknesses.

prompt
→ Claude Code
Create a complete LaTeX preprint about [topic] using [supplied sources, assumptions, and data]. If the topic or required source material is missing, request it and stop. Do not invent claims, citations, or data. Use explicit placeholders for missing information. Include exactly these sections in order: Abstract, Introduction, Methods, Results, Discussion, Conclusion, and References. Build every figure and table with native LaTeX tools such as TikZ, pgfplots, and booktabs. Do not use \includegraphics, \svg, or external image files. Every substantive claim must trace to a numbered equation, citation, supplied datum, or labeled assumption. Compile using the project's documented command or latexmk when no command is specified. Inspect compilation errors, warnings, typography, cross-references, and figure placement. Fix the most serious issue and compile again for at most five rounds. Stop when compilation has zero errors, all seven sections are present, every figure and table is referenced before it appears, and no banned command remains. Otherwise stop as blocked or exhausted. Finish with the .tex file, compilation command and log, structural checks, three substantive weaknesses, three typography issues, and unresolved placeholders.
/scheduleContent & SEOlow risk

Ship one post a week, learn what works

Six weeks, one variable changed per post; measure replies, saves, and questions, and end with a winner or an honest null.

prompt
→ Claude Code
Find a repeatable weekly post format for [approved account, audience, and topic] through a six-week experiment. If the account, audience, or topic is missing, ask for it before drafting. Obtain approval before publishing anything externally. Each week, draft one short post about a real problem [person, product, or company] solves. Record substantive replies, saves, and questions after the same measurement window. Treat likes as secondary evidence. Keep the audience, topic area, cadence, and measurement window comparable. Change only one meaningful element each week, such as the opening, format, example, or call to action, based on the strongest signal from the previous post. Stop when one format materially outperforms the alternatives, the six-week experiment ends without a winner, approval is withheld, required metrics are unavailable, or the budget is exhausted. Never fabricate engagement data. Finish with every post, its measurements, the variables tested, the winning format or no-winner result, and the next recommendation.
/loopContent & SEOlow risk

Research until the deliverable's ready

Chase the most important evidence gaps until a memo, brief, spec, or page is genuinely ready to use.

prompt
→ Claude Code
Research [question or topic] and produce a decision-ready [memo, brief, specification, recommendation, page, or other artifact] for [audience or decision]. If the question, audience, or intended artifact is missing, ask one focused question before starting. State the decision the artifact should support, its acceptance criteria, the allowed source scope, and the research budget. If no budget is supplied, use no more than ten strong sources or ninety minutes. Prefer current primary sources where available. After each research pass, update the artifact and identify the largest remaining evidence gap, contradiction, or uncertainty. Continue only if resolving it could materially change the decision and the budget allows another pass. Never invent evidence or hide uncertainty. Stop when the artifact meets its acceptance criteria, important claims trace to sources, and remaining uncertainty is explicit. Otherwise stop as blocked or exhausted. Finish with the completed artifact, sources, findings, tensions, confidence level, open questions, and recommended next step.
Sponsored · ConnectMyEmail

Loops that read your inbox.

Email is the missing tool in your harness. ConnectMyEmail gives Claude Code and Codex a clean MCP into Gmail, iCloud and IMAP — triage, drafts, follow-ups, on a loop.

connectmyemail.com →