The BrainGrid Loop
Frame. Spec. Scope. Load. Verify. Five plain verbs for shipping quality software with AI agents, in a closed loop that gets stronger every turn.
The first turn is heavy. Every turn after is momentum.
Walk one feature through it
Each stage is something you do, something BrainGrid does back, and an artifact you can point at.
1. Frame
Say what you want in plain words. Messy is fine.
You: Describe the feature, the app, or the bug the way you would tell a friend.
BrainGrid: Interrogates the idea the way a senior engineer would. Surfaces the edge cases you skipped and the decisions you have not made yet.
The feeling: Relief. The blank page is gone.
You said: "add usage limits with email alerts". Before we spec this:
1. Should quotas reset monthly, or on each customer's billing date?
2. When a user hits the limit mid-request, do we block or degrade?
3. Free tier: hard cap, or soft warning with a grace period?
Stage 1: Frame
Say what you want in plain words. Messy is fine.
You: Describe the feature, the app, or the bug the way you would tell a friend.
BrainGrid: Interrogates the idea the way a senior engineer would. Surfaces the edge cases you skipped and the decisions you have not made yet.
Stage 2: Spec
Approve what done means before any agent builds.
You: Review the requirement and acceptance criteria. Adjust anything that is not what you meant.
BrainGrid: Converts the framed idea into an engineering-grade requirement. Goals, context, architecture, edge cases, acceptance criteria. Not a wish, a contract.
Stage 3: Scope
See the build as steps, not a wall.
You: Read the build plan as a short, ordered list instead of one giant prompt.
BrainGrid: Decomposes the spec into discrete, sequenced tasks, each small enough to build right and verify cleanly. Dependencies explicit.
Stage 4: Load
You do not prompt your agent. You load it.
You: Hand the tasks to the coding agent you already use. No retyping, no context pasting.
BrainGrid: Loads each task into Claude Code, Cursor, Windsurf, Codex, or Gemini over MCP, with the context, steps, and success criteria included. Copy-paste works for Lovable and Replit.
Stage 5: Verify
Check the work against the spec, not your memory.
You: Walk the acceptance criteria. Pass it, or send it back with the context already attached.
BrainGrid: Holds every task to the criteria you approved. What you learn updates the spec, so the next turn of the loop starts from higher ground.
Then Verify feeds back into Frame. The spec persists, so the loop has memory, and every turn starts from higher ground.
Open loops drift. Closed loops compound.
Building with agents and no plan is an open-loop system: output is never checked against intent, so error compounds at machine speed. The Loop closes it. The spec defines done, verification checks against it, and what each turn teaches becomes the starting point of the next. That is the flywheel: the weight you put in the plan comes back as momentum.
Six rules of the loop
Put the weight in the plan, not in the prompt.
The first turn is the heavy one because the thinking happens before the building. Every turn after is lighter, because the plan persists and the prompts get small.
You don’t prompt your agent. You load it.
A loaded agent builds against a spec with context, steps, and success criteria. A prompted agent builds against whatever it guessed you meant.
Verify against the spec, not your memory.
Done is a claim until it is checked. Acceptance criteria make the check objective, and AI code review walks them item by item.
The agent forgets. BrainGrid doesn’t.
Agents start every session cold. The loop has memory because the spec, the decisions, and the verified ground truth live outside the conversation.
Clarity is upstream of velocity.
Speed without a plan is just drift at machine speed. The loop is how you go fast on purpose.
Structure protects the magic.
The point is not process for its own sake. It is keeping the joy of building fast without the week-three spaghetti.
The Loop, answered
How the method works and why it is a loop.
The BrainGrid Loop is a five-stage workflow for building software with AI agents: Frame, Spec, Scope, Load, Verify. You frame a rough idea, BrainGrid shapes it into an engineering-grade spec, scopes it into tasks, loads them into a coding agent over MCP or builds them itself, and verifies the result against the acceptance criteria you approved. Then the loop turns and the next feature starts from higher ground.
