The pirate from Captain Phillips leans in and stares straight into the camera

Look at me.

I’m the captain now.

The same scene: the pirate, now labelled Closed Loop Requirements, stares straight into the camera

Look at me.

Closed loop requirements

…staring down your source code

I’m the code now.

Before we explain anything

Play it. Fly it. Click anything.

Hello world · play it

Pong

The ball runs on its own converted Blueprint. 32 nodes.

A whole game · play it

Asteroid Shooter

A real public game: 232 nodes, run on its converted Blueprints.

The messy one · fly it

Lock-On

A real public Blueprint: 162 nodes, 200 wires, 29 crossings.

Each node lights as it fires. All three fly as 3D cities in WebGPU; press Unreal 2D to see a graph the way the Blueprint editor draws it.

Then read

The worked example

How it works

The record

The AI skills

From blueprintue.com: Pong (anonymous), asteroid shooter (siljaZ), Lock-On System (hitted); authors keep the rights. Counts: TASKS.md.

How we build Blueprints this big in a day

We don’t draw Blueprints. We print them.

Someone wired Lock-On by hand, node by node: 162 nodes. Overnight we printed a whole game in production: 4,201 graphs, 67,284 nodes, 79,507 wires.

1

Read. Roslyn, the C# compiler’s own reader, takes in every line of the finished code: its meaning, not just its text.

2

Graph. Each method becomes one logic graph, and a call opens its own graph: 14,499 links, none to nowhere.

3

Print, then prove. The Blueprint is printed from the graph, and the graph prints back to the exact same code: 4,201 of 4,201.

Then the requirements hang on that same graph.

■ Lock-On, wired by hand: 1 square

The game, printed: over 415 Lock-Ons’ worth of nodes.

Counts: the Blueprint view’s build log, Wed 28 Oct (runs/graphs_build_tr2.log, REQ-BPV-7); Lock-On from FRICTION_LOCKON.md.

The big idea

Code is just one way
of writing it down.

Underneath every program is something rawer: the problems it solves, the answers it gives, and every exchange between a person and the machine. Capture all of it, with nothing left out, and code becomes a translation you pick, like a language.

That complete capture is what we call closed loop requirements.

Closed loop requirements

How to easily understand closed loop requirements

Think of a recipe so complete that a stranger cooks your exact dish, and every “what if” is written down: out of eggs? oven runs hot? Nothing is left to guess.

1

Take a finished program

One that already works.

2

Tie each line to a story step

Who does what, and why.

3

Read the story in order

Step by step, every side path too.

4

Every gap is a question

Asked out loud, never guessed.

5

The loop closes

Every question answered, or handed to its owner.

Closed loop, measured

Every requirement carries a check, or the reason it can’t yet

Each requirement is judged by one question: what mistake can still get past it? 35 of 43 now carry a check that can fail. The other 8 carry a written reason: calls only the author can make.

Effect

What the code must set, call, branch on or read, and where.

Terms

Each word bound to a name in the code, so nothing reads two ways.

Lock

A fingerprint as last verified. Edit the requirement, or the line it reads, and it comes back stale.

On the public Blueprint

84 of 84 hold

checks from the 25 requirements read from the code

13 fail

checks from 10 of the owner’s questions: the defects

97 of 97

planted faults caught

“Lock-On System” (hitted, blueprintue.com). The loop is still open: 18 questions only its author can answer.

Why this matters for AI

Nobody types “build GTA 6” and gets GTA 6

A prompt

Build GTA 6.

Which city? Whose rules? What happens when the car hits the wall? Every answer the AI invents is a guess.

A closed loop

Every step of every story, in order

Every “what if”, answered or handed to its owner

A check the AI’s work must pass, wherever one can be written

A prompt is a wish. The loop is the instructions the AI acts on.

How the loop closes

The holy grail of a prompt: nothing left to guess

“Did I think of every requirement?” has no answer: what you forgot leaves no trace. “Is the question queue empty?” does. interrogate.py walks every use case, turns each hole in the chain into a question that names its line, and stays red until none is left.

Find the hole

A step that needs what nobody wrote, a source rule no requirement cites, a pathway with no requirement, a module missing its who, why or when.

Ask, never guess

Each hole is answered by a written requirement or handed to its owner. An invented answer is not one of the options.

Close the loop

