I build the agent teams behind this work, and the loop that improves them

I am rebuilding a team I used to run

At PingPong the website was a human operation. Webflow, and around it a product marketing manager, a product manager, a content manager, a designer and a content writer, all working the same page. Then the review: the marketing team ran several sprints where every person reviewed at least their own page, wrote up their feedback, and we discussed what to implement before anything changed. It was systematic and it worked. It was also slow, and it consumed most of a team.

At ThinkingAI I own website operations, inbound campaigns and the tech stack at the same time, so that shape was never going to fit. What I did instead was take the collaboration apart: every seat in that old room became an agent with its own context, its own skills, and its own to-do list, and the sprint review became a review loop. The systems below are that decomposition, and a new page now comes out of it in a few hours.

A catalog of 30+ modules, and agents that pick from it

The first phase of the site work was inventory. I built more than 30 reusable module templates, and each one declares its own constraints: which scenarios it suits, where it belongs on a page, roughly how much text each section holds, and the image dimensions it expects. That turns layout into a catalog an agent can choose from instead of a blank canvas it has to invent against.

A page run then works the way the old team did. The product marketing agent carries the product-capability knowledge base as its context. The writer agent carries brand tone of voice and the writing skills, held as system prompts. A UI/UX agent decides which module each block of content actually needs and picks the scheme from the catalog. The designer is its own sub-team: a visual instruction goes out, an image tool generates the asset, Claude Code inspects what came back, and an agent composites the HTML overlay when the module calls for one. An assembly agent puts the page together at the end.

The loop that proposes fixes to the team's own rules

This loop's job is making the team better. It attributes every score deduction to a single root cause and splits them honestly: instruction, context, and rubric defects are fixable; missing inputs, human decisions, and inherent tradeoffs are left alone. Concrete diffs are proposed only for the fixable kind, then an adversarial guardrail interrogates each one: real defect or score-gaming, does it generalize, what are the side effects. Survivors become a proposal for human review. Nothing auto-applies.

A quieter kind of improvement runs alongside it. Each page run has checkpoints where an agent can write back what it learned, so the skills and knowledge an individual agent needed on this page persist into its long-term memory for the next one. The meta-optimizer changes the team's rules through a human gate. This just means each agent starts the next page knowing more than it did on the last.

Raw material to published asset, images included

Five agents take source material to a live CMS entry. Product Marketing writes the guideline, outline, and image spec; the Writer drafts under hard de-AI rules; a Reviewer scores each piece through a dual-lens gate and leaves a record. Then the Designer generates the 16:9 cover via Volcano Ark Seedream 4.0, and Assembly builds the Sanity document and publishes it through the HTTP mutation API.