Practitioner threads report loop-based agent workflows for coding, PR, and sales proposals

• Practitioners are moving from one-shot prompts to loops, and steipete's loop framing boiled the shift down to a blunt line: design loops that prompt agents, not prompts for agents.
• In petergyang's Kun Chen preview and petergyang's main episode post, Kun Chen's coding stack centered on three separate layers: visual planning in HTML, parallel agent orchestration, and an AI validation gate before merge.
• shannholmberg's nine-part framework and shannholmberg's eval-loop note both treated agent systems less like chat interfaces and more like scoped job roles with memory, boundaries, delegation, and checks.
• Sales and ops builders are applying the same pattern outside software, with moritzkremb's proposal workflow turning discovery calls into five-part proposals and moritzkremb's no-show workflow generating personalized pre-call video scripts from CRM and calendar data.
• The same loop logic is showing up in shipping surfaces, from aakashgupta's Codex prototype-first post to halfmage's Netlify Agent Runner note, where agents build, test, and iterate inside a context-rich environment instead of a blank chat box.

You can browse Lavish, gnhf, and No Mistakes directly, skim the Compound Engineering plugin, and compare that repo-centric harness style with Netlify's Agent Runners overview. Netlify's docs also spell out maintenance prompts and a new-project flow that bakes deployment context into the loop.

The cleanest practitioner map in this batch came from Kun Chen's setup. petergyang's post summarizing the episode described three separate tools, and the linked repos make the split concrete.

• Lavish: a local editor for agent-generated HTML artifacts, built so humans can annotate plans and send targeted feedback back into the system.
• gnhf: an orchestrator that keeps agents running in a long loop, committing each successful iteration and rolling back failed ones.
• No Mistakes: a local git proxy that runs an AI validation pipeline in an isolated worktree before forwarding a clean PR upstream.

That decomposition matters more than the 40-PR headline. Planning, execution, and validation sit in different layers, so the loop does not depend on one giant all-purpose agent.

In shannholmberg's PR-agency example, one orchestrator agent ran a PR newswire vertical against databases, pricing, prior campaigns, and comms channels, then delegated writing to a specialist agent and sent output through an eval loop plus human review. A later post turned that pattern into a nine-part checklist.

1. Context
2. Data
3. Standards
4. Tools
5. Boundaries
6. Delegation
7. Evals
8. Human review
9. Memory

That list reads like an org chart, not a prompt template. It matches the broader shift in these threads: the agent gets a role, authority, inputs, and an escalation path.

The recurring mechanic across coding, marketing, and ops was not autonomy by itself. It was autonomy with a checking layer.

petergyang's skill checklist broke that layer into repeatable parts:

• give the skill examples of good output
• write a clear trigger description
• add an evals.md file with pass or fail checks
• add a memory.md file for one-line learnings
• build a meta-skill that cleans up stale or duplicated instructions

That mirrors Kun Chen's No Mistakes pipeline and shannholmberg's PR vertical, where every written artifact runs through internal evals before a person signs off. The fashionable part of agent loops is parallelism. The durable part looks closer to QA.

A second pattern in the evidence was taking brittle one-off behavior and freezing it into reusable skills.

In petergyang's browser-use example, Codex handled platform-specific publishing quirks through browser automation alone, including Substack Notes without an API, LinkedIn tag cleanup, and Threads' 500-character cap. In aakashgupta's prototype-first post, an OpenAI PM replaced the PRD-first flow with a prototype plus a ten-question companion FAQ, then pointed Codex at the most similar existing code path instead of a whole repo.

Those posts describe different jobs, but the harness logic is the same:

• start from a known pattern, not a blank prompt
• encode edge cases once
• let the agent operate against real tools
• hand humans a concrete artifact, not an abstract intent

Outside coding, the same structure is showing up as lightweight back-office automations.

moritzkremb's proposal workflow described a system that reads a Fathom transcript, assembles five proposal sections, writes the draft into Notion, and advances the CRM stage, cutting the task from roughly 30 minutes to about one minute of run-and-review time. moritzkremb's no-show workflow used the morning calendar, CRM data, and quick prospect research to draft personalized video scripts for upcoming sales calls.

These are narrower than Kun Chen's setup, but they use the same ingredients: source data, a structured output template, and a final human pass.

The most concrete platformization in the source set came from Netlify. halfmage's post and another halfmage build treated Agent Runners as an everyday building surface, while Netlify's Agent Runners overview says the product gives agents secure access to project context, deployment pipelines, build settings, and environment variables directly from the dashboard.

Netlify's docs add two details that the tweets only hint at. The prompt examples page explicitly supports running multiple agents for routine maintenance tasks, and the new-project quickstart frames forms, Blobs, and Identity as built-in feedback loops for debugging and iteration.

That is the newest twist in this batch of practitioner posts. The loop is no longer just a personal harness living in Markdown files and shell scripts. In some products, it is becoming the interface itself.