Vibe Coding the Epic AI MegaJam 2026 with Claude: Step-by-Step Tutorial, Workflow, and How to Submit

Epic Games is running its first game jam built around AI. The 2026 Epic AI MegaJam gives you four days, November 12 to 15, to build a playable game in Unreal Engine or Unreal Editor for Fortnite (UEFN). In Epic's words, you can team up "with up to four other humans and unlimited agents."

That's an invitation to vibe code: describe what you want, let an AI agent write and wire up the code, playtest, and repeat. Claude and Claude Code suit this well. Unreal Engine now ships an official MCP plugin that lets Claude Code work inside the editor, and Claude handles C++, Blueprint logic, and Verse.

This guide covers the rules that matter, the tool setup, a hands-on tutorial that takes a small game from empty project to packaged build, a day-by-day jam workflow, and how to submit on itch.io without getting disqualified.

Epic AI MegaJam 2026 at a glance

AI is allowed, not required

When Epic first announced the jam, its FAQ said you had to use AI. Epic walked that back on its official Unreal Engine account: "You can use as little or as much AI as you want." Judges don't score how much AI you used. They score the game.

That changes the strategy. Don't use AI to show off AI. Use it wherever it saves you time, and spend that time on what judges reward: a fun, polished game that fits the theme.

How you win

The main categories are Best Overall (Unreal Engine), Best Overall (UEFN), and Best Student Project, each paying $7,500, $5,000, and $2,500 for first through third. Best Student Project is open to students currently enrolled at a higher-education institution. Each entry can also win one "modifier" prize on top of a main category:

• Best Team: best game built by a team of two or more (UE or UEFN), $5,000.
• Solo Driver: best game from a solo developer (UE or UEFN), $2,500.
• Render Royalty: best visuals, photoreal or stylized (UE), $2,500.
• Pocket Powerhouse: best mobile game, with one UE winner and one UEFN winner, $2,500 each.
• Glass Box: best dev log showing how you used AI tools to build the game, $2,500. You must link the dev log in your submission.
• Walkie-Talkie: best narrative-driven UEFN game with LLM-powered NPCs, $2,500.

According to the jam page, the judges score entries on criteria including theme, fun factor, gameplay, visuals, audio, level design and progression, and ambition and innovation. Two prizes favor AI-heavy teams: Glass Box rewards documenting your process, and Walkie-Talkie rewards LLM-driven characters. We cover both below.

Why Claude fits a four-day Unreal jam

Vibe coding works when the AI can see your project, change it, and check its own work. For Unreal, Claude covers three layers:

1. Code. Claude Code runs in your terminal, reads your whole project, and edits C++ classes, .Build.cs files, config .ini files, and Verse files. Those are plain text, so it can work with them directly.
2. The editor. Blueprints, levels, and most assets are binary .uasset and .umap files that a coding agent can't read as text. Epic's Unreal MCP plugin closes that gap. It runs an MCP server inside the Unreal Editor so an agent like Claude Code can call editor tools, such as spawning actors, setting up lighting, and running automation tests.
3. Thinking work. Claude, in the browser or desktop app, is a fast partner for brainstorming the theme, scoping, writing dialogue, and drafting your dev log and store page.

Setting up Unreal MCP with Claude Code

Per Epic's documentation, the setup is short:

1. Enable the Unreal MCP and All Toolsets plugins, then turn on auto-start in Editor Preferences.
2. Generate a client config from the editor console. This writes a .mcp.json file to your project root, which Claude Code picks up:

ModelContextProtocol.GenerateClientConfig ClaudeCode

3. Start Claude Code in your project folder and confirm it can see the Unreal tools.

If your team is on an older engine version, community MCP plugins exist for UE 5.7. They're third-party code with full access to your project, so read the source before you install one, and prefer Epic's plugin if you can.

UEFN teams: Claude plus Verse

UEFN game logic is written in Verse, Epic's language for Fortnite islands. Verse files are text, so Claude Code can write and refactor them like any other code. Verse is newer and less common than C++, though, so give Claude the relevant pages of Epic's Book of Verse reference or paste in working examples. That one step prevents most invented API calls.

