Epic Games AI-Assisted Cooking Bug Fixes in Unreal Engine
Explore how Epic Games uses AI to fix non-deterministic cooking bugs, improving build stability in Fortnite and Unreal Engine 6 development.
The important phrase is “non-deterministic cooking bugs”
Epic executive vice president of development Marcus Wassmer has made several expansive claims about generative AI in Fortnite, Unreal Editor for Fortnite and Unreal Engine 6. The one worth unpacking is less flashy than “vibe-coding”: AI tools allegedly helped eliminate long-running non-deterministic cooking bugs. [1]
That is not a cosmetic workflow improvement. Cooking is one of the places where a game’s development build becomes a game players can actually download, install and run on a particular platform.
In Unreal terminology, assets are authored in forms convenient for development. Artists work with textures, meshes, materials, animations and sound files. Designers place those assets in maps. Programmers add gameplay code, configuration data and references tying the whole thing together.
A shipped PC build cannot simply contain that raw project folder. It would be bloated, slow to load, and full of editor-only material. Cooking converts those source assets into platform-ready data, strips unnecessary content and produces packages suitable for the target build.
Think of it as the production line between “the map works on a developer’s machine” and “this exact Fortnite update can be installed by millions of players.” A bug there does not merely crash one weapon or misalign one UI icon.
It can make two supposedly identical builds differ. That is what non-deterministic means in this context: give the process the same input, settings and target platform, then get a different output on separate runs.
Why identical inputs need identical outputs
Determinism sounds like an academic concern until a live-service game needs a patch. If the same source revision cooks differently on two machines, developers cannot reliably tell whether a changed file reflects an intentional fix or build noise.
Build noise is bad for several reasons. It can make patch sizes larger because systems detect changed output that should not have changed. It can send engineers chasing regressions caused by the pipeline rather than gameplay code.
It also damages confidence in automated testing. A test failure means much less when rerunning the same build may produce different cooked assets, different package contents or a different execution path. Reproducibility is the foundation of debugging.
The Fortnite analogy is a weapon bug that appears only in one match replay, with the same loadout and server rules apparently intact. Until someone can reproduce it, balance designers cannot tell whether the gun is broken or whether the report is junk.
Cooking bugs operate before the player reaches the match, but the principle is identical. A team needs stable inputs and repeatable output before it can confidently identify the real cause of a failure.
This is why Epic’s claim matters more than the company’s deliberately jokey “vibe coding” branding. If AI-assisted work genuinely removes a decade-old source of unpredictable cooked builds, it could improve development cadence without changing a single Fortnite cosmetic or weapon stat. [1]
What AI is apparently doing here
Epic has identified Claude Code and OpenAI’s Codex as tools used across development. Wassmer said they helped with code and feature work, test-suite upkeep, shader compression work and a significant rewrite of part of the Direct3D 12 rendering layer. [1]
The reports do not provide the actual fix for the cooking issue, nor do they show a code diff. That matters, because “AI eliminated the bug” is a result claim from Epic, not enough information for outside developers to audit.
Still, the likely workflow is more legible than the marketing language. A tool can search a large codebase, trace inconsistent file handling or ordering assumptions, suggest changes, generate test cases and compare behaviour across build configurations.
That is especially useful in old infrastructure. Unreal Engine is enormous, and build pipelines accumulate assumptions over years: platform conditionals, cache invalidation rules, compiler differences, asset dependencies and parallel jobs that may run in different orders.
A non-deterministic fault often hides at the joins. Perhaps two jobs write shared state in an unpredictable sequence. Perhaps generated metadata includes unstable ordering. Perhaps a cache key misses an input that should invalidate prior output.
The AI does not need mystical insight to help. It can accelerate the tedious work of finding every related call site, mapping dependencies and proposing consistent edits across many files. A human engineer still has to decide whether the proposed architecture is correct.
That final part is where the “bulk of the code” quote needs context. Wassmer said Epic’s engineers are guiding tools toward the desired architectural outcome, while keeping the engine inside memory, performance and scalability limits. [1]
Those limits are not optional polish. A generated refactor that passes unit tests but increases memory use, disrupts shader compilation or slows asset loading is still a failed engine change, however quickly it was drafted.
Why this will not move the player-facing meta overnight
Players generally notice engine work only when it goes wrong. A cooking fix may mean smaller or more reliable patches, fewer platform-specific issues, or faster iteration on future updates. It does not automatically mean Fortnite’s next balance pass ships early.
Live balance has its own gates. Designers need telemetry, reproduction steps, internal playtests, regression testing and platform approval. Even a clean cooking pipeline cannot answer whether a new shotgun falloff curve makes endgame fights healthier.
The difference is that cleaner builds reduce false signals. If an update unexpectedly changes too many packaged files, adds avoidable download size, or behaves differently across test environments, every downstream discipline loses time confirming the build is trustworthy.
Epic also said AI aided automatic PC stability monitoring, root-cause analysis and fix generation in Fortnite. That could be valuable for obscure hardware and driver combinations, where a crash cluster is visible in telemetry but difficult to recreate locally. [1]
But automatic fix generation is the phrase that deserves the most suspicion. A crash signature can point toward a likely cause. It cannot independently decide the correct trade-off between a workaround, a driver blacklist, reduced rendering quality and a proper engine fix.
A fix that stops one GPU driver crash by disabling a rendering path may be acceptable in an emergency hotfix. It may be a terrible permanent solution if it harms performance or image quality for every unaffected player.
That is the same distinction players make after a patch note says “improved stability.” Did the studio actually resolve the issue, or did it quietly turn off the expensive setting that exposed it? The result may be positive, but the implementation matters.
The number Epic has not supplied
There is no public percentage for how much Unreal Engine 6 code is AI-generated, AI-assisted or manually authored. Any confident figure circulating online is speculation, because Epic has not disclosed one. [1]
That absence makes sense technically. Lines of code are a rotten measure of software quality. An AI might generate hundreds of lines of routine test scaffolding, while a human writes ten lines that decide the lifetime and ownership model for a core system.
A better measurement would track outcomes: defect rates, security findings, reverted changes, performance regressions, maintenance cost and time from bug report to verified fix. Those are harder numbers, which is probably why they are more useful.
Current best practice is to treat generated code as untrusted until it has passed automated tests, static analysis, security scanning and human review. IBM’s guidance on standardising AI code generation stresses shared project rules and consistent quality controls across teams. [2]
The Godot Foundation has chosen an even more restrictive position for its open-source engine, barring generative-AI code contributions rather than trying to inspect their provenance after the fact. That is a governance choice, not proof that every AI-generated change is defective. [3]
Epic’s approach is the opposite: use the tools broadly, then rely on engineers to direct and validate them. That can work, but only if review capacity grows with generated output. Faster code production is not useful if verification becomes the bottleneck.
“Vibe-coding” is a workflow, not an escape from responsibility
The catchy term makes the process sound like a developer types “make Fortnite run better” and receives a patch. Epic itself says it is iterating with AI rather than one-shotting Unreal Engine 6. [1]
That distinction is crucial. One-shot generation means accepting a large opaque answer and hoping it works. Iterative development means defining a constrained task, checking the result, revising it, testing it and rejecting it when it violates requirements.
In game-engine work, requirements are brutally concrete. A renderer change needs correct output, predictable frame time, acceptable CPU use, manageable GPU memory, compatibility across drivers and no new failures in content made years ago.
Epic said an AI-assisted rewrite of a significant portion of its Direct3D 12 layer took around one week, compared with Wassmer’s estimate of three to six weeks for one engineer. It also reportedly improved CPU time and reduced bugs. [1]
That is a promising claim, but it is still an Epic claim. Outside observers do not have benchmark methodology, the before-and-after test scenes, hardware coverage, regression data or the number of engineers reviewing and integrating the work.
The practical lesson for studios using Unreal is not “replace engine programmers.” It is that AI is potentially strongest on bounded maintenance work, broad code searches, repetitive transformations and test expansion, where human experts can assess outputs against clear constraints.
The workforce argument needs cleaner evidence
Epic laid off more than 1,000 employees in March 2026, with the company attributing the cuts to Fortnite engagement decline and financial pressures. CEO Tim Sweeney said the layoffs were not performance-based. [4]
That timing has understandably encouraged people to treat Epic’s AI-first posture as proof that AI caused the layoffs. Available evidence does not establish that causal link, and saying it does would be more confident than the facts allow.
Epic’s public position is that AI assists engineers rather than replaces them. Reporting on developer concerns shows why workers remain unconvinced: efficiency tools can still change hiring plans, team sizes and which skills employers value. [5]
The sharper question is not whether one model literally replaces one programmer. It is whether management uses output gains to build more ambitious projects, shorten timelines, cut headcount, or outsource the risk of reviewing generated code onto fewer remaining staff.
Lawyers and security specialists have also warned that generated code can create confidentiality, licensing and accountability problems. If a model produces a flawed implementation, “the tool wrote it” is not a defence when the shipped game leaks data or breaks. [6]
Epic’s policy move reaches beyond code
Epic has also announced an intention to change the Unreal Engine licence so AI systems can train on Unreal Engine and MetaHuman outputs by default, with developers able to opt out for individual games. [9]
That policy was announced, not implemented. As of October 2026, the updated EULA had not taken effect and no effective date had been announced. The current agreement still restricts training AI on those outputs. [9]
This matters because code-generation tools and training rights are different systems. One concerns Epic using AI to build its own engine. The other concerns what third parties may do with content produced through that engine.
The community reaction to Epic’s AI MegaJam shows the trust problem. Epic initially framed AI use as a requirement, then walked that back after criticism. A voluntary game jam is not production development, but it reveals how quickly mandatory framing changes the conversation. [7] [8]
Epic’s bet is that faster iteration and fewer technical failures will eventually make the argument for it. That is plausible for a problem as unglamorous and expensive as non-deterministic cooking, provided the company can demonstrate repeatable improvements rather than slogans.
For players, the evidence will arrive in ordinary patch behaviour: smaller downloads where compression changes are claimed, fewer recurring crash clusters, fewer hotfixes for build mistakes, and engine updates that do not trade visible performance problems for internal development speed.
Frequently Asked Questions
What are non-deterministic cooking bugs in Unreal Engine?
Non-deterministic cooking bugs occur when the cooking process produces different packaged outputs from the same input, settings, and target platform. This means that identical game content can result in different builds on separate runs, causing patch churn, broken builds, and platform-specific issues. These bugs affect the reliability of game builds that players download and install.
How does Epic Games use AI to fix cooking bugs?
Epic uses AI tools like Claude Code and OpenAI’s Codex to analyze the large Unreal Engine codebase, trace inconsistent file handling or ordering, suggest code changes, generate test cases, and compare behavior across build configurations. AI accelerates the identification of dependencies and proposes consistent edits, but human engineers review and decide on the correctness of these changes.
What impact do AI-assisted fixes have on Fortnite patch stability?
Fixing non-deterministic cooking bugs with AI-assisted work can reduce patch churn and broken builds, improving development cadence. However, AI-written code must still pass the same rigorous testing, profiling, and certification processes as manually written code before benefits like fewer crashes or faster patches are realized.
Why is determinism important in game build pipelines?
Determinism ensures that the same inputs produce identical outputs, which is critical for debugging, automated testing, and patch reliability. Without determinism, developers cannot confidently identify whether changes in builds are intentional fixes or build noise, leading to larger patch sizes, chasing false regressions, and reduced confidence in test results.
Which AI tools does Epic Games use for code generation?
Epic Games uses Claude Code and OpenAI’s Codex as AI tools to assist in code and feature development, test-suite maintenance, shader compression, and rendering layer rewrites. These tools help automate and accelerate parts of the development pipeline but require human oversight for architecture specification and code review.
How we researched this
This article was assembled from 3 published articles, 9 cited references.
Nothing here is based on hands-on testing. Where a figure or finding appears, it belongs to the source cited beside it, and the writing says so rather than implying otherwise. Every source is listed below so you can check it.
Sources
"We are more concerned about the risks of moving too slowly": Epic get more specific about genAI use in Unreal Engine and Fortnite development — Rock Paper Shotgun
Epic VP says AI code tools have stomped out decade-old 'non-deterministic cooking bugs' in Unreal Engine — Game Developer
How to Standardize AI Code Generation Across Your Development Team | IBM
Fortnite Dev Understands The Fear That "AI Is Going To Take All Our Jobs" - GameSpot
"Just because you can order at a restaurant doesn't mean you're a chef," lawyer says of AI vibe code
Epic AI MegaJam challenges developers to build a game in 4 days with AI
Epic announces game jam where you have to use AI, then walks back the requirement
Epic is updating its EULA to allow AI training on … | GameDev.net
Related Articles
Epic Games Store AI Launcher
Explore the Epic Games Store AI launcher, its performance, bugs, and how AI is reshaping game development and the PC gaming industry.
Epic Games AI-First Development and Shooter Delay Explained
Learn about Epic Games' AI-first development approach and the delay of their Marvel and Star Wars shooter with insights on AI's role in game creation.
AI Cloning in Game Development
Explore how AI cloning concerns affect game development and playtests, and what studios do to protect their work before launch.
Steam Next Fest 2026 AI Controversies in Indie Games
Explore Steam Next Fest 2026 AI controversies, demo risks, and Steam's AI disclosure rules affecting indie game developers.