UE5 + CPP - practical case almost full automation

# Practical case: UE5 + C++ + full automation. How the AI writes all the code, dislominates and checks the result himself

## Context: Why This Case Is Important

Unreal Engine 5 is not a web application. It's not a CRUD service. This is not a front-end on React. This is:

- **Millions of code lines** in C++ in the most codebase engine

- **Manually controlled**: most actions in UE5 are done through GUI - clicks, drag and tuning parameters manually

- **Kittale architecture**: modules, plugins, subsystems, the relationship between which is not obvious

- **Bluprints**: visual programming, which is not obvious to automate

- **High entry threshold**: to write under UE5, you need to know C++, engine architecture, camera system, blueprints, render-pyplay

This is not the project** where he “gave the agent a task and he did.” This is a project where most “amplifiers for the introduction of AI” would say: “Matnotization is impossible here. It's too complicated. Too much manual control. Too much implicit knowledge.”

And yet. Now in this project **I is writing all the code in C++ itself, dislikes, restarts the execution environment and checks the result. All development and implementation of features is the setting of the problem of speculation and control in the process. 98% of the time - just look at the monitors with one eye.

---

## Problem: UE5 — manually controlled editor

The main difficulty of UE5 for automation is **the absence of API**. Python in UE5 allows you to call almost everything in the editor programmatically. The problem is the other: **action chains are very complex**.

One action in the editor is one team. But the real task is the **chain of dozens and hundreds of actions**, which must be performed in the right order, with the correct parameters, with the processing of errors at every step.

Examples of complex chains:

- **Writing the blupins in the editor**: create a node graph, connect them, configure parameters, compile, check. It’s not an obvious process that requires an understanding of UE5 visual programming.

- **Creation and adjustment of actors**: create an ac., add components, customize properties, tie to the level, check the render.

- **Configure materials and shaders**: create a material, configure parameters, connect textures, apply to the lush, check visually.

- ** Work with landscape and lighting**: create a landscape, adjust layers, place light sources, bake the lighting.

Each of these actions can be called through Python. But **cake system destruction is a non-trivial task. Need skills that control the sequence of actions, process errors, check intermediate results.

---

## Solution: the angular environment with a full cycle of execution

Instead of trying to integrate AI into the existing UE5 development process, we ** built an agent-generating environment** that closes the full cycle:

````

Setting a task (person)

↓

Analysis and planning (I + person)

↓

Writing code in C++ (AI)

↓

Compilation (automatically)

↓

Launch of the implementation environment (A)

↓

Testing / result (AI)

↓

Debag with errors (AI)

↓

Iteration to success

↓

Verification of the result (person)

````

The key difference from the standard approach is **gentiuse not just writing code**. The agent **manages the entire cycle**: compiles, triggers, tests, disdains, restarts. Man stays at two points: setting a task and verification of the result.

---

## What is Automated: Full List

Here is a complete list of what is automated on the project:

### Code development

- **Writing code in C++**: the agent writes code by spectacling, compiles, fixes compile errors

- **Search for modules and analysis of the required code in the engine**: the agent is looking for the necessary code in the code base UE5 through indexing (< 50ms to request)

- **Refactoring C++ of the project code**: the agent of the refactorate according to the specified rules, checks that nothing is broken

- **Debug**: agent parsit logs, finds root cause, fixes

- **Compile**: automatic compilation with error parsing

- **Build**: automatic assembly of the project

- **Archive project**: automatic project archiving

- **New code plugin**: automatic creation of new plugins according to the template

### Blueprints

- **Writing blupins in the editor**: automation of chains of creating graphs of node

- **Glasing blueprinted function for testing**: the agent launches blupint function and checks the result

- **Blueprint to C++**: written **native software converter** (not AI-conversion, namely software converter). Converts the Bluetooth in C++ code. Converter in the process of continuous improvement.

### Testing and Debag

- **Hand range environment**: Agent Runs UE5 Editor or PIE for testing

- **Enghead analysis**: agent parsite logs UE5, finds errors, warnings

- **Analysis of crash UE5**: agent parsit krash-dump, finds the cause, fixes

- **Visual check**: screenshots, sceneconfiguration to compare

### Content generation (in process)

- **Artist sand content generation from the mix**: attempts to automate the arrangement of the mix in the scene

- ** Materials generator**: attempts to automate the creation and configuration of materials

---

## Scope automation: exaggerated for any game studio

If you look at the list above, it becomes clear: **scope automation is already exorbitant for any game studio**.

It's not "writing code with autocompilation." This is a **complete development cycle**: from writing code to compilation, launch, testing, bragging, refactoring, creating plugins, converting blupins to C++.

This is not a “developer’s assistant.” This is a **executive layer** that closes 90% of routine tasks in development under UE5.

For game studio, this means:

- The developer does not write the code with his hands. He sets the task of spectacle.

The developer doesn't shake hands. Agent parsice logs and paint.

The developer does not compile with his hands. The agent compiles and fixes errors.

- The developer does not create plugins with their hands. The agent creates according to the pattern.

- The developer does not convert blupints into C++ with hands. The native converter makes it software.

The developer remains at two points: **setting and verification of the result**. The rest is an agent.

---

## How it works: components

###1. Skills for UE5

Python in UE5 allows you to call almost everything in the editor programmatically. We wrote **skift of Skills** (Python-scripts) that orchestracate chains of action:

- **Skill compile**: launches project assembly, compilation errors parsitis, returns the structured output to the agent

- **Skill of editor launch**: launches UE5 Editor in headless mode or with a minimum GUI

- **Skill of PIE*: launches Play In Editor to Test Gameplay

- **Skill of creation/configurement of actors**: through Python API creates actors, configures components

- **Skill of writing blueprints**: orchestras the chain of creation of graphs of node

- **Skill of blueprinted function**: launches blupint functions for testing

- **Lesk scans**: parsite logs UE5, finds errors, warnings

- **Skill analysis of crash**: parsite krash-dumps, finds the cause

- **Skill screenshot/capture**: takes a screenshot or captures the scene status for visually check

- **Skill of creating a plugin**: creates a new plugin according to the template

- **Skill of archiving of the project**: archives the project

Each skilles is a **executable code**, not instructions for humans. The agent calls the skell directly.

### 2. Native converter Blueprint to C++

It's a **non-Avia conversion**. This is a **program converter** that:

- Reads the blueprint structure

- Converts node graph to C++ code

- Keeps logic and connections

- Generates Valid C++ Code, which is compiled

The converter is written natively, without AI. This guarantees **determined**: the same blubfront is always converted to the same C++ code. No hallucinations. No “similar, but not” results.

Converter in the process of continuous improvement: new types of nodes are added, the processing of edge cases improves, the generated code is optimized.

### 3. Feedback Loop

This is a ** critical component**. Without it, the agent cannot verify the result of his work.

Feedback loop includes:

- **Compilation**: agent writes code → starts the compilation → if errors, parsite them → fixes → compiles again

- **Nap**: Agent compiles → launches the environment → if the crash, parsite logs → fixes → launches again

- **Testing**: Agent Runs PIE or Blueprinted Function → Checks Behavior → If Not Meetings → Fixing → Testing Again

- **Ledoverse analysis**: agent parsite logs UE5 → finds errors → fix

- **Kaser analysis**: agent parsite crash dups → finds the cause → fixes

- **Visual check**: where possible - screenshots or consumption capture for comparison

Agent** does not expect a person** to check. He's checking himself. A person is connected only for the final verification.

### 4. Search by codebase: indexing

The UE5 code base is millions of lines. Naked grep on such a base is useless: seconds to request, thousands of matches.

We have built **indexing codebase**:

- **Static indexation**: index the UE5 headers and source code for the engine when connecting the engine. Index contains: headlines, function signatures, key classes

- **Dynamastic indexation**: when the project files changes, the index is reassembled incrementally

- **Search for index**: request is **< 50ms**, withdrawal is immediately a piece of code with context

It's not AST Search. This is **grep + indexing + shell-scripts**. It works faster and easier than AST Search on such a codebase.

The agent uses this search through the skylly: requests a function, class, signature – gets a relevant piece of code in a millisecond. Does not spend tokens to scan the entire base.

