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.
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
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
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
Friction
As published
In the new view
Long wires
200 wires, 29 crossings
0 wires across 6 or more steps
Order over values
17 crossings
None: they run on separate levels
Finding one node
Pan a 2,736 × 2,160 canvas
One typed or spoken command
The hidden parent
Named nowhere
Read from the code: FrankBP is a Character
Cast To
4 casts
1 interface, proposed (not yet applied)
Answering 10 questions
1.6 million tokens of raw text
9,053 tokens: 181× fewer
Every node accounted for
No link to any requirement
162 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.
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.
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.
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.