Its partner, usecase_kg.py, holds every requirement to 13 criteria and locks it: change the code or the requirement and it comes back stale.

Measured

37 questions

open today on this prototype’s own model (245 steps, 94 pathways): red until each is answered

7 of 7

inferred requirements checked on a game in development were real bugs

0 holes of ours

on the Lock-On Blueprint: its 18 open questions belong to its author

Both tools are open source (autobot/ in the prototype’s repository). No loop has closed yet: each sample waits on its author.

Trust, checked outside the model

The model proposes. Something outside it decides.

What an LLM is for

English: reading, writing, explaining

Brainstorming: options, questions, drafts

Never the verdict on its own work

Its reasoning goes to a file and is held to something it cannot talk its way past: a parser, a test, a game’s own referee. Plain code on a CPU, not a second model.

Where it was learned: ARC-AGI-3

0.02 → 0.23

public score on ARC-AGI-3’s interactive puzzle games, version 13 to version 48, every one scored by the games, never by the model

1 of 37 → 0 of 37

a headline gain an audit outside the model took back: it accepted no verdict without a mutation test

6 of 6, yet 9 of 18

Claude’s logged reasoning on the Lock-On Blueprint: every claim held against the graph, and it still missed half the owner’s questions

ARC-AGI-3 work May to July 2026, Kaggle public leaderboard. Lock-On chain CH-1, 28 October, checked by chain_check.py.

Take away the syntax. Three things are left.

Problems

What hurts, and why someone came to the software at all.

Solutions

What the system does about each problem, and when.

Interactions

Every back and forth between a person and the machine.

Written down as

User stories

Use case descriptions

Class diagrams of the concepts

That is the new raw element. Every language is now an interpreted one.

One source. Every view.

The loop

requirements and one logic graph

Blueprint

C#

C++

Pseudo-code

3D city

92 of 92

Unreal Engine’s own template Blueprints turned into C# and pseudo-code, none failed. The C++ view still marks 11% as C#.

4,201 of 4,201

Methods of a game in production drawn as node graphs, each one printed back to its exact source.

1,270 of 1,270

Methods of a second game, a 2011 XNA title, through the same reader.

Counted by the converter’s round-trip check: Unreal 5.7.1’s own templates, our production game, and a 2011 XNA game.

Ripley from Aliens looks down, making up her mind

I say we take off and nuke Blueprints from orbit.
It’s the only way to be sure.

Kidding

We keep Blueprints.

Whole teams build games with them, and for small things they are wonderful. The trouble is a paradox.

The Blueprint paradox

Easy on day one. Out of control by month six.

Day 1

A tidy Blueprint: Event BeginPlay wired to Spawn Actor wired to Print String

How did something so easy get so out of control?

Built to make logic simple for non-programmers, Blueprints turn any complex system into a massive, unreadable grid.

Both pictures are illustrations in the editor’s style, not a real project.

Month 6

The same Blueprint grown into spaghetti: dozens of nodes, wires crossing everywhere, a comment box reading DO NOT TOUCH, works somehow
Ron Burgundy from Anchorman stares into the camera

Well…

One public 162-node Blueprint: 200 wires, 29 crossings.

That escalated quickly.

The Blueprint paradox, in three frictions

Why Blueprints hurt

1

Too many lines.

Wires everywhere, until nobody can see the logic.

2

The objects go missing.

Object-oriented underneath, procedural on screen.

3

Forcing objects in is worse.

A strict object graph buries you in pipes and gates.

Where our numbers come from

We picked a messy Blueprint on purpose

Real, public, and not ours

Someone published it on blueprintue.com to share it. We did not write it, tidy it, or go looking for a flattering one.

Small enough to read, big enough to tangle

A lock-on targeting system for Unreal Engine 5.0: 162 nodes spread over 12 graphs.

Counted, never typed

Every Blueprint number in this deck is produced by our tools from the pasted text, which they re-read from the published page.

Why this one

If the tools can read a stranger’s messy Blueprint, they can read yours.

The game numbers come from our own game in production: 4,201 methods and six recorded battles.

Sample: “Lock-On System” by hitted, blueprintue.com/blueprint/kg2evmas. The pasted text stays the author’s; we keep only our counts.

Friction 1 · Too many lines

The visual clutter of Blueprints

The spaghetti wire effect

Text reads top to bottom. A Blueprint drags each value across the screen, so one shared variable cuts through everything else.