### 5. Memory and context: memory.md

Long tasks in UE5 (writing a new module, plugin migration) can occupy the operation hours of the agent. The context window is overflowing. Compaction is inevitable.

Solution: **memory.md**.

````

Before compact: write in memory.md the current task, progress,

Key Solutions, Restrictions and the Next Steps.

After the compact: read memory.md and continue to work.

````

Three lines of the product. The agent himself discues the critical context into the file before compactization and loads back after. Nothing is lost.

For very long tasks, add **decisions.md**: all architectural solutions with justification. After the compact agent reads both files and restores the full context.

##7. Specification of the task

Each feature begins with **speak. Don't "make X." A structured document:

````

Task: [name]

Purpose: [what should happen]

Completion criteria: [specific verifiable conditions list]

Restrictions: [what can not be touched, which modules do not change]

Architecture: [what modules are affected, how related]

What not to do: [Overall prohibitions]

Testing: [how to check what works]

````

The speck is written ** in dialogue with AI** in 20-30 minutes. AI asks clarifying questions, helps to formalize edge cases, reveals hidden requirements.

It's not bureaucracy. This is a contract between a person and an agent. Without a contract, the agent does in his own way. He executes with the contract.

---

## Work process: what does the typical day look like

### Morning: Setting Tasks

I Formulaate 2-3 tasks in specges. Each skater is 20-30 minutes of dialogue with AI. Total: 1-1.5 hours for planning.

### Day: Agents Work

I'm putting agents on tasks. Every agent:

1. Reading the spectacle

2. Analyzes the code base through indexing

3. Writes code in C++

4. Compilations

5. If compile errors, fixes

6. Launches the fulfillment environment

7. If the crash - parsice logs, dislikes, fixes

8. Tests in PIE or through blueprinted function

9. If the behavior does not meet expectations, fixes

10. Repeating to success

I don't sit or watch as an agent prints the code. I switch between tasks. While Agent A is compiling, I will formulate a task for agent B. While Agent B is testing, I verify the result of Agent A.

### Control: with one eye in monitors

98% of the time is **observation. Not active intervention. Observation.

I watch:

- Where's the agent going? In the right direction?

- Isn't the fixate in the fixes?

Doesn’t the architectural limitations violate the specutia?

- Does he do the extra?

If the agent went wrong, **analysis and adjustment of instructions**. Don’t “stop, I’ll do it myself.” “Here you misunderstood the limitation. There is a lack of context. We need a different approach.” I'm adjusting the instructions, the agent continues.

### Evening: verification

I'm checking the results. I don't read every line of code. I watch:

- Is the architecture right? Is the modules related right?

- Contracts are complied with? Is the API broken?

- Isn't that too much? The agent didn't do what he didn't ask?

- Are the tests? Does PIE work as expected?

That's 5-15 minutes for a task. It's not a clock. Minutes. Because the **gent agent has already checked everything himself** through the loop feedback. I check only the judgment level: whether the decision is correct in principle.

---

#Metricas: what has changed

### Speed of analysis and preparation

The Parameter Before | Now |

|---------------------------

| Dive into the new module UE5 | 1-2 weeks | 2-4 hours |

| Analysis of the code base for the task | 2-3 days | 1-2 hours |

| Writing the Sake | 1 day | 30 minutes |

| Search for the right code in the database | Minutes-clock | < 50ms by index |

It's not +20%**. This is **100x** at the stage of analysis and preparation.

### Speed of development

The Parameter Before | Now |

|---------------------------

| Writing a feature of average complexity | 1-2 weeks | 1-2 days |

| Debag | Days | Minutes-hours (agent itself) |

| Compilation + error lock | Watches | Minutes (agent itself) |

| Testing in PIE | Watches | Minutes (agent itself) |

| Bluprint conversion in C++ | Days (manufactured) | Minutes (Native Converter) |

| Create a new plugin | Watches | Minutes (agent by template) |

### The Role of Man

The Parameter Before | Now |

|---------------------------

| Hand code | 80% of time | 0% |

| Debag with hands | 10% of time | 0% |

| Setting tasks | 5% time | 40% of the time |

| Verification and control | 5% time | 60% of the time |

The man does not write the code anymore. A person sets tasks and verifies the result. It's not a "manager." This is the **architect of intentions.

### Percentage of intervention

Of the 10 tasks:

- **7-8 tasks** the agent closes completely without human intervention

- **2-3 tasks** require adjustments in the process (the agent went wrong)

- **0-1 problem** requires manual intervention (architectural solution that the agent cannot take)

98% of the time is surveillance. Not active work. Observation.

---

## Rakes that bypassed

## Rake 1: “Give the agent a task and he will do”

The first attempt: gave the agent the task “write the module X for UE5”. No sinter. Without context. No restrictions.

Result: The agent wrote the code that is compiled, but** does not work in the context of UE5**. Because I did not know about the system of actors, about the life cycle of components, about the features of the render-pipeline.

**Solution:**Speed with architectural context. Not “write the module”, but “write the module X, which integrates with subsystem Y through the interface Z, taking into account the limitations of W”.

### Rooks 2: “Blueprints cannot be automated”

Blueprints are visual programming. They don’t seem to be automated. But Python in UE5 allows you to call almost everything in the editor software. The problem was not the absence of an API, but in the complexity of the action chains.

**Solution:** Skills that orchestra the chain of creation of node graphs. And the native Blueprint to C++ converter for those cases when you need to convert bluprits into code.

### Rakes 3: “The code base is too big for an agent”

Millions of lines. The agent cannot load everything into the context.

**Decision:** Indexation. Search by index for < 50ms. The agent does not load the entire base. It searches for a specific code through search skillas and gets only a relevant piece.

### Rake 4: “Agent loses the context on long tasks”

Compaction. The window is overflowing. The agent forgets what he did.

**Solution:**me.md + decisions.md. Three lines of the product. The agent himself discards the context before the compact and loads after.

### Rakes 5: “The agent fixes the wrong mistakes”

The agent disdains, but fixes the symptoms, not the cause. Spends iterations on superficial fixes.

**Decision:** In the instruction for the debagg added: “First determine the root cause. Do not fix the symptoms. If you can’t determine the reason for 3 iterations, stop and ask for help.”

### Rake 6: “Agent does more”

The agent got the task “add the function X”. Added the function X. And at the same time refactoryl module Y. Rewrote tests for Z. And updated the documentation.

**Decision:** In the spectacle explicit section "What Not to Do". And in the instructions of the agent: “Do only what is in the spectacle. Not refactors. Don't improve. Don't optimize. Only a task of specutia.”

### Rake 7: “AI-converting of blueprints is unstable”

The first attempt to convert blueprints into C++ via AI gave unstable results: the same blueprint was converted in different ways, the code generated was not always compiled.

**Solution:** Written **naded software converter**. Deterministic. The same bluprint is always converted into the same C++ code. No hallucinations. Converter in the process of improvement: new types of nodes are added, the treatment of edge cases improves.

---

## Tools

| Component | What to Use | Why |

|---------------------------

| Agent | Claude Code / Codex | Write Code, Debag, Cycle Management |

| Skilles | Python scripts | Management UE5: compilation, start, PIE, Actors, Bluprits |

| Blueprint to C++ | Native Software Converter | Deterministic Blupin Conversions to C++ |

| Search | greg + indexation + shell | Search by codebase UE5 for < 50ms |

| Memory | memory.md + decisions.md | Context preserving the context under compaction |

| Verification | PIE + blueprinted functions + logs + crash dams | Automatic result verification |

| Speka | Dialogue with AI, 20-30 minutes | Contract between a person and agent |

| Logging | Automatic session collection | Analysis of patterns, optimization of products |

---

## Why Game Studios Don't Pay Attention

This case was offered to a small number of game studios. Reaction: **not even allowed to pay attention**.

Why? Because ** corporate filters do not miss this possibility**.

Game studios think in the paradigm:

- "We have developers, they write code"

“We have artists, they make content”

“We have QA, they are testing”

“Why do we need automation if we have people?”

They don't see that:

Developers spend 80% of the time on a routine that can be automated