If you're aiming for Walkie-Talkie, read Epic's docs on developing personas in UEFN and LLM game mechanics with Verse. This is Epic's built-in system for NPCs players can talk to. Claude is useful here for writing NPC personas, backstories, and the Verse code that reacts to what the conversation returns. Epic has listed parts of this system as experimental, so confirm it works in a private version before you build your whole game around it.

Tutorial: vibe code a playable prototype with Claude Code

The best way to prepare is a practice run on a throwaway game before November 12. This tutorial builds a small Unreal Engine game called Orb Rush: collect every glowing orb before a 60-second timer runs out. It takes an afternoon and goes through every step you'll repeat in the jam: setup, planning, code, editor work, UI, playtesting, packaging, and upload.

Step 1: Create the project

1. In the Epic Games Launcher, install the Unreal Engine version you'll use in the jam.
2. Create a new project from Games → Third Person, choose C++, and name it OrbRush. The template gives you a working character and camera, so Claude can focus on the game.
3. Open the project once so the engine generates its files, then close the editor.

Step 2: Put it under version control

Claude Code works best in a git repository, where every change it makes can be reviewed and undone. In the project folder:

git init
git lfs install
git lfs track "*.uasset" "*.umap"

Then add a .gitignore that excludes Unreal's generated folders: Binaries/, Intermediate/, Saved/, and DerivedDataCache/. Make your first commit. From here on, commit every time something works.

Step 3: Install Claude Code and connect it to Unreal

1. Install Claude Code by following the official quickstart.
2. Reopen the project, enable the Unreal MCP and All Toolsets plugins, turn on auto-start in Editor Preferences, and restart the editor.
3. Run ModelContextProtocol.GenerateClientConfig ClaudeCode in the editor console to write .mcp.json into the project root.
4. Open a terminal in the project folder and run claude.
5. Type /mcp to check that the Unreal server shows as connected. If it doesn't, check that the editor is open and the plugin started.

Step 4: Give Claude the project rules

Type /init. Claude scans the project and writes a starter CLAUDE.md. Open it and add what it can't work out on its own:

- Engine: Unreal Engine 5.x, C++ gameplay classes + Blueprint subclasses.
- Game: Orb Rush. Collect all orbs before a 60-second timer ends.
- Put tunable values in UPROPERTY(EditAnywhere) so we can tweak them
  in the editor without recompiling.
- Never delete or rename existing assets without asking.
- After any C++ change, compile and fix every error before stopping.

Step 5: Plan the game in plan mode

Press Shift+Tab until Claude Code shows plan mode, then describe the game:

Build the core loop for Orb Rush on top of the Third Person template:
1. An AOrbPickup actor: a mesh, a sphere overlap, a slow spin, and
   when the player touches it, it tells the game mode and destroys itself.
