Loop Engineering: AI Loops That Ship PRs, Handle Support & Optimize SEO

Yesterday, AI Jason dropped a video after spending 30+ hours building these things in production. The title was something like “After spent 30+ hrs building loops…” and honestly? It might be the most useful 20 minutes of AI content I’ve watched this year.

If your current relationship with AI looks like this:

“Hey Claude, fix this bug.”
pastes error
“But the tests broke.”
pastes new error
“Now the whole page is on fire.”
existential crisis

…then Loop Engineering is the intervention you didn’t know you needed.

Instead of playing prompt ping-pong until your soul leaves your body, you engineer loops — autonomous agents that wake up on their own (cron, webhook, or another agent’s signal), do real work, write structured findings into shared memory, and feed the next loop. Multiple loops share the same folders, so insights actually compound instead of dying in separate chat windows.

It’s less “magic AI” and more “well-architected automation with LLMs as the workers.”

The Four Ingredients of a Loop (According to Someone Who Actually Shipped It)

Jason distilled his production setup into four things. The open-source template he released makes the middle two almost plug-and-play:

1. Triggers
   Cron every 30 minutes for support. Webhook on new incident. Another loop finishing and dropping a signal. Simple event-driven stuff we already know from DevOps.

2. Shared Memory Layer (the real magic)
   Not a fancy vector database. Just disciplined folders with schemas:

   • signals/ or artifacts/ — structured findings, bugs, ideas, customer friction (each folder has a README defining the schema)
   • domains/<loop-name>/ — loop-specific contracts and outputs
   • LOG.md — append-only global timeline (one line per batch of work, with ## Timeline sections)
   • ARCHITECTURE.md + CLAUDE.md — the “constitution” every agent reads on startup

3. Tools & Skills
   Pre-built connectors for Zendesk, Stripe, Playwright, etc. The template even includes a ship-change.js workflow that handles git worktrees, implementation, verification, and PR creation.

4. Codebase Harness (this is the DevOps bit I geeked out over)
   Make your repo:

   • Legible — good docs so agents aren’t guessing
   • Executable — one-command local dev setup with worktrees
   • Verifiable — E2E tests + a dedicated read-only verifier agent that reviews before any PR is opened

   Sound familiar? It’s basically “treat your AI agents like you treat production deploys.”

Real Loops That Actually Run

From the video and template:

• Support Loop: Wakes up, grabs new tickets, drafts replies, extracts friction points and feature ideas as signals, and can hand clear bugs off to a coding agent.
• SEO/Content Loop: Generates and optimizes based on performance data + signals from other loops.
• Product & Growth Loops: Prioritize from the shared signals folder.

Because everything writes to the same structured folders, a growth loop can “read” what support is seeing without anyone manually copying notes into Notion. It’s compounding intelligence, not just task automation.

The Humour (and Slight Terror) of Autonomous Agents

My favourite mental model from this: a team of very diligent AI interns who never sleep, communicate only through a shared folder system that would make a librarian proud, and have a strict “show your work to the quiet verifier kid before touching main” policy.

The funniest (and most important) part? Jason is very clear: don’t let agents self-verify. Have a separate verifier. This is the same lesson we learned in DevOps the hard way — you need guardrails, observability, and separation of duties.

It’s also why the template leans so hard on git worktrees, E2E tests, and PR checks. Because nothing ruins your week like an overconfident agent deciding your entire authentication flow needed “a little refactor.”

What This Means for Actual DevOps & Automation People

This isn’t just “cool AI stuff.” This is infrastructure for knowledge work.

• We’re moving from deploying applications to deploying agent factories.
• State lives in git + structured files instead of just databases.
• CI/CD principles now apply to ideas, bug fixes, and content — not just code.
• Observability (that LOG.md timeline) becomes table stakes.

If you already think in terms of operators, workflows, or even well-structured GitHub Actions, this pattern will feel surprisingly natural. The LLM is just another (very powerful) worker in the pipeline.

Practical First Steps (Steal This)

1. Clone the template: https://github.com/JayZeeDesign/loop-engineer-template
2. Fill in CLAUDE.md (replace all the {{PLACEHOLDER}} bits — this is the agent’s main context)
3. Read ARCHITECTURE.md so you understand the memory model
4. Run /new-loop (or equivalent) to scaffold your first small domain — maybe a personal “daily signals digest” or internal support helper
5. Test manually a few times before turning on any cron jobs
6. Build the harness on a real repo early. Future you will thank present you.

Start small. One loop. One clear contract. Good logging. Then expand.

Lessons I’m Stealing for My Own Automation

• Structure and schemas beat clever prompting every single time.
• Shared memory across loops is the killer feature. Isolated agents are just fancy scripts.
• Verification gates are non-negotiable if you ever want to sleep again.
• Logging isn’t optional — it’s how the “collective brain” actually forms.
• This still needs humans in the loop for the hard decisions. The goal is to remove the soul-crushing repetition, not the interesting work.

Final Thought

Moving from “chat with a very smart autocomplete” to “engineer self-improving loops of agents” feels like the real moment AI stops being a toy and starts being infrastructure. And like every good DevOps practice, the boring, well-architected version wins.

Jason’s video and template are generous. Whether you’re already deep in AI agent building or just exhausted by repetitive prompting, this is worth your time.

Watch the video: https://www.youtube.com/watch?v=W6x-hb44C0c
Grab the template: https://github.com/JayZeeDesign/loop-engineer-template

Until next time — may your agents be autonomous, your loops actually compound, and your production deploys stay boring.

P.S. Yes, I cloned the template the same day. No, I have not let it touch anything important yet. Baby steps and strong harnesses, people. 😏