Artists spend hours on the placement of interference, which can be automated

- QA spends days on manual testing that can be automated

- Conversion of Bluetooth in C++ is done manually, although there is a native converter

They do not see that **scope automation is already exorbitant. That it is possible to automate not "codewriting", but ** the entire development cycle**: from code to compilation, launch, testing, debaggage, refactoring, bluprint conversion, creating plugins.

Corporate filters are not “we don’t want to.” It’s “we don’t know it’s possible.” And until they understand, they will continue to do what can be automated.

---

## What does it mean for the industry

This case destroys several myths:

**Myth 1: “Difficult projects cannot be automated”**

UE5 is one of the most challenging automation projects. Millions of C++ strings, manual-controlled editor, complex architecture, blueprints. And yet – complete automation of the development cycle.

If UE5 can be automated, you can automate anything. The issue is not the complexity of the project. Question in the correct architecture of the agent environment**.

**Myth 2: “AI can only write code”**

AI doesn't just write the code. AI **manages a full cycle**: compiles, triggers, tests, disdain, restarts, converts blupins, creates plugins, analyzes crashes. It's not an autocompillette. This is the **executive layer**.

Myth 3: “Blueprints cannot be automated”**

You can. Python in UE5 allows you to call almost everything in the editor programmatically. The problem is not the absence of an API, but in the complexity of the chains. The Skilles are orchestrating chains. The native converter converts bluprits to C++ deterministic.

Myth 4: “You need to read every line of code”**

You don't have to. The agent himself checks through the feedback loop. A person checks only the judgment level: whether the solution is correct in principle. That's 5-15 minutes for a task, not a clock.

Myth 5: “Automation is for simple tasks”**

On the contrary. The more difficult the task, the more routine there is. The more gains from automation. Simple tasks and so do quickly. Difficult tasks - where automation gives 100x.

---

## Conclusion

Project on top of UE5 with a huge code base in C++. Manually operated. Millions of lines of code. Blueprints. And yet, nevertheless:

- **AI writes all the code in C++ itself**

-**I is dismantling by himself** (parosite logs, paint)

- **I compiles, build, archives himself**

- **I restarts the fulfillment environment itself**

- **I tests itself** (PIE, blueprinted functions)

- **Native converter Blueprint to C++** (deterministic, not AI)

- **I creates plugins itself**

- **I analyzes the crash itself**

-** The person sets the tasks of the specut and control**

- **98% of the time - one eye observation**

Scope Automation – **extreme for any game studio**. Writing code, module search, engine code analysis, refactoring, debug, compile, build, archive, new plugin, blupint, converting blupins to C++, launching blueprinted functions, log analysis, paint analysis, artist content generation.

It's not the future. This is **present. August 2026. Works. Every day.

Key components that make this possible:

1. Skills for managing the environment (not only writing code)

2. Native converter Blueprint to C++ (deterministic)

3. Feedback loop (the agent checks the result)

4. Codebase indexation (search for < 50ms)

5. memory.md (construction context at compaction)

6. Spope as a contract (do not "make X", but clear criteria)

7. Setting up the task + verification (man does not write code)

It's not magic. This is a **engineering approach to building an agent environment**. And he's reproduced. Not just for UE5. For any project where there is a routine that can be automated and the judgment that remains a person.

And game studios that do not pay attention because “corporate filters do not miss” – they will continue to do what can be automated. And in a year, it will wonder why competitors who have automated are doing 10 times more content for the same budget.

It's their choice. But that doesn’t mean automation is impossible. It means they're not ready. The one who is ready is already doing.

---

# Practical case: UE5 + C++ + full automation. Reverse Engineering, Editor UI migration and 350B parameters on the free tariff

## Problem level: reverse engineering UE5 architecture

Forget about “write a CRUD-endpoint”. The tasks on this project are **reverse engineering codebase UE5** to understand:

- What class to inherit

- What modules depend on which

- What can be done from Editor-only to Runtime

- What addictions will break the compilation in Shipping build

- How to remodel the architecture of widgets so that they work without Editor modules

These are the tasks that require **highest level of knowledge of the UE5** architecture: which modules are responsible for, how Editor and Runtime are related, which subsystems depend on the Development modules.

And all this is doing AI. The man only controls.

---

## The Last Major Task: The Migration of Content Browser

### What is Content Browser

Content Browser in UE5 is the main interface of the editor for asseth management. It's not just one widget. These are **10+ dependency modules** Editor and Development modules:

- "ContentBrowser"

- `ContentBrowserData`

- `ContentBrowserAssetData`

- `AssetTools`

- `AssetRegistry`

- "SourceControl`

- `EditorStyle`

- `Slate` / `SlateCore`

- `UnrealEd'

- And others

None of these modules ** does not work in Shipping build**. Moreover, even **compiling code will fall** if you try to use them outside the Editor context.

### The scale of the task

- **100+ .cpp files** main Content Browser

- **100+ .h files** headers

- **50+ .cpp files** related modules that need to be inclined and forcrework

It’s not “rewriting a couple of functions.” This is a **complete migration of the architectural module** from the Editor-only context to Runtime context.

### Target

Create **yrtime system**: in-shipping-build runtime editor with exhaust time assets. I mean,:

- The editor works in the Shipping build (not only in the Editor)

- Assets are managed in Runtime (not only in Editor)

- Content Browser operates without Editor modules

- Everything is compiled and works in Shipping

### How it was done

**AI conducted a reverse engineering:**

1. Analyzed the structure of Content Browser: what classes, what addictions

2. Determined from which class to inherit for the Runtime version

3. Identified the Editor-only dependencies that need to be replaced

4. Cloned and forkal adjacent modules

5. Rewriting code by removing Editor-only dependencies

6. Compiled, fixed errors

7. Tested in Shipping build

8. Repeated to success

** The man only controlled:**

- Set the task of specutia

- Observed the progress

- Adjusted the instructions if the AI was not there

- Verified the final result

### Time

**30+ hours** AI work. Man didn't write code. The man didn't fight. The man did not compile manually. The man observed and corrected.

---

## Another task: File Dialog widget

In UEditor there is a widget **File Dialog** – a dialog of opening/saving files. He's also Editor-only.

What has been done:

- Created **cloth File Dialog**

- Created **UuserWidget**, which is fully operational **in Shipping**

- Widget does not depend on the Editor modules

- Compiled and working in Shipping build

This is the same category of tasks: ** take the Editor-only component and make it Runtime compatible**, while saving functionality.

---

## Difficulty Level: Why It's Not "Just Code"

These tasks require understanding:

**1. Architecture of UE5 **

UE5 has a clear division into modules:

- **Runtime modules**: work in Shipping

- **Editor modules**: work only in Editor

- **Development modules**: work in Development, but not in Shipping

Content Browser depends on the Editor and Development modules. To make it Runtime compatible, you need to:

- Understand what the dependencies of Editor-only

- Find Runtime Alternatives

- Rewrite code without Editor-only calls

- Save functionality

**2. Class inheritance system**

UE5 uses a deep hierarchy of classes. Content Browser is inherited from Slate widgets that depend on the Editor context. It is necessary:

Understand the hierarchy of inheritance

- Determine what class you can inherit in Runtime from

- Rewrite classes so that they do not depend on the Editor

- Save Behavior

**3. Assembly system UE5**

UE5 has a complex assembly system:

- "- Build.cs` files determine the dependencies of modules

