Working with AI: Let AI Read and Write Your Verse

1. You Can't Paste a Node Graph Into a Chat Box

Start with a scene every Blueprint author has lived through. You're stuck on a bug and you want to ask someone — a colleague, a forum, an AI assistant. Your standard move is: take a screenshot.

And immediately you start losing things. The screenshot has no pin types, no variable defaults, none of the make-or-break checkboxes on the Details panel, none of the three subgraphs folded away behind a Collapse node, and neither of the two other assets that clearly take part in this logic but aren't on this screen. What the other side receives is a picture, and they have to guess their way back to the logic. You'll probably add "oh, and that Delay is 5 seconds" — you add three clarifications and forget the fourth.

The other direction is worse. Even if the other side figures it out, they can't hand it back: nobody can generate a .uasset for you. All they can do is describe it in words — "add a Set node after the True branch and set the Bool to true" — and then you open the editor, find the spot by hand, wire it by hand, and check by hand that you didn't wire it wrong. One request for help, two lossy conversions.

Verse opens up both ends of that chain at once. Note the reason: AI did not get smarter — reading code is something AI has been able to do all along. What changed is the form your logic exists in. It went from a picture only eyes can read to text that can be pasted whole, quoted line by line, and handed back verbatim.

That's the technical premise of this lesson, and it's one sentence: Verse is text code. Everything in the next five sections is a corollary of that sentence.

2. The Four Things Text Unlocks

"It's text now" sounds like a formatting detail. It's actually a jump in capability. It unlocks, in one move, four things that are impossible — or agonizing — in the node-graph world.

One: pasting and asking. You can paste an entire .verse file into a chat box without losing a single character: the type annotations are there, the specifiers are there, the indentation levels are there, your own comments are there. What the AI sees is exactly what the compiler sees. On the Blueprint side, the highest fidelity you can offer is a screenshot plus a verbal description — the information is already short-weighted at step one.

Two: diff and code review. Changes to text are presented per line: three lines removed in red, five added in green. The reviewer only has to read those eight lines, not the whole file — and those eight lines are themselves text, so they can be pasted into a chat, commented on line by line, and read by an AI. A .uasset is a binary asset; version control can only tell you "this file changed". What changed takes the Blueprint Diff tool, two assets side by side, and your own eyes — and the conclusion you reach leaves no trace and can't be pasted anywhere.

Three: merging under version control. Two people editing different functions in the same .verse file? Git merges both sets of changes automatically. Only edits to the same line count as a conflict, and a conflict is laid out line by line so you can keep half of each. Two people editing the same .uasset? The standard team practice is exclusive checkout — checking out locks the file: first to lock gets to edit, everyone else waits. When you really do collide, it's basically one or the other, and somebody's entire afternoon goes in the bin. This is the most concrete difference in team work, it has nothing to do with AI, and it has everything to do with how long your project survives.

Four: letting AI make bulk changes. "Replace every Print call in these 12 devices with our own logging function" is, in the text world, one find-and-replace — or one round of "the AI hands back 12 edited files and you review each diff". In the node-graph world it means opening 12 assets, hunting down the Print String node in each graph, swapping it by hand, and re-wiring the pins. No tool can do it for you, because there is no stable textual representation to operate on.

All four have a shared name: machine-processable. Version control, automation scripts, code review tools, AI assistants — everything that can do work on your behalf speaks in lines. A node graph has no lines, so none of them can help.

3. AI in the UE6 Editor: What Has Actually Been Announced

Every item in this section carries a status label. News about AI moves faster than engine versions, and telling "shipped" from "announced" from "not disclosed" matters more than remembering the details.

Shipped (flagged Experimental). Unreal Engine 5.8 ships a plugin called Unreal MCP, and the official documentation marks it Experimental right at the top: learn it, but be careful shipping with it. What it does is embed an MCP server inside the Unreal Editor process so that any MCP-compatible AI client — the official docs name Claude Code, Cursor, VS Code, Gemini and the MCP Inspector — can drive the editor over a local HTTP connection, calling tools such as spawning actors, configuring lighting, creating material instances, inspecting Slate widgets, and running automation tests. The docs are equally blunt about the limits: it listens on loopback only by default and has no authentication layer, many features are incomplete, and APIs and data formats may change at any time.