Zoom blindness

Zoom out to see the shape and you can’t read a node. Zoom in to fix one and the shape is gone.

Two kinds of wire, one screen

White wires say what happens next. Coloured wires carry values. They cross, and you have to track both at once.

Measured on a real Blueprint

200 wires

82 for order, 118 for values

29 crossings

17 of them an order wire over a value wire

2,736 × 2,160

units of canvas to pan for one event graph

Sample: “Lock-On System” by hitted, published on blueprintue.com (Unreal Engine 5.0, 162 nodes). Counts read from the author’s own layout.

Friction 2 · The objects go missing

Objects underneath, procedures on screen

The hierarchy hides

A child Blueprint inherits everything from its parent, yet its graph opens blank. Reaching the parent takes a special node.

No encapsulation

Text code hides a fifteen-step routine behind one line, TakeDamage(10). In Blueprints it gets copy-pasted, node for node.

The Cast To trap

Instead of one clean interface call, every use starts with a Cast To roadblock in the middle of the graph.

Measured on a real Blueprint

0 parents

named anywhere in the pasted Blueprints

4 Cast Tos

each testing an actor’s class before using it

1 rule, twice

a six-node chain copy-pasted, plus 3 variables written from several graphs

Sample: “Lock-On System” by hitted, published on blueprintue.com (Unreal Engine 5.0, 162 nodes).

Friction 3 · Forcing objects in is worse

Why a pure object graph fails people

The grid problem

Player.Weapon.Stats.Damage is one line of text. Drawn as boxes inside boxes, it is a map you have to travel.

Invisible relationships

Draw every child-to-parent link as a pipe and the screen turns into a matrix of lines.

Encapsulation gates

Showing Health on screen would take a reference, a getter and a gate, each one a node to wire by hand.

Measured on a real Blueprint

12 graphs

spread over 4 pasted texts, one variable written in 4 of them

5 calls

made by a function name typed in a string, which the editor can’t follow

43 of 162

nodes are only variable reads and math

Sample: “Lock-On System” by hitted, published on blueprintue.com (Unreal Engine 5.0, 162 nodes).

What is easy?

Visual programming misread what makes things easy

The bet

Pictures are easier than words

So draw the code: boxes and wires instead of text. It works, for three nodes.

How people understand

We see pictures. We understand stories.

Who wants what, what happens next, and what if it goes wrong.

A wiring diagram is a picture with no story. That is why it stops being easy.

Back to the cave

We have understood in stories since the cave

UC-1 Hunt the bison

Actor: the hunters

Goal: feed the tribe

1. Track the herd to the river.

2. Circle one bison.

3. Strike together.

2a. Herd stampedes: climb, wait.

A use case is that same story: an actor, a goal, steps in order, and every “what if”. That is why the loop is built on them.

The fix

Three ideas, working together

1 · The source

Closed loop requirements

One complete description that every language and every picture is drawn from.

2 · The shape

Human ergonomics

Logic arranged the way a mind holds it: parent and child, one step after another.

3 · The motion

Observational understanding

A system that keeps running, so you learn it by watching it, not by reading it.

Idea 2 · Human ergonomics

Shaped for the way people think

Analogies you already know. A class is a district in a city. Its parent class is the floor it stands on.

Parent and child. A big idea breaks into smaller ones you open one at a time.

In a line. Steps read in order, like a story, never as a web of wires.

Order runs up here

Values run down here

The child class: one district

The parent class: the floor it stands on

0 long wires

across six or more steps, where a one-to-one drawing of the game’s core had 2,343

Never cross

order pipes run above the nodes and value pipes below, by construction

Folded in

variable reads and math become words in a line, not nodes to wire

Counted by the layout check over every graph of our game’s core code.

Idea 3 · Observational understanding

Learn it by watching it run

Watch it run

Pulses travel the pipes. Heavy values flow thick, simple ones trickle. Two lock-on functions fire 100 times a second, and here they glow red.

Rewind it

Every path replays step by step: all 54 in the sample. On our game, scrubbing found a deliberately planted bug at its exact step: one hit, 339 to 372.

Change it mid-flight

Turn a valve to double one damage value: six battles replay with it, the slowest in 0.84 s, with no rebuild.

Try it: play Pong or the asteroid shooter and watch its own Blueprint run, each node lighting as it fires.