2. The game mode counts orbs at start, runs a 60-second timer, and
   ends the round with a win (all orbs) or a loss (time's up).
3. On win or loss, show a message and let the player restart with R.
Plan only. List the classes and files you'll create or change, and
anything I need to do by hand in the editor.

Read the plan before saying yes. This is where you catch a bad idea cheaply. A common fix at this stage: "Keep the timer and score in the game mode, not the character."

Step 6: Let Claude write and compile the code

Approve the plan and let Claude work. It will create the C++ classes and then compile. Ask it to use the engine's build script so it can read the errors itself. On Windows, that command looks like this:

"<Engine path>\Engine\Build\BatchFiles\Build.bat" OrbRushEditor Win64 Development -Project="<path>\OrbRush.uproject"

If the compile fails, Claude reads the log and fixes the code. When it builds cleanly, commit.

Step 7: Do the editor work through MCP

Open the editor and create BP_OrbPickup as a Blueprint subclass of AOrbPickup, with a sphere mesh and an emissive material. Then let Claude place the orbs:

Using the Unreal tools, place 10 BP_OrbPickup actors around the
third-person map at reachable spots: a few on the ground, a few on
the raised platforms. Keep them at least 400 units apart. Tell me
each location when you're done.

Press Play and check the result. If an orb is stuck in a wall, say so and Claude can move it. This is where the MCP connection earns its keep: no hand-placing, and you can redo the whole layout in one prompt.

Step 8: Add the HUD

Ask Claude for a C++ UUserWidget base class that shows the remaining time and orb count, using bound text widgets. Then create a Widget Blueprint from that class in the editor and add two text blocks with the names Claude gives you. Splitting the work this way keeps the logic in code, where Claude is strongest, and the layout in the editor, where you can see it.

Step 9: Playtest and give feedback like a designer

Play for five minutes and write down what feels off. Then give Claude specific feedback:

Playtest notes:
- 60 seconds is too generous. Make it 45 and expose it in the editor.
- Pickups feel flat. Add a scale-down over 0.15s and a sound cue slot.
- The win message disappears too fast. Keep it until R is pressed.

You can also drag a screenshot into Claude Code and ask what to change. Claude can read images. Commit after each round. Repeat this loop of playtest, notes, fixes, and commit until the game is fun. In the jam, this loop is most of your time.

Step 10: Package the build

Package the game the way you'll package your entry. In the editor, use Platforms → Windows → Package Project. Or have Claude run Unreal's automation tool so it can read and fix any packaging errors:

"<Engine path>\Engine\Build\BatchFiles\RunUAT.bat" BuildCookRun -project="<path>\OrbRush.uproject" -platform=Win64 -clientconfig=Development -build -cook -stage -pak -archive -archivedirectory="<path>\Build"

Run the packaged .exe and play the game from start to finish outside the editor.

Step 11: Practice the itch.io upload

Zip the packaged folder as TeamName_GameName.zip. Create a draft project on itch.io, upload the zip, and set it to Windows. If the build is near 1 GB, practice with butler instead. Then delete the draft. On jam day, every step of submitting will already be familiar.

Step 12: Write your practice dev log

Ask Claude to summarize the session from your commit history:

Read the git log for this project and write a short dev log: what we
built, in what order, what broke, and how we fixed it. Mark which
parts Claude did and which were done by hand.

Edit it in your own voice. You now have a template for the dev log the Glass Box prize asks for.

Doing the same in UEFN

The loop is the same in UEFN, with Verse in place of C++:

1. Create a new island project in UEFN and add a Verse device from the Verse Explorer. The .verse files live in your project folder, so you can open that folder in Claude Code.
2. Put Epic's Book of Verse and the API pages for any devices you use in your project notes or CLAUDE.md, so Claude writes current Verse.
3. Describe the mechanic in plan mode, for example: "a Verse device that counts collected items, runs a 60-second timer, and ends the round."
4. Build the Verse code in UEFN, paste any compiler errors back to Claude, and playtest in a session.
5. Practice creating a private version code, since that's what you submit for UEFN.

The workflow: day by day

Here's the plan we'd follow. It assumes Claude Code as the main agent and one teammate who owns the editor, but it scales down to a solo dev.

Before November 12: set up tools, not the game

The rules say not to start building before November 12, and you must declare anything made earlier. So prepare your tools, not your game:

• Install the engine version you'll use and confirm a blank project packages for your target platform. Packaging failures on day four are the classic jam killer.
• Set up version control. Claude Code works best in a git repository, where every change can be reviewed and rolled back. Configure Git LFS (or your team's source control) for binary assets.
• Get Claude Code running, test the Unreal MCP connection on a throwaway project, and learn the basics. Anthropic's Claude Code best practices and the free Claude Code 101 course on Claude Academy are the fastest routes.
• Create your itch.io account and read the full jam page now, not at 5 PM on Sunday.
• Watch the kickoff livestream on November 11 for the theme.

Day 1 (Nov 12): scope hard, then build the core loop

Morning: brainstorm with Claude, decide as humans. Give Claude the theme and your constraints, and ask for options:

The jam theme is "<theme>". We have 4 days, <N> people, and are using
<Unreal Engine 5.x / UEFN>. Our skills: <list>.
Give me 10 game concepts that fit the theme. For each: the core loop
in one sentence, why it's fun in the first 30 seconds, the riskiest
technical part, and what we'd cut first if we fell behind.

Then pick one as a team. AI is good at generating options. Choosing the one your team can finish and polish is your job.

Write a one-page design doc and a CLAUDE.md. Claude Code reads a CLAUDE.md file at the start of every session. Anthropic's docs recommend keeping it short and limited to what Claude can't work out from the code. For a jam, that's your engine version, conventions, and guardrails:

# Jam project: <Game Name>
- Engine: Unreal Engine 5.x, C++ + Blueprints. Target: Windows.
- Core loop: <one sentence>. Read docs/design.md before big changes.
- Gameplay classes live in Source/<Game>/; prefix with the game's
  short code. Expose tunables as UPROPERTY(EditAnywhere) so designers
  can tweak them in Blueprints.
- Never delete or rename existing assets without asking.
- After any C++ change, compile and fix all errors before stopping.
- Keep a running dev log entry in docs/devlog.md for every feature.

Afternoon: get the core loop playable. Use plan mode for anything bigger than a small fix. Claude proposes a plan, you correct it, and only then does it write code. Anthropic's guidance is to put the effort into the plan so the build goes in one pass. By the end of day one, you want something ugly but playable: the player can move, do the main verb, and win or lose.

Day 2 (Nov 13): build features in parallel

This is where "unlimited agents" pays off, and where teams get into trouble.

• Split by file, not by feature list. Anthropic warns that two agents editing the same file in parallel causes conflicts. Give each person (and their Claude session) a separate area, such as the enemy AI, the UI, or the level, and merge often.
• One editor driver at a time. Unreal MCP runs tool calls one at a time on the game thread. Let one agent work in the editor while the others work on code.
• Use subagents for review, not for everything. Claude Code can hand work to subagents with their own context. They help most with parallel research, noisy jobs like reading logs, and independent review. A read-only reviewer subagent that checks each feature against the design doc is a cheap way to catch drift.
• Playtest every few hours. The agent can compile and run tests, but only a human can tell whether it's fun.

Day 3 (Nov 14): content, feel, and a first package

• Juice the game. Ask Claude for screen shake, hit-pause, camera tweaks, and particle hooks, then tune the values yourself in the editor.
• Balance with data. Have Claude move difficulty numbers into a data table or config so you can tune them without recompiling.
• Package a full build today. Make the target-platform package you'll submit, install it on a clean machine if you can, and play it start to finish. If packaging breaks, paste the full log into Claude Code. Build logs are long and noisy, which is exactly what agents read well.
• Cut scope. Ask Claude: "Given what's left and 30 hours, what should we cut so everything that ships feels finished?"

Day 4 (Nov 15): freeze, package, submit

• Feature freeze by midday your time. After that, fix bugs only.
• Final package (UE) or private version code (UEFN), then a full playthrough of exactly what you're submitting.
• Record the 30–60 second gameplay video and write the store page (see below).
• Submit hours before the 5:59 PM PST deadline. Uploads stall, and late entries are disqualified.

Using Claude for what judges see beyond the game

Your dev log (and the Glass Box prize)

The Glass Box prize goes to the best dev log showing how you used AI tools to build the game, and an AI-assisted jam gives you a lot to show. If your CLAUDE.md tells Claude Code to update docs/devlog.md as it goes, you'll end the jam with a timeline already written. Then ask Claude to turn it into a readable post, and add the human parts yourself: what you decided, what you cut, and what the AI got wrong. Judges reward honest process writing more than a highlight reel.

Store page and itch.io copy

Your itch.io page is the first thing judges see. Ask Claude to draft a short description, the controls, and a "how to play" section from your design doc, then rewrite it in your own voice. Make sure it covers how to launch the game, the controls, and any known issues.

Audio, art, and other AI tools

Claude writes code and text. It doesn't generate images, 3D models, or sound. The jam allows other AI tools for assets, but the Official Rules ban content that infringes someone else's IP. Whatever tools you use, make sure you have the rights to every asset, and keep a list of tools and asset sources for your submission and dev log.

How to submit your game on itch.io

Submission runs through the itch.io jam page. You upload the game to your own itch.io account, then submit that project to the jam. Here's the checklist from the jam page as it reads at the time of writing.

Unreal Engine teams

1. Package a development build for Windows, macOS, Android, or iOS.
2. Zip it and name the file TeamName_GameName.zip.
3. Keep the upload under 1 GB. For bigger builds, itch.io's command-line uploader, butler, handles large files and resumes interrupted uploads.
4. Create a project on your itch.io account, upload the zip, and set the platform tags.
5. Submit the project to the jam from the jam page before the deadline.

UEFN teams

1. Create a private version code of your finished island. This is a locked snapshot of the build you want judged, and it must exist before the deadline.
2. Don't submit a live island code or a playtest code. The jam rejects them because they can change after the jam ends.
3. Follow Epic's Fortnite developer rules for island content.
4. Create an itch.io project for the entry, add the private version code and instructions, and submit it to the jam.

What every entry needs

• A 30–60 second gameplay video.
• A clear description, controls, and how to run or join the game.
• A dev log link if you're going for Glass Box.
• A note on anything you made before November 12, as the rules require.

Mistakes that sink AI-assisted jam games

• Letting the agent drive scope. AI makes adding features cheap, so teams add too many. Judges play a polished small game longer than a buggy big one.
• No version control. One bad agent session can break a level. Commit before every session and after every working feature.
• Trusting code you never ran. A clean compile doesn't mean it works. Playtest every feature.
• Packaging late. Package on day three. Package again on day four.
• Unverified assets. Using AI doesn't remove IP rules. If you can't say where an asset came from, cut it.
• Overlapping agents. Two sessions editing the same file, or two agents driving the editor at once, burns hours on merges and crashes.

FAQ

Do I have to use AI in the Epic AI MegaJam? No. Epic corrected its FAQ: you can use as little or as much AI as you want, and judging isn't based on AI use.

Can I use Claude for the MegaJam? Yes. The jam allows any AI tools, and Claude Code works with Epic's Unreal MCP plugin. Check the Official Rules for limits on assets and IP.

Do I need Claude Code, or is the Claude chat app enough? Chat works for brainstorming, writing, and short code you paste in yourself. For a four-day build across a whole project, Claude Code is the better fit because it reads and edits the project directly, compiles, and connects to the editor over MCP.

Can I start before November 12? You can set up tools and accounts, but don't start building the game. You must declare anything made earlier.

Can we enter with both Unreal Engine and UEFN? No. Pick one.

What's the deadline? November 15, 2026, at 5:59 PM PST / 8:59 PM EST, according to the jam page.

Learn more before November 12

• The jam itself: Epic's announcement and the itch.io jam page, which has the full rules, FAQ, and submission form.
• Claude Code: Anthropic's best practices, its guide to using CLAUDE.md files, and how and when to use subagents.
• Unreal MCP: Epic's Unreal MCP in Unreal Editor docs.
• More AI dev workflows on our site: Cursor vs Copilot vs Claude Code compares the agents, and our Blender AI workflows guide covers using Claude for 3D assets.
• Go deeper on agents: if you want to understand tool use and MCP well enough to build your own Unreal tools, Building with the Claude API is the course we recommend.

The bottom line

The Epic AI MegaJam rewards the same thing every jam does: a fun, finished game that fits the theme. Claude speeds up the parts that usually eat a jam, such as boilerplate code, editor busywork, build errors, and the write-up, and Epic's MCP plugin lets Claude Code work inside Unreal itself. Scope small, keep humans on design and playtesting, commit constantly, package early, and submit hours before the deadline.

More guides on working with AI live in AI & Workflows.