Source Library Ingestion QA ★
Turn raw captures into retrieval-ready knowledge instead of a pile of orphaned links.
A new article, video, X post, podcast, or image enters your knowledge base and should be findable later.
Sortable wall
All 68 reusable loops in one searchable wall. Filter by category, difficulty, tag, or Paul originals when you already know the kind of work you want to run.
Loop Library
68 loops. Search title, use case, tags, verification, or prompt.
★ Paul's picks
Turn raw captures into retrieval-ready knowledge instead of a pile of orphaned links.
A new article, video, X post, podcast, or image enters your knowledge base and should be findable later.
Make the repo legible to agents before asking them to do real work.
You are about to let a coding agent do meaningful work in a repo and want fewer dumb mistakes.
Keep documentation synced with what the product actually does.
Code changed and the docs are probably now lying by omission.
Raise the floor for every future loop by improving the evidence system.
Important flows are hard to debug or verify, especially auth, payments, data mutation, external APIs, jobs, and error boundaries.
Attack one CI bottleneck at a time until the target is met or the bottleneck report is more valuable than another tweak.
The team is waiting on CI long enough that it changes behavior.
Reconcile what the system thinks is open against what actually happened.
Your personal operating system has accumulated stale promises, half-decisions, or outdated context.
Convert high-signal sources into grounded ideas without auto-posting like a caffeinated intern.
A strong X or YouTube source should become reusable insight and possible social material.
Prove the README works from zero, not tribal memory.
You suspect setup instructions only work for people who already know the system.
Turn recurring production errors into verified patches.
Production telemetry should become repairs, not vibes.
Rank vulnerabilities by real exposure, then fix the reachable ones first.
Scanners are noisy and you need to know what is actually reachable.
Find the real cause of flakes instead of wallpapering them with sleeps.
CI fails differently across comparable runs.
Inventory the claims before the internet does it for you.
A factual draft is about to go public.
Constrain research around the decision it needs to support.
Research should end in a decision-ready memo, not a heap of notes.
Run real scenarios until the streak proves the product is stable.
You need confidence that the product works in realistic flows.
Replace error sludge with clear recovery paths.
Your product exposes raw provider errors, stack traces, or dead-end messages.
Fix access barriers without silencing checks or weakening the standard.
A site or app needs a defined accessibility target and repeatable testing.
Reduce first-load bytes without breaking the first impression.
A web app ships too much before showing anything useful.
Refactor against a written rubric, not taste fumes.
A refactor matters, but “make architecture better” is too vague.
Separate builder and critic so “looks good to me” means something.
One model built the change and should not grade its own homework.
Maintain an evidence-backed story of what matters and what is unfinished.
Work spans repos, notes, goals, and people.
Make product claims survive contact with reality.
Marketing, docs, demos, and support answers may promise more than the product can prove.
Map priority questions to answer-ready pages.
You need search engines and AI answer engines to understand the site.
Change one variable per week and let useful audience behavior decide.
You want a repeatable content format and need audience evidence.
Let buyer language rewrite the page where the objection appears.
Landing-page copy is missing the concern that almost stopped buyers.
Prevent the next agent from starting with amnesia and bravado.
Long-running agent work crosses sessions, tools, repos, or humans.
Check the harness before blaming the model.
Agent setup depends on CLIs, MCP servers, browsers, tokens, local models, and cron jobs.
Find where the API contract forked and bring every consumer back to one truth.
Backend, frontend, docs, and SDKs may describe different realities.
Mine the calendar for promises before they become social debt.
Meetings create obligations that never make it into a task system.
Keep the case moving until the money lands or the wall is real.
A refund or support claim will take multiple conversations and deadlines.
Hire loops like employees: for recurring work with clear outcomes.
You have lots of automation ideas and need to decide which loop deserves oxygen.
Pin the target with executable scenarios before the agent starts changing code.
A coding agent is about to implement a feature where success could be interpreted three different ways.
Turn inbox sludge into a small list of decisions, drafts, and explicit no-actions.
Email, DMs, or comments are creating invisible obligations and context switching.
Give the agent an oracle, not a pep talk.
You need a coding agent to implement complex behavior that can be checked against a browser, official library, legacy system, API, compiler, or production output.
Turn one agent run into better future agent runs.
A coding agent just learned something about the repo, test harness, edge case, command, or convention that future sessions should not relearn the expensive way.
Make the agent split the work before it starts swinging a hammer.
The request is too large or vague for a single coding-agent prompt but not large enough to justify a full project plan ceremony.
Use tests as the prompt, one behavior at a time.
A pricing rule, validator, parser, permissions rule, workflow state machine, or other logic-heavy feature could balloon if implemented all at once.
Make the agent earn the fix before touching code.
A failure has logs, screenshots, stack traces, recent commits, or user reports, but the cause is not obvious yet.
Show the agent the page, not just the code.
The frontend technically works but looks wrong, drifts from design intent, or breaks at specific viewport sizes.
Give stateless agents a project spine.
Agent work spans multiple sessions, contributors, or tools and context keeps getting rebuilt from scratch.
Let the agent run wild somewhere boring.
You want a coding agent to iterate freely, but the command surface, repo contents, or prompt-injection risk makes direct host execution unsafe.
Run more agents, but keep their blast radiuses separate.
You have multiple independent coding tasks and the human bottleneck is orchestration, not implementation speed.
Separate useful agent output from merge-shaped confetti.
Agent throughput created more branches than a human can safely review from memory.
Make the agent promise completion against explicit evidence, not vibes and a cheerful summary.
A coding agent keeps declaring work done after the easy part, or a feature has multiple acceptance criteria that must be proven before handoff.
Turn internal change lists into release notes that match the product users can touch.
Release notes are being drafted from PR titles, tickets, or internal updates and may overstate what users actually get.
Treat prompts like code: keep a small regression set before tuning the clever wording.
A prompt, system instruction, tool policy, or model setting change could silently break workflows that used to work.
Turn messy meeting records into owned next actions without inventing commitments.
A meeting transcript, chat log, or call note contains promises and decisions that could disappear into the transcript graveyard.
Retire stale flags before yesterday's rollout logic becomes tomorrow's haunted house.
Feature flags, experiments, or kill switches have outlived their rollout and are making code paths harder to reason about.
Make the database change prove itself somewhere safer than the real thing.
A schema change, backfill, cleanup script, or bulk edit could corrupt data, lock tables, or surprise users if run directly in production.
Turn one dense source into a small, traceable distribution kit instead of posting chopped-up leftovers.
A valuable longform source should become multiple useful public artifacts without flattening nuance or leaking private context.
Turn incident noise into a usable timeline before the story hardens into folklore.
An outage, degraded workflow, or operational scare has evidence scattered across alerts, logs, chats, dashboards, and human memory.
Package customer evidence into useful proof without laundering private details into public copy.
A promising customer story, testimonial, support win, or product result could become marketing proof but contains private context or unsupported claims.
Test the retrieval chain before polished nonsense reaches users.
A chatbot, agent, search page, or knowledge workflow answers from docs and could sound confident while grounded in the wrong source.
Make the agent show its hands before it touches reality.
An automation can send, post, delete, buy, invite, merge, schedule, unsubscribe, or change account, product, customer, or repo state.
Turn scattered security facts into a reusable response packet without improvising compliance poetry.
A prospect, partner, or platform asks for security, privacy, compliance, or infrastructure details and the answer could overpromise or expose sensitive internals.
Catch quiet AI behavior drift before users become the monitoring system. They charge more.
A production AI workflow can change behavior because the model, prompt, tool results, retrieval index, or upstream data shifted under it.
Turn unreliable webhook mysteries into replayable fixtures before touching live traffic.
An integration bug depends on third-party webhook payloads, retry timing, signatures, or idempotency behavior that is hard to reproduce from normal tests.
Compress scattered context into a source-backed brief so the human shows up oriented, not archaeology-adjacent.
A meeting or update matters enough that walking in cold would waste the room or create avoidable relationship debt.
Turn blurry bug reports into a small, executable evidence packet before anyone starts spelunking.
A bug report has real signal but is missing the exact steps, inputs, logs, screenshots, account state, or acceptance test an engineer needs to act without guessing.
Convert repeated confusion into one reusable answer instead of playing inbox whack-a-mole with nicer fonts.
People keep asking the same product, pricing, setup, troubleshooting, or workflow question and the answer is scattered across notes, docs, Slack, or someone's head.
Shrink the blast radius before the integration becomes load-bearing and mysteriously sacred.
A tool, plugin, OAuth app, API key, or agent workflow asks for broad access and nobody has proven which permissions are actually needed.
Turn fragile analyst archaeology into a repeatable pipeline with receipts.
A one-off notebook, spreadsheet, SQL query, or script has become a recurring report or decision workflow.
A bounded loop for when contacts, stages, and follow-ups decay after busy weeks.
Contacts, stages, and follow-ups decay after busy weeks.
Find hard-coded style values that should be tokens, replace one cluster per round, and stop only when token usage, component examples, and screenshots agree.
Product screens still ship hard-coded colors, spacing, type, or radii that ignore the token file, so the design system and the live UI disagree.
A bounded loop for when repeated support answers should become product fixes, macros, or docs.
Repeated support answers should become product fixes, macros, or docs.
A bounded loop for when agent runs consume meaningful tokens without clear ROI.
Agent runs consume meaningful tokens without clear ROI.
Scheduled rank-KPI SEO loop: one experiment per cycle, measure next tick, undo losers.
You want search (and LLM/GEO) visibility to climb over months without hiring an agency, and you can give an agent read access to rank data plus write access to a small content surface.
Ads loop: generate copy variants, spend enough for signal, kill losers, scale winners.
Paid search or social ads are running and performance is flat, and you need a disciplined cut-losers / double-winners loop without letting the agent freely blow budget.
Turn feedback + analytics into one measured product change per cycle; keep bugs separate.
Customer feedback and product telemetry are piling up, but shipping is driven by loudest request instead of a measured build-learn cycle.
No loops match that filter. Either you found a gap, or search is being dramatic.