Game numbers: six recorded battles of our game, replayed headlessly. Sample numbers: the Lock-On Blueprint.

Proof · A public Blueprint

The loop asks what a reader misses

18 vs 9

The loop holds 18 questions only the owner can answer. An AI reasoning from the converted code alone reached 9 of them.

Some of what it flagged

The enemy writes DistanceToFrankVar. The search reads Distance to Frank Var. Two different variables.

When the locked-on target dies, the lock is never released.

Every enemy runs a line trace 100 times a second, with debug drawing left on.

Does the old target ever hear it lost the lock? The pasted graphs never say.

Sample: “Lock-On System” by hitted on blueprintue.com. 162 of 162 nodes tied; 54 paths: 48 covered, 6 excluded with a reason.

Before and after

The same Blueprint, side by side

FrictionAs publishedIn the new view
Long wires200 wires, 29 crossings0 wires across 6 or more steps
Order over values17 crossingsNone: they run on separate levels
Finding one nodePan a 2,736 × 2,160 canvasOne typed or spoken command
The hidden parentNamed nowhereRead from the code: FrankBP is a Character
Cast To4 casts1 interface, proposed (not yet applied)
Answering 10 questions1.6 million tokens of raw text9,053 tokens: 181× fewer
Every node accounted forNo link to any requirement162 of 162 tied to a requirement

Measured by the tools on “Lock-On System” (hitted, blueprintue.com). Not yet measured with people: that is the next step.

One more, chosen for its friction

A whole enemy AI: 1,009 nodes, every friction measured

As drawn

One graph of 18,880 × 12,146 units: 1,090 wires with 174 crossings, 108 of them exec over data; branches 5 deep; a 35-statement path.

In the view

36 graphs, 629 statements; 451 nodes folded into the line that reads them; 851 wires, none spanning six statements.

On the loop

36 requirements with 236 checks, all holding and all flipping when planted; 0 holes of ours, 20 questions for its author.

Each friction, honestly

108 → 0

exec wires crossing data wires: as drawn, and in 3D, where the two kinds of pipe never share a plane

1,009 of 1,009

nodes reached by a use case step, or excluded with the reason

2 not answered

its parent class (the view refuses to guess) and changing values by watching (the paste holds no run)

“Enemy Blueprint for Antagonist Combat System” (JJ GameDesign, blueprintue.com, UE 5.3); the author keeps the rights.

The far future

Picture a program that ships as a zip file

game.zip

Inside

stories.graph

rules.graph

checks.graph

No .cpp, no .cs, no Blueprints

Unpacked by AI

and written into a running program, in real time.

Does the zip contain code? No.

It holds a graph of closed loop reasoning: the program’s raw essence, which an AI extrapolates back into the program.

Five years from now

You describe it.

The loop holds it.

You see it your way.

Blueprints, C#, C++, a city you fly through: all just views. The requirements are the program.

Where it stands today

Built, measured, and ready for people

Working now

Blueprint to code and code to graph, a five-way view, the 3D city, two games playing on their converted Blueprints, replays and valves.

Next

Developers using it for real, with friction measured before and after. So far only machines have tested it.

Then

Inside the Unreal editor as a panel, and spoken changes, not only spoken commands.

Bring us your messiest Blueprint.

A roast beef sandwich piled high with beef

Where’s the beef?

Right here.

See it run

Play Pong and an asteroid shooter, fly Lock-On and a 1,009-node enemy AI, in WebGPU

Walk the worked example

Fixing Blueprint Friction: traced node by node, each friction measured

See how friction comes out

Objects in 3D, dictation, the whole code, watching it run

Read the whole Blueprint as code

Every class, field and method of every sample

Read how it works

Closed Loop Requirements and the Blueprint View

Check the record

Use cases, requirements and gap checks behind it

Meet the skills behind it

The AI playbooks the agents worked from

From blueprintue.com: Pong (anonymous), asteroid shooter (siljaZ), Lock-On System (hitted), enemy AI (JJ GameDesign); authors keep the rights. Source: github.com/rj45Thompson/blueprint-view-source (MIT).

About this prototype

Built in under 24 hours

On top of RJ’s existing u2ue toolkit, whose gates it reuses.

Tue 19:17

RJ sets the direction: Blueprints as icing over code

Tue 23:33

Requirements written as data, gap checkers fixed

