The Core Engineering Loop
A six-step loop for any coding task: clarify, check, choose, execute, verify, recommend.
CATALOG NO. 001 · JULY 2026 EDITION
Field-tested loops, goals, workflows, and prompts. Look one up, copy it, paste it into Claude Code, Cursor, or Codex. No account, no theory, no fluff.
Three routes into the catalog
157 entries in the catalog
A six-step loop for any coding task: clarify, check, choose, execute, verify, recommend.
Make the agent build, run, diagnose, and retry until there's real passing evidence, not a hunch.
Make the agent name exactly what's unclear and stop, instead of guessing silently and building on it.
Get one honest, out-of-the-box improvement idea alongside routine execution, without derailing the task.
Classify a new build into a size tier before scaffolding, so you don't over- or under-build it.
Collect small pending decisions during a long task and approve them together at one checkpoint.
Log every real technical decision so it never gets silently relitigated by a future session.
Make the agent tear apart its own diff like a hostile senior reviewer before you ship it.
Before adding any new dependency or service, check for an existing alternative and the real cost first.
Build UI leaf-first: components, then composites, then pages, routing, state, and API.
Refuse any bug fix until a test reproduces the bug, so the fix is proven, not vibes.
Optimize against a stated numeric budget with median-of-5 measurements, reverting any change that doesn't move them.
Rewrite thin skill descriptions so agents actually reach for them instead of silently ignoring them.
Study a reference codebase once, then extract its patterns into a reusable skill instead of re-reading it.
Pack the full codebase into one file before closing a session, so the next agent inherits real code.
Cut an oversized task into ordered slices and execute only the first, with the rest explicitly deferred.
Force an explicit preset-vs-custom decision before scaffolding a new project.
Open every session by placing today's task inside the bigger roadmap, not as an isolated request.
Force one clear recommendation with a one-line tradeoff instead of a noncommittal list of options.
Force one hypothesis at a time against real evidence, so the AI stops guess-and-check fixing.
Score AI-generated code against a checklist and keep iterating until every item passes.
Don't accept 'fixed it' from an AI agent until it re-runs the exact failing case and shows real output.
Have a second, fresh-context pass try to prove the first agent's fix is wrong before you trust it.
List every assumption behind a bug theory and mark each confirmed, unconfirmed, or false.
A standing rule that blocks an AI agent from claiming a fix works without pasting real output.
Turn a fixed bug into a structured postmortem so the same class of bug doesn't ship again.
Pin down which single dependency bump in a multi-package upgrade actually broke the app.
Force the AI to parse the exact error text and stack trace before it's allowed to guess a cause.
Re-run a failing test enough times to tell a real regression from noise before you touch any code.
Automate git bisect with a real pass/fail check so the agent finds the exact breaking commit.
Compare logs from a working run and a broken run side by side to find where behavior splits.
A standing rule: one change per run while debugging, predict before you edit, revert what didn't help.
Binary search a broken data flow with tagged log probes to find the exact step where the value goes wrong.
Cut a failing case down until every remaining line is load-bearing and the bug has nowhere left to hide.
Scan a codebase area for swallowed errors and ignored rejections that hide real bugs.
Run before closing any coding session so nothing sits uncommitted overnight.
Confirm build, routes, and diff are clean before you push to production.
Write a handoff so the next session or teammate starts working in minutes, not re-explaining.
Classify every red CI run as code, flake, or infra, then fix or retry with proof until the branch is green.
Force a recoverability check before any delete, drop, or force-push touches real state.
Reconcile every env var across code, .env.example, and your deploy platform until nothing is unaccounted for.
Sweep every worktree before touching any of them, and label each safe or risky.
Find every dev server, stray node process, and container squatting on your ports before you debug the wrong app.
End every task with what changed, what's verified, what's risky, and one clear next move.
Stop an agent from pushing or merging without your explicit go-ahead, every time.
Maintain one HANDOFF.md that survives across sessions: phase, ports, decisions log.
Before you deploy, confirm you can actually roll back, not just that the deploy itself is clean.
Decide every third-party service a new build needs before wiring any of them ad hoc.
Classify a task's complexity first, then gate execution behind your approval so agents stop over- or under-building.
Feed a one-line idea in, get a real PRD out: problem, goals, non-goals, stories, P0/P1/P2.
Expand a one-liner into success criteria and a verify step so the agent can loop without you babysitting it.
Log every silent planning assumption in a ledger and force confirmation before you build on it.
Run the backlog through the spec's original goals and cut what doesn't serve any of them.
Batch every clarifying question into one list instead of guessing or asking one at a time.
Force a tier re-classification every time a new requirement lands mid-build, catching drift early.
Turn a flat feature list into a dependency-ordered build sequence before assigning sprints.
Decide if this ships an API or MCP surface before you scope it; that decision changes the build.
Log estimate vs actual per finished ticket, compute a drift factor, and re-plan when the milestone math breaks.
Answer four questions before you scaffold anything, so the build starts pointed at the right target.
Assume the project failed, name the killers, patch the plan, repeat until a fresh pre-mortem finds nothing new.
Split a locked spec into sized tickets with acceptance criteria instead of one vague epic.
Force two rival plans, cheapest and most thorough, then make the agent attack both before you pick one.
Run an independent challenge-and-build panel, falsify its lead plan, then execute the smallest proven move.
Turn messy notes into a publish-ready blog post or landing page section in one pass.
Turn a short project brief into a structured client proposal or RFP response draft.
Edit AI-generated copy to cut filler, hedging, and generic AI phrasing without losing meaning.
Convert an exec summary into a technical deep-dive (or the reverse) without rewriting from scratch.
Flag every vague claim in a draft that has no real example backing it, then fill or cut it.
Catch every fact, number, or quote a draft invented that isn't actually in your source material.
Get headline options that hook a specific reader trigger, ranked, not ten flavors of the same idea.
Turn a messy recorded-conversation transcript into a structured Q&A or narrative article.
Fix the first two sentences that make readers bounce before the actual point shows up.
Verify every command, path, and claim in your README against the actual repo, then fix what drifted.
Turn the commits since your last release into human release notes, every line tied to a real commit.
Turn one long-form post into a thread, a LinkedIn post, and an email blurb, not chopped-up excerpts.
Loop hostile-reader objections against your draft, patch the real ones, repeat until it survives a clean pass.
Meet a hard word or character maximum by cutting weak sentences first, not shrinking every sentence a little.
Loop section by section against a reference paragraph until a long doc reads like one writer wrote it.
Give the agent a checklist of AI-slop tells and make it revise its own UI until it passes.
Feed it three colors and a vibe, get back a concrete palette, type scale, and spacing scale to reuse everywhere.
Force your AI to describe the mockup and wait for your yes before touching production UI.
Check every custom select, toggle, and combobox for a real accessible name before you ship it.
Loop through every interactive component and force it to have every state it needs.
Walk every page in both themes and catch the contrast failures light mode was hiding.
Compare your UI with a reference screenshot, name material gaps, and verify any approved changes.
Hunt every hardcoded hex and px that bypasses your tokens, replace it, and prove drift is zero with grep.
Turn every '0 results' screen in the app into a state that explains, guides, and invites action.
Run automated and manual a11y checks, fix only the highest-impact blocker, then prove it.
Screenshot every affected route before and after, then loop until the styling refactor changes zero pixels.
Break every breakpoint with the ugliest real content you have before calling a layout responsive.
Measure tap targets in an agreed mobile route/state scope, fix confirmed misses, and show a before/after table.
Build a clean llms.txt index so AI answer engines cite your site accurately.
Feed it a page's content, get back valid JSON-LD structured data ready to embed.
Audit a landing page's indexability and long-tail targeting, get a prioritized fix list.
Assess which sentences are clear, query-relevant, and supportable enough to be useful to answer engines.
Decide which AI bots to allow or block in robots.txt, with reasoning per bot.
Sweep the codebase for internal links that 404 or hit redirects, fix them, re-verify until zero remain.
Cluster near-duplicate pages, pick one canonical each, and stop them competing.
Diagnose why specific pages are sliding in traffic before you spend time rewriting them.
Turn a failing Core Web Vitals report into a confirmed root cause and a shipped fix.
Find conflicting descriptions across the organization surfaces you provide and propose one canonical record.
Turn scattered support answers into a publishable FAQ page with FAQPage schema.
Find orphaned pages and thin topic clusters your internal links never reach.
Find topics competitors cover that you don't, then rank editorial opportunities with the supplied evidence.
Batch-write unique, click-worthy meta descriptions for dozens of pages at once.
Map every old URL to its new home, then loop until there are no chains, loops, or lazy homepage dumps.
Give it your JSON-LD plus the validator's error output, get back a corrected block.
Turn a flat URL list into a segmented sitemap with accurate canonical URLs and lastmod values.
Run a fixed evidence-backed query set across AI search surfaces and log citations without inventing a rank.
Build the real locale clusters, repair invalid or non-reciprocal hreflang, and rescan every variant.
Compare raw HTML, browser DOM, and search rendering, then fix only search-critical JavaScript gaps.
Verify that useful images and video are crawlable, contextual, accessible, and consistent with visible metadata.
Replace generic claims with real tests, data, examples, or expert evidence, and verify the full page again.
Decide if an SEO change is testable, then lock cohorts, metrics, safety rules, and verdicts before launch.
Gate a programmatic page system on real user value, source accuracy, boundary cases, and doorway risk.
Turn query-and-page Search Console data into an evidence-ranked action list without generic CTR benchmarks.
Trace a URL through crawl, render, canonical, and index evidence until the real controllable blocker is isolated.
Build one search brief whose user questions, factual claims, and unique contribution all trace to evidence.
Map licensing, compliance, and recent policy shifts for a product launch in one structured pass.
Scope TAM/SAM/SOM for a product idea in one pass, with every number labeled estimate or sourced.
Turn a rough audience description into grounded user segments with needs, objections, and buying triggers.
Weigh building new against buying an incumbent, with real switching costs named, not assumed.
Feed competitor pages in one at a time and build a running positioning matrix that ends in testable gap hypotheses.
Check search, forum, and workaround-tool signals for real demand before writing a line of code.
Loop scattered interview notes into ranked themes with quotes, until the same theme stops surfacing.
Filter broad macro trends down to the 2-3 that actually change your product bet.
Stress-test whether now is the right time to enter a market, or if you're early, late, or on time.
Design a one-week demand test where the kill threshold is written down before you see a single result.
Estimate a defensible price range for a new product category using proxy signals, not guesses.
Rank a plan's load-bearing assumptions, then loop cheapest-test-first until each is validated or killed.
Turn a pile of pasted reviews for an adjacent product into ranked complaints and unmet needs.
Turn a competitor's public pages into a structured pricing and feature comparison table.
A weekly check that flags only what changed on a competitor's public pages, not the whole page again.
Compare your product against competitor URLs to find the gaps worth leading with in messaging.
Re-verify every claim in your sales battlecard against competitors' live pages and flag what went stale.
Decide whether to position against the category leader by name or define a new category instead.
Classify six months of a competitor's changelog to see where they're headed before they announce it.
Mine a competitor's negative reviews for weaknesses that recur, are recent, and a buyer would switch over.
Track a competitor's open job postings over time to catch roadmap bets before they ship.
Extract the exact words competitors use to sell, so you can tell echo from real differentiation.
Map documented switching friction and separate it from customer impact that still needs validation.
Break down 2-4 competitors' pricing pages into tier structure, packaging levers, and pricing psychology.
Find who else solves this problem, including spreadsheets and manual workarounds, not just named rivals.
Turn scattered G2, Reddit, and churn-survey quotes into a ranked list of why you actually lose deals.
Expand a one-line campaign idea into a full brief an agent or agency can execute against.
Turn what you just shipped into a structured hook-problem-solution-proof-CTA launch thread.
Feed an agent your weekly metrics and get one ranked growth lever with the reasoning shown, not five vague ideas.
Feed in variant numbers, get a verdict with the math shown and a date if the answer is keep running.
Feed channel performance data and a fixed budget in, get a specific dollar allocation out.
Turn one specific ICP and a sourced pain point into a 3-email sequence that isn't generic spam.
A self-verifying loop that finds broken links, dead anchors, and untagged CTAs in your site repo and fixes them.
Score your landing page headline against a 5-check rubric, rewrite, rescore, and loop until it passes all 5.
Give it your actual activation funnel steps, get one nudge email per step, not a generic welcome series.
Give it your pricing copy and real sales objections, get told exactly which ones go unanswered.
Feed an agent cohort retention data and get one diagnosed churn point, not generic save-the-user tactics.
Feed raw support tickets or feedback dumps in, get verbatim quote-ready testimonials out.
A recurring weekly check that turns scattered organic mentions into a ranked, actionable queue.