Announced, form not disclosed. At State of Unreal 2026, Epic announced that UE6 will build generative AI assistants into the editor, and stressed that the interface stays open: you can plug in Claude, plug in Gemini, or plug in your own model. Epic's public position is that AI is an amplifier of creativity and productivity, not a replacement — it will not replace the editor and it will not build a whole game on its own; whether and how to wire it into your pipeline is the developer's call. What that in-editor assistant will finally look like in UE6, and when it will be usable, has not been disclosed.

Not disclosed. Whether UEFN will support Unreal MCP: Epic has not said. The form of Verse's visual scripting layer (the community calls it Visual Verse): also not disclosed. So working with AI in UEFN today still means the plainest method there is — paste the contents of your .verse file into a chat box, and paste the AI's code back into the editor.

Which is exactly the point of this lesson: that path requires no new feature at all. It works today. A built-in editor assistant will make it smoother, but it won't change the principle — and the principle is that one sentence from Section 1: your logic is text.

4. How to Ask So It Actually Helps

Same person, same model: change how you ask and the answer quality shifts by an order of magnitude. In the three pairs below, the difference isn't politeness — it's whether you handed over the information the other side needs to judge.

Pull out what those three pairs have in common and you get five rules:

• ▢ Paste real code and the verbatim error — don't paraphrase, don't say "something about not finding something". Every word in the error text is a clue.
• ▢ State the environment: UEFN or the Unreal Editor, engine version, which modules you using. The same Verse has different APIs available in different environments.
• ▢ Ask for behavior, not syntax. "A player's score must survive them leaving mid-match" is behavior; "use a weak_map" is syntax — lead with the former.
• ▢ Ask one thing at a time. Bundle your questions and you get a mongrel answer, and when it breaks you can't tell which part is at fault.
• ▢ Ask it to explain, not just to produce code. Code you don't understand is code you can't review and can't maintain — that isn't your code, it's just code temporarily lodged in your project.

5. The Part Only You Can Sign Off: A Four-Step Review

Good news over; here's the bad news. AI crashes on Verse in three characteristic ways, and none of them is laziness — they're structural.

It will invent APIs that don't exist. No mystery why: models have seen Python, C++ and C# by the hundreds of millions of lines, and far less Verse — Verse has only been running in UEFN production since 2023, its API surface is much smaller than a mainstream language's, and the public corpus is much thinner. The thinner the corpus, the more readily a model fills the gap "the way another language would look", producing a function name that sounds perfectly reasonable and simply does not exist in Verse. It isn't lying to you; it's filling in a blank by probability because you didn't give it enough context.

It will give you outdated syntax. Verse has been evolving since 2023, and a model's corpus mixes every era of it. Code that was perfectly correct two years ago may have been renamed or resigned since.

It will skip failure contexts and concurrency semantics. Those two are precisely where Verse is least like other languages, which makes them precisely where a model is most likely to smooth things over "by common sense": writing straight through where an if belongs, calling a <suspends> function as if it were synchronous, waving away the cancellation semantics of race and sync.

Here's a textbook crash site. You asked for "add score to a player, one ledger per player", and the AI hands back this:

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

var PlayerScores:weak_map(player, int) = map{}

score_device := class(creative_device):

    # Neither the read nor the write goes through a Branch -- won't compile
    AddScore(Player:player, Delta:int):void =
        Old := PlayerScores[Player]
        set PlayerScores[Player] = Old + Delta
        Print("New score: {Old + Delta}")

The structure is right, the naming is right, even the comment looks the part — but it took a shortcut in two places: reading from a weak_map might not find anything, and writing to a weak_map might not go through, so both have to sit somewhere that is allowed to not go through. That's the whole failure-context story from Lesson 12 — and it's the one a model most readily overlooks, because other languages don't have it. Below is the corrected version. Click "Run Next Step" and watch what each of the two Branches the AI dropped is actually doing.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

# Module-level weak_map: one slot per player
var PlayerScores:weak_map(player, int) = map{}