Wed 00:22

4,201 game methods drawn as graphs, round trip exact

Wed 02:00

Unreal Blueprints convert to code

Wed 10:15

A public Blueprint traced to requirements; the 3D city

Wed 11:04

The closed loop measured

A prototype, not a product. What it shows is how RJ thinks.

Long-range vision

Sees where software is going and builds toward it now.

Out of the box

Asked what is easy for a human mind, not what is easy to draw.

Problem solving

Named each friction, measured it, and answered it.

Directing AI

Steered AI agents from an idea to a measured prototype overnight.

Times are Mountain Time, 27–28 Oct 2026, from RJ’s request and the commit log. Built on the existing u2ue toolkit.

How it was built

The AI skills behind the prototype

usecase-map

Use cases from the problem story, classes from the code, never blurred.

usecase-interrogate

The gap checker: every hole in the story becomes a question, and the gate stays red until it is answered.

morph

Maps every design choice as a box of options, each present (with where) or absent (with why).

decide

Routes judgement calls through a calibrated decision matrix instead of a guess.

autonomous-worker

Works a task list on disk to the end, checking each item against evidence.

Read each one in full: The skills behind the loop

The pages themselves were laid out with Anthropic’s built-in artifact-design skill.

Where it lives

u2ue, and the code behind it

u2ue · the porting toolkit this was built on

u2ue: Unity to Unreal

The toolkit’s public page, with its whole manual on it

The toolkit’s source

Private for now: access on request

This prototype

rj45thompson.github.io/anchor-demo/blueprint

This deck, the playable demos and the documents

The prototype’s source

Open, MIT licence: github.com/rj45Thompson/blueprint-view-source

Thank you.

What this really shows

How to build large AI infrastructure that holds together

Requirements are the contract

Every node is tied to a use case step and a requirement, and every gap becomes a question for its owner. The AI acts on the closed loop, not on a prompt.

Trust lives outside the model

The model proposes; gates decide: the public gate, the commit gate, the gap checkers. 70 of 72 real-data tests pass and 0 fail; the other 2 are the slow round trips, left for the full run.

Measured like a product

Dictation was tested with a synthesized voice on the live site: 19 of 22 spoken commands heard and run. Every link is crawled signed out, and every feature is run in a real browser.

Scale without a committee

117,509 lines of toolkit and prototype. This week, 81% of the tokens went through one writing session and 99.4% of what it read came from cache; helpers took only separate lanes.

AI makes the work faster, not easier. It adds no fun to a game, and often takes it away. What it gives back is time for the real art: what we build and why, not how.

Why more than one way in

Different minds need different doors

Minds differ

Some people read their way in, some talk it through, some need to see it, and some only get it with their hands in the thing. Ergonomics has to serve all of them: code to read, commands to say, a city to fly, a run to watch.

The craft changes, the art stays

A hand-made table and a skyscraper are both building. Music went from playing every part to remixing, and the DJ arrived; vibe coding is that DJ. The game changed. The art did not leave.

Our job: requirements, to the letter

When code was slow, we planned so we never wrote it twice. Now it takes a second, so the danger is writing it wrong: nobody reads every line at this speed. Right the first time is what closed loop requirements are for.

A prototype, measured by tools and not yet tested by people. Debugging, where ergonomics matters most, is not finished.

Vegeta crushing his scouter, the 'It's over 9,000!' scene

It’s over 9,000!

So, what did all this cost?

A huge build, on a small bill

102,092

lines of hand-written code in u2ue, the toolkit underneath

15,417

lines in the Blueprint view on top, open source, built since Tuesday evening

28%

of one week’s Max plan, on Thursday morning, every other project included

6.39 M

tokens written by the model; 99.4% of what it read came straight from cache

905

tokens to ask a Blueprint a question, not 164,230: 181x fewer

81%

of the tokens through one writing session; the deck had its own, and 5 short helpers used 12%

One writer, closed loop requirements: no committee of agents to referee. Find the fun fast in WebGPU or Unity, then ship AAA in Unreal, whose defaults look better than anything we would write ourselves.

Lines: non-blank, hand-written program source in each repository’s committed tree. Tokens: the model’s own usage in the session logs, Tue 27 Oct 19:17 MT on. Plan: the app’s usage meter. A question: the trace’s answer against the raw paste, Lock-On.