How I work

The RECL loop

Requirements, Execute, Check, Loop. It is the cycle I run on every project, and the reason agent speed does not turn into agent chaos.

1. 1

   Requirements

   I write down what the thing has to do, in plain language, before any code. A short PRD, an AGENTS file, a task list. The clearer the requirements, the less the agent has to guess.

2. 2

   Execute

   I let the agent build against those requirements, and I stay in the loop. I read the diff and steer rather than accept whatever comes back.

3. 3

   Check

   Every change is checked against a test. Pytest for the Python projects and Vitest for the TypeScript ones, with cached fixtures and recorded payloads so the checks run in CI without a live service. If it is not tested, it is not done.

4. 4

   Loop

   Then I loop. Refine the requirements, run it again, tighten the tests, until the result holds. The loop is short on purpose.

The vocabulary, mapped

The field has picked up a vocabulary for all of this. None of it is new to the loop. Here is where each piece actually lives.

Prompt engineering

The Requirements step is prompt engineering by another name. Before any code I write down what the thing has to do: a short PRD, an AGENTS file, a task list. The clearer the instruction, the less the agent has to guess.

Context engineering

An agent is only as good as what it can see. I curate that context on purpose: repo conventions in an AGENTS file, cached fixtures and recorded payloads for the tests, and pointers to the real docs when the model's training is stale. This site's AGENTS file opens by warning the agent that it is not the Next.js it knows, and telling it to read the docs first.

Loop engineering

The loop itself is the design. I keep each cycle short: refine the requirements, run it, check against a test, tighten. Errors surface in minutes instead of after a thousand-line diff. Short loops are what keep agent speed from turning into agent chaos.

Orchestration

On a task bigger than one context, I do not drive a single agent. I split the work across specialized agents and subagents, each with its own scope, and keep them coordinated against shared requirements and the same tests. The loop is what holds the pieces together.

Model-agnostic

The method does not depend on any one model. Requirements, tests, and short loops travel across tools. The projects on this site were built with Claude, this redesign with Codex, and lately I reach for Grok as often as not. When a better model arrives, the process absorbs it instead of breaking.

What keeps it durable