Prompt Templates for Describing Verse Tasks to an AI
The main lesson covered the principles of asking well; this page turns them into templates. Five of them, ready to copy: write a new feature, explain a piece of code, track down a compile error, translate a Blueprint into Verse, and build a manual test checklist. Each marks the blanks you must fill. At the end, a set of counterexamples — sentences that look like questions but carry no information at all.
1. How to Use These: The Brackets Are Mandatory
In the five templates below, anything inside [ ] is a blank you must fill. Leave it empty and the template collapses back into an ordinary question, with ordinary results. Every other sentence can be copied verbatim; their job is to pin down the output format and the acceptance criteria up front, saving you the three or five rounds of follow-up you would otherwise spend.
One general tip: don't delete the numbered lists. Give an AI a numbered checklist and its answer usually comes back numbered too — which is enormously helpful when you're checking it, because you can say "item 3 is wrong, redo item 3" instead of asking for a full rewrite.
2. The Five Templates
Template 1: write a new feature. The easiest one to crash on, because "what I want" is usually the part you haven't thought through either. Half the value of this template is forcing you to think it through first.
Environment: [UEFN / Unreal Editor], engine version [5.x], language Verse.
The behavior I want (not the syntax):
[One sentence: who, at what moment, sees what. Don't mention any syntax.]
What already exists:
[Paste the relevant .verse file in full; if there's no code yet, list the
device types already placed in the level.]
Boundaries and constraints:
- If a player leaves mid-match, it should [...]
- If it is triggered twice in the same frame, it should [...]
- Does the data need to persist across sessions: [yes / no]
Answer like this:
1. Give the complete code first, then explain it section by section.
Don't give code alone.
2. Call out every failure context separately and say why it must sit in an if.
3. For every API you use, say which module it belongs to and which
using line it needs.
4. Implement only this one feature. No UI, no sound, nothing I didn't ask for.Mandatory blanks: environment and version, the behavior (not the syntax), existing code, at least one edge case. The third matters most: with no existing code, the AI will invent its own naming and structure, and you'll be stitching it into your project by hand.
Template 2: explain a piece of code. For when you inherit someone else's Verse, or copy something out of the docs and aren't sure what it does. Note the last line — it explicitly forbids rewriting.
Here is a piece of Verse code, from [my UEFN project / the official docs /
a colleague]:
[Paste the complete code, including the using lines and comments.
Don't paste a fragment.]
Explain it in this order:
1. What it does overall, in one sentence.
2. Line by line, calling out three kinds of lines specifically:
- which lines might not go through (failure contexts),
- which lines can suspend,
- which lines change state (set).
3. If I put it inside [a creative_device's OnBegin / an event callback],
what should I watch out for.
4. Give me a Blueprint analogy so I can map it onto what I already know.
Do not rewrite this code. Right now I only want to understand it.Mandatory blanks: the full code, where it came from, where you plan to put it. That third item decides a lot of answers: the same code inside OnBegin versus inside a button callback differs completely on whether it can suspend and whether it can re-enter.
Template 3: track down a compile error. The two crucial phrases here are "verbatim" and "don't paste only the failing lines". Verse errors often point at where the symptom surfaced, while the cause lives elsewhere.
Environment: [UEFN / Unreal Editor], engine version [5.x].
The compile error, verbatim (including file name and line number):
[Paste the complete error. Don't paraphrase, don't say "something about
not finding something".]
The full text of the failing file:
[Paste the entire .verse file. Don't paste only the failing lines --
the cause is often somewhere else.]
The behavior I want is: [one sentence.]
Answer in this order:
1. What this error is saying, in words I can follow.
2. Why it appears on this particular line.
3. The smallest fix. If there's a better structural change, mention it
afterwards -- give me the smallest one first.
4. How I can recognize this class of error at a glance in future.Mandatory blanks: the verbatim error, the full file, the behavior you want. Item 4 is free money: trade every error you ask about for one "how to recognize it next time", and after a few rounds you stop needing to ask.
Template 4: translate a Blueprint into Verse. The core problem is the one from Section 1 — you can't paste a node graph. So this template does the next best thing: dictate the graph as a structured list in execution order. Writing the list is already half the translation.
I want to translate a piece of Blueprint logic into Verse. A node graph
can't be pasted, so here it is written out in execution order:
Entry event: [Event BeginPlay / an Event Dispatcher / a device event]
Node sequence (following the execution wire):
1. [Node name] -- input pins wired to [...], output wired to [...]
2. [Node name] -- [...]
3. [Branch] condition is [...]; True goes to [...], False goes to [...]
Variables used:
- [Name]: type [...], default [...], Instance Editable [yes / no]
Assets or devices used: [...]
Please:
1. Give the equivalent Verse implementation.
2. Point out which nodes have no one-to-one counterpart in Verse and what
you replaced them with.
3. Point out where Verse's semantics differ from Blueprint's, especially
around failure and concurrency.
4. If my description has gaps, list the questions you need me to answer.
Do not fill them in yourself.Mandatory blanks: the entry event, the node sequence in order, the variable list with types and defaults. That final "do not fill them in yourself" matters: a dictated node graph always has gaps, and having it ask is far cheaper than having it guess.
Template 5: write test cases. Note the final line — what you want is a checklist you can walk through in UEFN by hand, not a test framework.
Here is my Verse code:
[Paste it in full.]
The expected behavior of this feature is: [one sentence.]
List the scenarios I should verify by hand, in three groups:
1. The happy path.
2. Edge cases: empty containers, counts of zero, upper and lower bounds,
repeated triggers, several triggers in the same frame.
3. Multiplayer and concurrency: a player joining mid-match, a player leaving
mid-match, two players triggering at once, and the state of one race
branch when the other is cancelled.
Write each item as "action -> expected result". I'm going to walk through
them one at a time in UEFN.
Don't write automated test framework code -- I need a manual checklist.Mandatory blanks: the full code, one sentence of expected behavior. This template has the best return of the five: an AI's ability to enumerate edge cases is more reliable than its ability to write code, because enumerating doesn't require it to know Verse's exact APIs.
3. Counterexamples: Why You Get Garbage Back
All five below show up constantly in real life. What they share is that they look like questions while carrying nothing anyone could judge from.
| The question | What you get | Why |
|---|---|---|
| "How do I write Verse?" | A syntax overview with no connection to your actual problem | That's a topic, not a task. The AI has to guess what you want, and it guesses the most common case — which is probably not yours |
| "This code has a bug, can you look at it?" (attaching a screenshot of the code) | A pile of "it might be... or it might be..." | Code in an image has to be read back into text before it can be understood, and Verse's indentation is the syntax — misread one level and the conclusion changes. Always paste text, never a picture |
| "Don't use if, just write it directly." | Code that doesn't compile, or fake code that dodges the failure context | You're disabling the language's core mechanism. The AI will generally comply with your instruction and hand back something that can't run — it won't argue with you for the sake of correctness |
| "While you're at it, add a leaderboard, add sound effects, and optimize performance." | A mongrel in which every part is one-third finished | Ask one thing at a time. A bundled request gives every item a third of the attention, and when something breaks you can't tell which part is at fault |
| "That code from last time is erroring again." (in a brand-new conversation) | An answer from another planet | A new conversation carries no memory of your project. Every round needs the context pasted again — that isn't laziness, it genuinely cannot see it |
Read the five counterexamples backwards and you get five rules: give a task not a topic, paste text not pictures, don't disable the language's mechanisms, one thing at a time, re-paste the context every round. Together those five are worth far more than switching to a stronger model.
4. Quick Quiz
Which kind of "mandatory blank" appears in all five templates?