score_device := class(creative_device):

    AddScore(Player:player, Delta:int):void =
        var NewScore:int = Delta
        if (Old := PlayerScores[Player]):
            set NewScore = Old + Delta
        if (set PlayerScores[Player] = NewScore):
            Print("New score: {NewScore}")

So: for any piece of Verse an AI gives you, run the same four steps.

• ▢ 1. Compile. Let the compiler speak first. Its hit rate on hallucinated APIs is 100%, it costs nothing, so run it first.
• ▢ 2. Read every line and understand it. You must be able to say what each line does. Any line you can't read, either ask until you can or delete and rewrite it — don't leave it in the project.
• ▢ 3. Check the failure contexts. Every operation that might not go through — a map lookup, unwrapping an option, indexing with [], calling a <decides> function — is it honestly wrapped in an if? This is where AI most loves to cut corners.
• ▢ 4. Run the edge cases. Empty array, a player leaving mid-match, two presses in the same frame, a re-trigger before the timer finishes. AI code usually performs beautifully on the everything-is-fine path.

Note that none of the four steps is "trust it", and none is "distrust it". You aren't checking whether the other side is honest — you're checking whether it understood your project. And it doesn't have your project; it only has the few hundred lines you gave it. You supplied the information, so of course you sign off on the result.

Blueprint Cross-Reference

The same four tasks — asking for help, reviewing, merging, changing things in bulk — work completely differently in the two worlds. The difference column is the point.

Every difference in that table has one root: a node graph is drawn for humans; text is written for humans and machines at the same time. Blueprints chose "draw", and bought zero-barrier intuitiveness with it. Verse chose "write", and bought the entire software-engineering toolchain — version control, review, automation, AI. Both trade-offs cost something; it just happens that every tool capable of doing work for you today grows on the text side.

One status note to add: Actors and Blueprints are fully supported in UE6 Early Access (Epic's official roadmap targets late 2027) and in the early versions after it; deprecation waits until Scene Graph is mature enough, with no date set. Epic has committed to shipping conversion tools before any deprecation, but they have not been released. So the two worlds will coexist for a long time — and precisely because they coexist, "which logic is worth moving into Verse first" gets a very practical test: whatever most needs to be reviewed, merged, and changed in bulk.

6. Graduation: What You Learned Is a Language

Thirty lessons, and here's the end of the road. Look back at it: Chapter 1 asked the question that actually got you here — will your Blueprint skills go stale. Chapter 2 translated every Blueprint noun into Verse and every node graph into indented blocks. Chapters 3 through 6 moved variables, control flow, containers, functions and types out of the panels and into code, one piece at a time. Chapter 7 covered time and concurrency — the things you used to assemble out of Delay, Timeline and a pile of boolean flags now have names. Chapter 8 walked into the new world of Scene Graph, where Actors become entities and the inheritance tree becomes components. Chapter 9 had you translate a whole Blueprint into Verse, and then this lesson: learning to put AI to work alongside you.

Engines will change versions. Frameworks will change names: entity follows Actor, Scene Graph follows Blueprints, and something else will follow Scene Graph. Today's best AI is next year's baseline. All of that will move, and it will move faster than you finish a project.

But what you learned across these 30 lessons is not in that update queue. What you learned is a language — what a type is, how scope is drawn, why failure deserves a context of its own, why cancellation semantics must be explicit, why composition beats inheritance. These ideas existed in other languages before Verse existed, and they'll still be there in the next engine and the next framework. Epic didn't invent them; Epic put them in the middle of game development.

As for AI: it will write faster and make fewer beginner mistakes every year. But it will never decide for you whether this code belongs in your project, whether this trade-off is worth it, or whether this bug takes a one-line fix or a refactor of the layer beneath it. Making those calls requires being able to read code — which is exactly the ability you just spent 30 lessons buying.

Frameworks will change, AI will get stronger, and the person who can read the code is always the one making the decisions. That's what this course actually puts in your hands.

Level Challenge

Three last checkpoints. Correct answers earn a star ★; wrong answers can be retried forever, zero penalty.

Further Reading