- `ModuleRules' determine which modules are available in what context

- Shipping build eliminates Editor modules

It is necessary:

- Understand the assembly system

- Change the dependencies of modules

- Make sure the code is compiled in Shipping

- Don't break other modules

**4. Slate UI system**

Slate is the UI UE5 framework. Content Browser uses Slate widgets. It is necessary:

- Understand Slate architecture

- Rewrite widgets without Editor-only dependencies

- Preserve visual behavior

- Ensure compatibility with Runtime

It's not what the car complit does. This is the **architectural work of the level of Principal Engineer**, which usually takes months for a team of several people.

---

# Tools: UECortex – MCP Tools Server for UE5

### What is it

**UECortex is a plugin for UE5, which is **MCP (Model Context Protocol) Tools Server**. It provides the agent with tools for managing UE5:

- Compilation of the project

- Start Editor

- Running PIE (Play In Editor)

- Creation and configuration of actors

- Blupint management

- Analysis of the logs and crashes

- And other operations

### How it is written

UECortex**written through AI**. Not a man. AI generated the plugin code, the person verified.

### Key feature: self-maintaining instruction

UECortex contains **instructions** that allow AI:

- **Everything is always quickly understood** how the plugin is arranged

- **How to fix the toe** if it breaks

- **How to add a new toe** if you need new functionality

It's not just a code. This is **self-documenting system**, where AI can serve itself. If the too breaks - AI reads instructions, understands the problem, fixes. If you need a new trunk - AI reads instructions, understands architecture, adds.

It's an **evolving system**. She's not static. It grows with the project. And AI is raising it.

---

## Model: 350B Parameters, 200K context, free rate

All of the above is made on the model, which the user calls the **«big pickle”**:

- **350B parameters**

- **200K context**

- **Free rate**

It's not Claude Opus for $ 200/month. This is not GPT-5 for the corporate budget. This is a free model** that:

- Conducts reverse engineering code base UE5

- Migrating Content Browser from Editor to Runtime

- Cloning and forecasts 50+ modules

- Writes, compiles, disdain, tests

- Manages the entire development cycle

And it works. 30+ hours on the task of the level of Principal Engineer. At a free rate.

This destroys the myth that “expensive models are needed for serious work.” It's not necessary. Need **right architecture of the agent environment**: skillas, loop feedback, indexation, memory.md, spectacle. The model is a performer. Architecture is what makes the performer effective.

---

#Metricas: what has changed

##0 Speed

| Parameter | Previously (manually) | Now (AI) |

|---------------------------

| Migration Content Browser | Impossible for one person (months for team) | 30+ hours |

| Reverse engineering module | Days-See-Week | Watches |

| Writing code | Watches-days | Minutes |

| Compilation + fixed | Watches | Minutes (AI) |

| Debagh Krasher | Days | Minutes-Hours (Ai itself) |

| Create a new plugin | Days | Minutes-hours (AI) |

### The Role of Man

The Parameter Before | Now |

|---------------------------

| Writing code | 90% of the time | 0% |

Reverse engineering | 5% time | 0% (Ai) |

| Setting tasks | 2% time | 40% of the time |

| Verification and control | 3% time | 60% of the time |

### Percentage of intervention

Of the 10 tasks:

- **7-8 tasks** AI closes completely without intervention

- **2-3 tasks** require adjustments in the process

- **0-1 problem** requires a manual architectural solution

98% of the time is surveillance. Not active work. Observation.

---

## Rakes that bypassed

### Rakes 1: Editor-only dependencies are not obvious

Content Browser looks like a single module, but actually depends on the 10+ Editor modules. AI at the timeline did not understand what the dependencies of Editor-only.

**Solution:** In the specutter added a clear list: “Check every #include. If it is from the Editor module - replace the Runtime alternative. If there is no alternative, cloned and fork.”

### Rakes 2: Compilation falls on Editor-only challenges

AI wrote the code that compiled into the Editor, but fell in Shipping. Because he used Editor-only functions.

**Solution:** Feedback loop includes a compilation ** in Shipping build**, not just in the Editor. If the compilation falls, AI parsices errors and fixes.

### Rakes 3: Hierarchy of Inheritance is Difficult

AI tried to inherit from the Editor-only classes. It doesn't work in Runtime.

**Solution:** AI conducts a reverse engineering hierarchy: finds a basic Runtime class, from which you can inherit. If not, it creates a new one.

### Rakes 4: Adjabbling modules also Editor-only

Content Browser depends on related modules (AssetTools, SourceControl, etc.), which are also Editor-only. You need to cloning and forging them too.

**Solution:** AI analyzes the dependency graph, determines which related modules are needed, clones them, removes Editor-only dependencies.

### Rakes 5: 50+ files — AI loses context

When working with 50+ files, AI loses context. Compaction is inevitable.

**Solution:**me.md + decisions.md. AI discards the context before the compact and loads after. Plus: work on modules, not all files at once.

---

## What does it mean for the industry

This case destroys several myths:

**Myth 1: "AI can't do architectural work"**

Content Browser migration from Editor to Runtime is an architectural work at the Principal Engineer level. The AI did it in 30+ hours. The man only controlled.

**Myth 2: “We need expensive models”**

Everything is done at a free rate. 350B parameters, 200K context. No need for Claude Opus for $200/month. You need the right architecture of the agent environment.

**Myth 3: “UE5 is too complex for automation”**

UE5 is one of the most difficult engines. Millions of lines of code, complex module architecture, Editor-only dependencies. And yet, complete automation. If UE5 can be automated, you can automate anything.

Myth 4: "AI can't do reverse engineering"**

AI conducts reverse engineering codebase UE5: understands the hierarchy of classes, module dependencies, build system. It’s not “write a function in a specutian.” It is ** understand the other person's architecture and rebuild it**.

Myth 5: “Plugs should be written by a person”**

UECortex – MCP Tools Server for UE5 – is written through AI. And contains instructions for self-maintenance. AI himself wrote the plugin, it itself serves, he adds new tulles.

---

## Conclusion

Project over UE5. Reverse engineering codebase. Immigration Editor UI to Runtime. 100+ files, 10+ dependency modules. And all this is doing AI.

- **I conducts reverse engineering** codebase UE5

- **I migrates Content Browser** from Editor to Runtime (30+ hours)

- **I clones and forks** 50+ related modules

- **AI writes, compiles, disdains, tests** himself

- **I created UECortex** – MCP Tools Server for UE5

- **UECortex self-maintaining**: AI fixes and adds to the tulas

- **Man only controls**: sets tasks, verifies the result

- **All on the free rate**: 350B parameters, 200K context

It's not the future. This is **present. August 2026. Works. Every day.

Key Components:

1. UE5 Skills (compilation, Start, PIE, Log Analysis)

2. UECortex – MCP Tools Server with self-maintaining instructions

3. Feedback loop (compilation in Shipping, testing, debag)

4. Codebase indexation (search for < 50ms)

5. memory.md + decisions.md (context preservation)

6. Spoken as a contract (clear criteria, restrictions)

7. Setting up the task + verification (man does not write code)

It's not magic. This is a **engineering approach to building an agent environment**. And he works on tasks that previously required the command of Principal Engineers and months of work.

And those who say “AI can’t do serious work” – they just haven’t tried. Or tried without the right architecture. And got a bad result. And they concluded that “AI doesn’t work.”

But AI works. You just need the right architecture. And then even a free model of 350B parameters does what was previously impossible.

---

#Economics of the project at UE5: from plans for hiring a senior team to fuck from what AI materializes the transcendental tasks

## How it was planned a year ago

A year ago, I didn’t hire people. I **planned to hire** and wrote technical tasks. For each complex feature - a separate TK, a separate search for a senior specialist, a separate budget.

A typical plan looked like this:

**Runtime assets:**

- TK for 20 pages

- senior asset programmer search ($10k-15k/month)

- 2-3 months per prototype

- Budget: $30k-45k only on proof of concept

**Runtime TTF/OTF fonds:**

- TK for 15 pages with description of parsing, glyph rendering, font atlas generation

- senior search typography/graphics engineer (rare specialization, $12k-18k/month)

- 2-3 months per prototype

- Budget: $36k-54k

**UI Editor Migration (Slate → UICore):**

- TK for 30 pages with description of the architecture of Editor modules

- Team search for 3-4 senior UE5 engineers

- 4-6 months for migration

- Budget: $150k-300k

**MIDI assets:**

- TK for 12 pages

- Search for audio/tools programmer

- 2 months per prototype

- Budget: $20k-30k

**Runtime meshes:**

- TK for 18 pages

- Search senior graphics programmer

- 2-3 months per prototype

- Budget: $24k-45k

**Common plan:**

- Recruitment budget and prototypes: **$300k-600k**

- Time to proof of concept all features: **8-12 months**

- Risk: 30-50% of prototypes will not confirm the concept, the money will be burned

It was a **negal economy** for complex UE5 projects a year ago. No one's a one's a question. Everybody did that.

---

## What Happened When I Set Up AI to Work with UE5

I didn't hire seniors. Instead, I took the time to ** tuning the intelligence environment** to work with UE5:

- Skills for Editor management, compilation, PIE, log analysis

- UECortex (MCP Tools Server) with self-maintaining instructions

- Indexing of UE5 codebase (search for < 50ms)

- memory.md + decisions.md to save the context

- Blueprint to C++ Native Converter

- Feedback loop with compilation in Shipping build

When this infrastructure was ready, I began to do what was previously impossible: **feeding the formalized TKs, which he wrote for senior specialists, directly AI**.

---

## Lapping point

And now you are sitting, feeding the AI TK, which a year ago was intended for a senior specialist for $ 15k / month. TK for the migration of Editor UI Slate widgets in the shipping usitor module. 10+ Editor modules, 100+ cpp files, Editor-only dependencies that do not work in Shipping, the compilation drops.

And you see how AI:

1. Conducting reverse engineering architecture Content Browser

2. Determines which class to inherit for Runtime version

3. Clots and foresals 50+ adjacent modules

4. Rewrite the code by removing the Editor-only dependencies

5. Compiles, fixes errors, compiles again

6. Launches in Shipping build

7. **And it works**

You look at the screen and fuck. Because this is a **extreme level of complexity of tasks**, which materializes in the **working prototype of the Proof of Concept**.

It’s not “looking like a worker.” It’s not “compiled, but it doesn’t work.” And the full-time PoC** the feature, which a year ago demanded a team of senior specialists and $150k-300k budget.

And it's not one task. This is ** all the tasks of the hiring plan**:

- **Runtime assets** - AI studied the architecture of Asset Registry, Streaming Manager, built runtime system

- **MIDI assets** — AI created custom UAsset type, wrote parser, integrated with audio subsystem

- **Runtime meshes** – AI built a full-fledged dynamic mesh creation system with LOD and collision

- **Slate → UICore migration** — AI migrated Content Browser in 30+ hours

- **Runtime TTF/OTF fonts** – AI has built its font rendering system without Editor context

All this **materialized in the working prototypes**. One by one. No hiring. Without a team. No budgeted for $300k-600k.

---

#And then – sawing with nuances

After the PoC works, the ** finished with the nuances*:

- Optimization of productivity

- Processing edge cases

Integration with other systems

- UI/UX Improvements

- Documentation

- Testing in real scenarios

AI does that too. But now this is not an “impossible task of the Principal Engineer level”. This is a **turdinal revision of the working prototype**. AI is coping with this even faster, because the context is already there, the architecture is already working.

---

## It's fucking up as fast and incredibly awesome

When you see exorbitant tasks materialize into the working code, it is **danging. Not “+20% to speed.” “Not “a little faster than before.” And **great jump**: "You need a senior team for $300k" to "AI does it in a clock."

**It was (a year ago):**

- Planning of hiring senior specialists

- Writing TK for people

- Budget $300k-600k

- 8-12 months to proof of concept

- Risk of failure 30-50%

**Standed (now):**

- TK, written for senior, feeds AI

- AI conducts reverse engineering and materializes PoC

- Budget: $0 on AI (free tariff), $36k-54k per one production engineer

- 3 months before proof of concept all features

- Minimum risk (cheapering)

This is not an incremental improvement**. This is a paradigm shift. Projects that were impossible a year ago due to the budget and the complexity of hiring are now made by one engineer with AI.

---

## What it means in practice

**For startups:**

Projects that required a 15M+ sequencer size for prototyping are now being done on pre-seed or boottrapping. One strong + AI engineer close the action command of 5-7 senior.

**For indie-developers:**

Complex UE5 projects with runtime editor, runtime assets, custom UI - are now available. You don't need a studio with a budget. We need one engineer who knows how to set AI tasks.

**For large studios:**

Those who continue to hire senior teams for every feature lose. Their economy is obsolete. They spend $500k on what a startup with one engineer does for $50k.

---

## Specific example: UE Editor widgets for import testing runtime assets

Here is the specific task I fucked:

**TZ:** Create UE Editor widgets to test runtime assets import from native files to shipping build.

**Difficulty:**

- Editor widgets is usually Editor-only (does not work in Shipping)

- Runtime assets require its import system

- You need to test imports in Shipping build (not in Editor)

- Widgets should work without the Editor context

- Integration with asset, import pipeline, UI system

**What did AI:**

1. Analyzed the existing Editor widgets for import

2. Identified Editor-only dependencies

3. Created a Runtime-compatible version of widgets

4. Integrated with runtime import pipeline

5. Wrote tests that are launched in Shipping build

6. Compiled, checked that everything is working

**Time:** A few hours of AI work. The man only controlled.

**Result:** Fully working widgets for testing import runtime assets in Shipping build. The task, which a year ago required senior UE5 tools programmer for 2-3 months.

When you see how it materializes, you fuck. It’s not “AI helped write code.” This **I solved the problem of the level of Principal Engineer per watch**.

---

# Why does it fuck up as fast

Three factors:

**1. And does not get tired and burns out. **

Senior-specialist works 6-8 hours a day. He needs breaks, weekends, vacations. AI works 24/7. While you're sleeping, AI compiles, tests, fixes.

**2. AI does not switch between tasks. **

Senior-specialist spends time on contextual switches: calls, opinions, planning, communication. AI focuses on one task before completion.

**3. AI is scaling. **

A single specialist does one task. AI can work on several tasks in parallel (with several agents). You set 3 tasks - 3 agents work in parallel.

** Result:** What took months for the senior team now takes days for one engineer with AI.

---

## Why is it incredibly awesome

Because it is a **democratization of complex development**. Previously, complex UE5 projects were available only to large studios with large budgets. Now, any strong engineer who knows how to set AI tasks.

It’s not “AI replaces people.” This **I reinforces one strong engineer to the level of the team. The engineer does not write the code with his hands. Engineer:

- Sets tasks on speculation

- Controls architectural solutions

- Verifies the result

- Corrects instructions when AI goes wrong

AI is a **universal performer who replaces a team of narrow specialists. An engineer is a **setr and vertifier** that ensures the quality.

---

## Conclusion

A year ago, I planned to hire senior specialists under every feature. Wrote TZ. Counted the budget ($ 300k-600k). Scheduled for the time (8-12 months).

Now I **feed the same TK AI**. And I wander away from the fact that the exorbitant tasks are materialized in working prototypes. Runtime assets, MIDI assets, runtime meshes, Slate → UICore migration, runtime fonts – everything works.

It's **hoking up like fast** and**incretious awesome**. Not +20%. Not 2x. And **great jump**: from “you need a senior team for $300k” to “AI does it per watch on a free rate”.

Key components that make this possible:

1. Skills for UE5

2. UECortex (MCP Tools Server) with self-maintaining instructions

3. Codebase indexation (< 50ms)

4. memory.md + decisions.md (context at compaction)

5. Feedback loop (compilation, testing, debag)

6. Side as contracts

It's not magic. This is a **engineering approach to building an agent environment**. And he works on tasks that a year ago demanded the team Principal Engineers and hundreds of thousands of dollars of the budget.

Now one engineer does it. WITH AI. At a free rate. For 3 months instead of 8-12 months.

This is a new development reality. And she's fucking . .

---

# Honest view: AI is not autonomous, but cognitive load drops hundreds of times

## Important clarification, which is often missed

When I talk about the project on UE5, where AI migrates Content Browser from Editor to Runtime for 30+ hours, conducts a reverse engineering architecture, clones 50+ modules - some have an image "pressed the button, went to drink coffee, back - everything is ready."

It's not like that. And it's important to talk honestly, without hype.

**Man is needed. It's all the time. ** There is present. Controls the progress of the task. Because the tasks are extremely complex. AI is not autonomous in the full sense of the word.

But here’s the critically important thing: ** the cognitive load on a person is hundreds of times lower** than if he did it without AI.

---

## What does “control” mean in practice

It’s not “sitting and watching AI type code.” It’s not “checking the result every minute.” This is **observation with the possibility of intervention**.

Specifically on the UE5 project:

**AI does:**

- Reverse engineering architecture UE5 modules

- Search for the right classes and dependencies through indexing

- Writing C++ code

- Compilation and record of compilation errors

- Launch of the implementation environment

- Analysis of crashes and logs

- Iterative Debag

- Testing through PIE and blueprinted functions

**Man does:**

- Sets the task of spectacle (20-30 minutes of dialogue with AI)

- Monitor progress (one eye in the monitor)

- Corrects course if the AI goes wrong

- Makes architectural solutions when the AI can not

- Verifies the final result (5-15 minutes)

**Key:** the person ** does not write the code with his hands**. Doesn't fight his hands. Doesn't compile with his hands. Does not analyze the logs with hands. The person **govers the direction** and ** makes decisions**.

---

Why the cognitive load falls hundreds of times

##9 Previously (without AI):

To migrate Content Browser from Editor to Runtime, you need:

1. ** Immerse yourself in the architecture of UE5** (weeks):

- Read the source 10+ Editor modules

Understand the dependency system

- Understand what classes are inherited from

- Find Runtime alternatives for Editor-only features

2. **Plan migration** (days):

- Determine the order of actions

- Identify the risks

- Make a rollback plan

3. ** Write code** (weeks):

- Cloning modules

- Rewriting dependencies

- Remove Editor-only calls

- Compilation, fix, compile again

4. **Test**(days):

- Run in Shipping build

- Search for crash

- Debate

- Fix and repeat

**Cigitization load:** You keep in your head **everything. Architecture. Dependence. Code. Mistakes. Context. You are the only source of truth. Your brain is running at an exposition of 8 hours a day. In a week, burnout.

**Total: ** 2-3 months of full-fledged work of a senior specialist with maximum cognitive load.

### Now (with AI):

You're setting a spectacle task. AI makes reverse engineering, writes code, compiles, tests, dislikes. You're watching.

**What do you keep in your head:**

- The overall objective of the task

Criteria for success

- Architectural restrictions

Current progress (high-level)

**What you don't keep in your head :**

- Specific code (AI writes)

- Compilation errors (Ai fixes)

- Test results (AI checks)

- Logs and crashes (AI analyzes)

- Implementation details (AI decides)

**Cognicious load:** You hold in your head **only the strategic level**. Tactical level on AI. Your brain is running at 10-20% power. You can think about other tasks in parallel. You're not going to burn out.

**Total:** 30+ hours of AI + several hours of human control. Cognitive load - **hundreds of times below**.

---

## Specific example: Migration Content Browser

### Task:

Migrate Content Browser (10+ Editor modules, 100+ cpp files) from Editor-only to Runtime to work in Shipping build.

### Without AI:

**Day 1-5:** Read the source UE5. I try to understand the architecture of Asset Registry, ContentBrowserData, SourceControl. The head is boiling.

**Day 6-10:** I plan to migrate. What Modules to Cón? In what order? What dependencies to replace? I'm writing a 20-page plan.

**Day 11-30:** I am writing code. I'm cloning modules. I rewrite the dependencies. Compiling, 50 bugs. Fiksuhu. I compile, 30 bugs. Fiksuhu. Compilation – 10 mistakes. Fiksuhu. Compilation – success! I'm going to Shipping, crash. Analyzing the logs. I find an editor-only challenge. Fiksuhu. I repeat.

**Day 31-45:** Test. I find bugs. Fiksuhu. I'm testing again. I find more bugs. Fiksuhu.

**Day 46-60:** Stabilize. I'm optimizing. Documenting.

**Cognet load:** 60 days × 8 hours = 480 hours **maximum concentration**. The brain holds architecture, code, errors, context. Burning is inevitable.

### WITH AI:

** Hour 0-1:** Formulate specution with AI. “Migrund Content Browser to Runtime. Criteria: It works in the Shipping build, retains functionality, does not use Editor-only modules.”

** Hour 1-30:** AI works. I'm watching.

- AI conducts reverse engineering → I see that it has found the right modules

- AI clones files → I see progress

- AI compiles → I see errors in logs

- AI fixes → I see that errors are decreasing

- AI launches in Shipping → I see crash

- AI analyzes crash → I see that he found the Editor-only challenge

- AI fixes → I see that the crash has disappeared

- AI tests → I see that the tests are passing

**My interventions:**

- Hour 5: The AI went wrong, tried to use the Editor-only API. I advise you: “Don’t use Editor modules. Find Runtime an alternative.”

- Hour 15: The AI is stuck on a difficult relationship. I help: “Here we need to clone module X and remove dependence on Y.”

- Hour 25: AI did more - refactoryl the neighboring module. I correct: “Do only what is in specery. Not refactors.”

** Hour 30-31:** I verify the result. I'm checking the architecture. I check that everything works in Shipping. It's all about it.

**Cognitive load:** 31 hours, of which:

- 1 hour - active work (speak)

- 29 hours - observation with the possibility of intervention

- 1 hour - final verification

**Real cognitive load:** ~5 hours of active work + 26 hours of background observation. This is **100 times less** than 480 hours of maximum concentration without AI.

---

Why it's not "complete autonomy"

AI is not autonomous because:

**1. AI does not make strategic decisions. **

When there are two architectural paths, and both are technically possible – the AI does not know which one to choose. It's a man's decision. A person understands business context, long-term consequences, limitations.

**2. And sometimes goes wrong. **

AI can misunderstand the task. Can start doing too much. He can get stuck on the problem. A person sees it and adjusts the course.

**3. AI does not know the implicit knowledge. **

AI doesn’t know that “three years ago we tried this approach, and it didn’t work because of X.” The man knows. The person adds this context.

**4. AI is not responsible. **

If the result is wrong, the responsibility of a person. The man verify. The man makes the decision “it is ready for production.”

Therefore, **man is needed**. But his role has changed qualitatively.

---

## How the Role of a Person Has Changed

### Was: Performer

- Writes code with hands

- Distances with hands

- Compiled with hands

- Tests with hands

- Holds everything in mind: architecture, code, errors, context

- Works 8 hours a day with maximum concentration

- Burns out in a few weeks of intensive work

### Became: The Director and the Verifier

- Sets tasks on speculation

- Monitors progress

- Adjusts course if necessary

- Makes architectural solutions

- Verifies the final result

- Holds only a strategic level in mind

- Works with background load, can think in parallel about other tasks

- Does not burn out

**Key Difference:** A person is no longer**executive**. Man - **architect of intentions and verifier of results**.

---

## Balance: a person is needed, but the load is minimal

Here is an honest picture:

**I is not autonomous. ** A person is present. Controls. Corrects. Make decisions.

** But the cognitive load drops hundreds of times. ** Because:

- AI does tactical work (code, debag, tests)

- A person does a strategic work (striking, verification, decisions)

- The person does not keep in mind the details of the implementation

- A person does not burn out from the maximum concentration

- A person can lead several tasks in parallel

**The result:** One person with AI does a job that previously required a team of senior specialists for months. But it's not "at pressed the button and left." This is “observing and adjusting the course.”

---

## Why it's still a revolution

Even with the fact that a person is needed for control, it is a **repeat, because:

**1. Scaling. **

Previously: one senior specialist = one difficult task.

Now: one person with AI = several complex tasks in parallel (because the cognitive load is low).

**2. Accessibility. **

Previously: complex tasks required expensive senior-experts.

Now: complex tasks are available to any strong engineer who knows how to set AI tasks.

**3. Speed. **

Previously: 2-3 months for a difficult task.

Now: days and weeks for a difficult task.

**4. Quality of life. **

Previously: burnout from the maximum concentration.

Now: background load, the ability to think about other things, lack of burnout.

---

## Conclusion

Honest and without HYIP:

**I is not autonomous. ** A person is needed to monitor, adjust the course, decision-making, verification of the result. The tasks are extremely complex, and AI can not do them completely on their own.

** But the cognitive load drops hundreds of times. ** Because AI takes on tactical work (code, debag, tests, compilation), and the person remains at a strategic level (staging, verification, solutions).

It's not "at pressed the button and went to drink coffee." It is “observing with one eye and adjust the course when needed.”

But even with this clarification, it is a **repeat. One person with AI does the work of a team of senior specialists. Hurry up. Cheaper. No burnout.

It is not complete autonomy. This is ** strengthening one person to the level of the team**. And that is changing the industry.

---

# Honest Addition: How the Attitude to Work Has Changed

## What is not said in technical articles

The last three months, after I set up a full-fledged agent environment for UE5, I felt the difference for the first time in years. And that's not about the metrics. Not about speed. Not about saving the budget.

It's about ** quality of life.

---

## How it was before (semi-legal regime with AI)

Six months ago, even with AI, the process looked like this:

**Morning:**

I open the task. Formulation of the product. AI generates code. Copempt in IDE.

**Compilation:**

I'm putting my hands on. I'm Waiting. Mistakes. I read. I'm trying to figure out what AI meant. I come back to AI: “Here’s a mistake, correct it.” AI generates new code. Copie is again.

**Debag:**

Compiled. I'm trying. Courage. I read the logs. I'm trying to figure out where the problem is. Again to AI: “Here’s a crash, here are the logs, what to do?” AI offers a fix. Copip. Compiled. It's a crash again, but the other one. I repeat.

**Gunsing into the code:**

AI wrote 200 lines. I need to understand what he did. I read. I'm trying to get into the logic. I find a problem. I'm explaining the AI. The AI is rewriting. I'm reading again. I'm delving into it again.

**By the end of the day:**

Did a single feature. Tired. Burned out. Feeling: ** "This code is in the cunt. Another endless problematic task.”

And that was **nomy. That's how everyone worked. Even with AI. Because the AI was a ** assistant, not **executor. You still did the work with your hands: coppaste, compilation, bragg, reading code.

---

How it is now (full agent environment)

**Morning:**

I make a spectacle. 20-30 minutes of dialogue with AI. I'm putting the agent out.

**Day:**

The agent writes the code himself. Compilations itself. It itself fixes the compilation errors. It itself launches the environment. Tests himself. It's the crashing itself. He interprets to success.

I'm looking at one eye. I drink coffee. I'm thinking about other tasks. Sometimes I adjust the course if the agent goes wrong.

**By the end of the day:**

Made 3-4 tasks. Not tired. There is a feeling ** "Yes, it's done. I’ll do more tomorrow.”

---

## What has changed qualitatively

### Cognitive load has fallen hundreds of times

I used to keep my mind:

The code that wrote the AI

- Compilation errors

- Logs of crash

- Context of the task

- Architectural solutions

- What needs to be corrected

I'm keeping in my head now:

- The overall objective of the task

Criteria for success

Current progress (high-level)

The rest is on the agent. My brain doesn't work at the limit. It operates at 10-20% of power.

### Burning from the routine

Previously, the routine killed:

- Copypaste code from chat to IDE

- Manual compilation and waiting

- Reading the logs and finding out of errors

- Dawn into someone else's code (even if this "alien" - AI)

- Repeated cycles "Could - compile - again error"

Now the routine **no**. The agent does everything himself. I'm not a copy. I don't compile with my hands. I don't read the logs. I don't delve into every line.

### There is a feeling of “get it”

Previously, each task was **fight. You didn't know how long it would take. I didn’t know how many iterations would be required. I didn't know if you'd be stuck on a bug for three days.

Now I **known **known that the task will close. Maybe in an hour. Maybe in a day. But it'll shut down. Because the agent doesn't get tired, doesn't burn out, he's not distracted. He is eager to success.

This changes the attitude to work**. You come not with the thought of “again an infinite problem task”, but with the thought of “okay, I will set the task and I will observe”.

### The feeling of “this coding” disappeared

That's probably the most important thing.

The end of the day was like: “I’m tired. I'm burned out. I hate that code. Tomorrow is the same thing again.”

Now by the end of the day: “Yes, it did. I'll do it again tomorrow. Maybe I’ll take the task harder.”

It's not about laziness. It's about the fact that **rutin no longer kills**. You do what is interesting: you set tasks, take architectural solutions, verify the result. And do not copy the code and do not dislike the crash for the tenth time.

---

## And it's even without complex tasks

Important: this change occurred **even at normal tasks**. Not to the migration of Content Browser. Not on reverse engineering architecture UE5. And on the usual features that I did every day.

If someone had told me a year ago, “In a year, you’re going to come to work without feeling “washing this coding,” I wouldn’t have believed it. Because it was **normal. Everyone lived like that. Everyone was tired of the routine. Everyone's gone.

It's not okay now. Now the normal state is when you are not tired of the routine, because there is no routine. It's made by the agent.

---

## Why this is important

Technical articles say about:

- Speed (+20%, 10x, 100x)

- Budget savings (10-13x)

- New classes of tasks

But they don’t say about the quality of life. About you stop burning out. About the fact that you come to work with a feeling “will work”, not “again the fight”. About the fact that by the end of the day there is no feeling "in the garbage of this coding."

This may be the most important **. Speed and economics are good. But if you burn out in three months, what’s the difference, how fast you were?

Now, with a full-fledged agent environment, you ** you do not burn out. Because there's no routine. Because the cognitive burden is minimal. Because you're doing what's interesting, not what's killing.

---

## Conclusion

Honest and without HYIP:

**Full-fledged agent environment is not only about speed and savings. It's about the quality of life. **

Previously: copypaste, manual compilation, debag, delve into the code, burnout, "this coding punch".

Now: setting tasks, observation, verification, lack of burnout, “yes, it turned out”.

The cognitive load fell hundreds of times. The agent makes a Routine. Man stays at a strategic level.

And that changes the attitude to work**. You're not coming to fight, you're going to build. Not to survive, but to develop. Not to burn out, but to grow.

This is perhaps the most important change. Not +20%. Not 10x. And **returning the joy of work**.

---

# When AI is dulling, infuriating, and why it’s normal: evolution through complex tasks

# Honest Recognition

The tasks of AI is dull. Sometimes annoying. Really pissed off.

You set a task that requires a deep understanding of the architecture of the UE5 module. AI is writing code. Compiled. Mistake. Fixitis. Mistake again. Fixitis. Mistake again. But it's different. And so in a circle. Five iterations. Ten. Twenty. AI walks around, can not find the root cause. Spending tokens. Wasting time. It's your patience.

At this point, I want to close the laptop and say, “All right, I’ll do it myself faster.”

But you don't. Because you know, it's not the AI that's broken. This is a difficult task. And AI lacks the context to solve it.

---

## What to do when the AI is dull

When AI gets stuck on a difficult task, the solution is not to “give him more time.” The decision is to give it more context**.

Specifically on the UE5 project, when AI is dulling on a difficult task, I do the following:

Step 1: I'm Calming down. **

It's important. Not crazy. I don't close my laptop. I know, AI is not stupid. AI lacks the context. The task is difficult. That's okay.

**Step 2: I rewrite the architecture of the module with AI. **

Don’t “let’s try again.” And **sit and discuss architecture**. I explain AI:

- How my module works

- What dependencies

- How it's related to UE5

- What are the restrictions

- What edge cases

It's not a one-line product. This is a **dialogue**. 20-30 minutes of discussion of architecture. And asks questions. I'm answering. The yen clarifies. I complement.

Step 3: I run code audit. **

I ask AI to audit the current code of the module:

- What works

- What's not working

- Where are the potential problems

- Where violations of UE5 contracts

The AI analyzes the code. Finds problems. Offers fixes.

Step 4: I put in the context on the constipation. **

Everything we discussed is the specifics of the module, its connection with UE5, restrictions, edge cases - **ffers in the context on the constipation**. In agents.md, in memory.md, in skills.

This is not a one-time context for one session. This is a **persiste context** that AI will use every time it works with this module.

Step 5: The AI overcomes the barrier. **

After the context is loaded, AI ** overcomes its cognitive barrier. He's not going around anymore. He understands the architecture. Understands the limitations. He understands what he can and can't.

And finds a solution. For one or two iterations instead of twenty.

---

#Evolution through complex tasks

Here is what is important: **pending the process of complex tasks is the evolution of AI. Not in the process of simple. Not in the course of the routine. Just where the AI is dull.

Because when AI is dull, you realize that there is not enough context here. And you add the context. You're writing a skill. Update the instructions. Bring the specifics of the module.

And the next time, when the AI faces a similar task, he no longer is corpus. Because there is a context. Because there's a skilla. Because the specificity of the module is documented.

This is **evolution. It wasn’t AI that itself has become smarter. And the system has become smarter. Because you added a context that AI didn't know.

---

#A specific example: advanced skil debagg

On the project UE5 there are **repeating bugs**. Not unique. Repeated. The same patterns of errors that arise over and over again in different contexts.

Previously, AI had been dismanted them for a long time. Spent 10-15 iterations to search for a root cause. Because I didn't know the pattern. Because I started from zero every time.

What I did:

**Step 1: Conducted an audit. **

I watched where AI was dull. Where he had long been. Where I walked around. Identified the patterns of recurring bugs.

Step 2: Wrote an advanced scalton of the debagg. **

Not just “analyze the logs.” And **skill with mini-scripts parsing logs**:

- The parsite logo script UE5

- Highlights key errors

- Classifies by type

- Compared with known patterns

- Offers a fix based on the pattern

Step 3: Optimized the process. **

Now that AI is facing a recurring bug, it doesn’t fight from zero. He:

1. Launches a parsing of the logos

2. Receives Error Classification

3. Compared with a known pattern

4. Applies a known fix

5. Checks the result

Instead of 10-15 iterations - **2-3 iteration**. Instead of 5 minutes, **30 seconds**.

---

## Psychological Feeling of Improvement

Here is what is interesting: this improvement is felt psychologically**. Even unconsciously.

Previous: AI spends 20 seconds on another action. You're sitting. You're Waiting. Stick to the monitor. You think, “Come on. “What are you digging up?”

AI is spending 6 seconds on another action. You don't have time to get distracted. AI has already offered a code for revue. You don't stick into the monitor between the moments when the AI thinks. Because there are almost no moments.

This is really felt. Not like a metric. Not like “+20% to speed.” And as a **quality change**: AI began to work better. Stable. Hurry up. Predictable.

And you're **ny fattering out. Because you get the answers faster. Because you don't expect it. Because you don't stick it to the monitor. Because AI doesn't go every step.

---

## Stack is no longer important

And here's the most important thing: **I don't care which stack to write on.

I am writing on:

- JavaScript

- Python

- Shell

- C++

- Lua

And I'm still **great. Because AI knows all these stacks. Because AI can write on any of them. Because my role is not to “know C++ syntax” or “know the Python API.” My role is to set tasks and verify the result.

Previously, to write on UE5, you had to **know C++ deeply**. Knowing STL. Know the patterns. Know the macros of UE5. Know the assembly system. These were years of study.

AI knows C++ better than most developers. The AI knows STL. Knows the templates. He knows the macros. Knows the assembly system. My job is not to know it myself. My task is to ** set the task correctly and check the result**.

This does not mean that knowledge is not needed. They're needed. But they are needed at the level of architecture and verification**, and not at the syntax level.

---

## Era When Programmers Can Be Human

And this is what it really means:

Previously, the life of a programmer is an endless study**:

- New version of the framework - study

- New plugin - study

- New module — learn

- New stack - study

- New library - study

- New tool - study

And so infinite. You don't write the code. You are studying**. You don't solve the problem. You read the documentation**. You're not making it. You're going to go.

And by the end of the day, the feeling is, “I’m tired. I'm burned out. I didn't create anything. I just read the documentation and tried to figure out how another league works.”

It's now **it's over. Because AI knows the framework. AI knows the plugins. AI knows the modules. And knows the stacks. The AI knows the libraries. AI knows the tools.

My job is not to study. My task is to ** set tasks and verify the result**. Don't catch up. And **create **.

This is an era where programmers can really feel like human. Not by machines to study documentation. Not robots for copy code. And the people who set the tasks, make decisions, create products**.

---

## Conclusion

Honest and without HYIP:

**AI is dull on difficult tasks. Sometimes annoying. That's okay. **

But the decision is not to close the laptop and do it yourself. The solution is to **give AI more context**: rewrite the module architecture, discuss, start an audit of the code, bring the specifics to the permanent.

**It is in the process of complex tasks that the evolution of AI occurs. ** Not in simple. Not in the routine. Where the AI is dull. Because there you know what you're missing, and you're adding it.

** This improvement is felt psychologically. ** Unconsciously. The AI has started to work better. Stable. Hurry up. You're less sticking to the monitor. Feel less. You get answers faster.

**Stok is no longer important. ** JS, Python, Shell, C++, Lua does not matter. Because the AI knows everything. Your role is not to know syntax. Your role is to set tasks and verify.

**It’s an era when programmers can be human. ** Not by the machines for the study of documentation. Not robots for a copyp. And the people who create.

This is perhaps the most important change. Not +20%. Not 10x. And **return of humanity to the profession**.

---

# Reference point: one instruction in agents.md

## How It All Began

All automation on the UE5 project began with a **one simple step**: I wrote the first instruction in `agents.md`.

Three months ago. Just three months ago.

The instruction was primitive:

````

When I say "open the project"

you open a specific *.uproject file

along such and such a path.

````

That's it. One instruction. One binding: the “open project” command → specific file.

---

## Why this is important

It seems like a little thing. But this is a **fundament. Because:

- The AI stopped asking, "What project to open?"

- AI stopped wondering, "What's the *.uproject file?"

- AI began to **under the context of the project** from the first team

It was the first step from “AI as a chatbot, which needs to be explained every time” to “AI as an executor who knows the context.”

---

#From one instruction to complete automation

Three months ago:

- One instruction in agents.md

- "Open the project" → AI opens the right *.uproject

Now:

- Full agent environment with dozens of skills

- UECortex (MCP Tools Server) with self-maintaining instructions

- Migration Content Browser from Editor to Runtime

- Runtime assets, MIDI assets, runtime meshes, runtime TTF/OTF fonts

- Blueprint to C++ Native Converter

- Reverse engineering architecture UE5

- One engineer instead of a team of senior specialists

---

## Conclusion

It all started with one line in agents.md. Not buying an expensive subscription. Not hiring a team. Not from months of planning.

With one instruction: “When I say X, you do Y.”

And that was three months ago. Now it is a complete automation of exorbitant tasks on UE5.

Three months. From one line to complete transformation.

---

# Final chord: 10 minutes of copypate instead of three months of research

## What is now

My harness environment for UE5 has so far been written under **Linux. But the architecture is such that it can be rewritten or rewritten or added to Windows and macOS**. It’s not “to start with zero.” It is to adapt the existing skillas and scripts to another OS. It's a technique, not research.

---

## What does it mean for any UE5 project

Everything that is now - skillas, UECorex, indexation, loop feedback, memory.md, native converter Blueprint to C++ - can be **copyshot in 10 minutes in any UE5 project**.

No need:

- Three months of research on tasks

- Reverse engineering UE5 architecture

- Method of trial and error

- The rakes I've already beaten

- Writing Skills from scratch

- Adjustment of indexing from zero

Everything is already **ready. At the current level of automation. Checked on real tasks of extreme complexity.

---

## Why it's awkward

A year ago, to reach this level, it was necessary:

- Hire a team of senior specialists ($300k-600k)

- Spend 8-12 months on prototypes

- Go through all the rakes manually

- Burn out several times

- Pray that the concept will be confirmed

Now:

- **10 minutes of copypation**

- Ready-made agent environment

- All rakes are already bypassed

- All skills are written and verified

- You can immediately start tasks

Three months of research I have gone through **crow in 10 minutes** for any other person with UE5 project.

---

## Conclusion

This is the real value of what has been done. Not just “I automated my project.” A **I has created an infrastructure that can be saved in any other project in 10 minutes**.

It’s not an “individual solution.” This is a **ratified system**. Which eliminates three months of research for anyone who wants to work with UE5 at the level of full automation.

It's fucking awesome. And that's just the beginning. Because the harness can be rewritten under Windows and macOS. And then it will work **everywhere. For any UE5 project**. In **10 minutes**.

This is a new development reality on UE5. And It's here.

Page updated

Google Sites

Report abuse