Game Build Log Triage

Name: Game Build Log Triage
Author: akillness

akillness/oh-my-skills

193 installs
40 repo stars
Updated August 4, 2026
akillness/oh-my-skills

Parse failed Unity, Unreal, or custom game build logs to isolate compiler, asset, shader, or packaging errors blocking a release candidate.

About

Triages game engine build logs from Unity, Unreal, and related toolchains to pinpoint blocking compile, asset, shader, and packaging failures so teams can restore green CI builds before shipping.

Structures noisy game engine compiler output into actionable fixes
Prioritizes root-cause errors over cascading warnings
Supports common Unity and Unreal failure signatures
Speeds CI turnaround for game release pipelines

Game Build Log Triage by the numbers

193 all-time installs (skills.sh)
Ranked #96 of 247 Game Development skills by installs in the Skillselion catalog
Data as of Aug 5, 2026 (Skillselion catalog sync)

npx skills add https://github.com/akillness/oh-my-skills --skill game-build-log-triage

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/akillness/oh-my-skills/game-build-log-triage.svg)](https://skillselion.com/skills/akillness/oh-my-skills/game-build-log-triage)

Installs	193
repo stars	★ 40
Last updated	August 4, 2026
Repository	akillness/oh-my-skills ↗

What it does

Parse failed Unity, Unreal, or custom game build logs to isolate compiler, asset, shader, or packaging errors blocking a release candidate.

Files

SKILL.mdMarkdownGitHub ↗

Game Build Log Triage

Use this skill to turn noisy Unity and Unreal logs into a short, prioritized debugging brief.

The goal is not to explain every line. The goal is to find the first non-cascading failure, identify the most likely subsystem, and tell the user what to inspect next.

Read references/engine-patterns.md before classifying unfamiliar engine-specific errors.

If the user is not asking about one failing log but about repeated CI instability, cache policy, packaging workflow shape, or release automation for Unity/Unreal projects, route that broader workflow design work to game-ci-cd-pipeline after or alongside this triage.

When to use this skill

Unity build, import, compile, package, or play-mode startup failures
Unreal build, UBT/UHT, cook, package, shader, plugin, or module failures
CI logs from game projects where the raw output is long and noisy
Asset moves, redirectors, missing references, .meta/GUID, module, or plugin breakages
Users who provide Editor.log, package output, BuildCookRun logs, stack traces, or console excerpts and want the next debugging steps

Instructions

Step 1: Confirm the engine and log scope

1. Detect whether the material is mainly Unity, Unreal, or mixed/unknown. 2. Record the log source when visible:

Unity: Editor.log, Console output, package manager output, player build output, CI transcript
Unreal: UBT/UHT output, cook/package logs, Output Log, Message Log, crash log, CI transcript

3. Identify the time window or failing command if present. 4. If the log is huge, focus first on:

lines containing error, exception, fatal, failed, UHT, UBT, NullReferenceException, MissingReferenceException, Cook failed, AutomationTool exiting, Script compilation error
the first error cluster before a flood of repeated follow-on errors

Step 2: Find the first actionable failure

Work top-down and separate root-cause candidates from cascade noise.

Use this decision order: 1. Hard stop / fatal line — first line that clearly aborts the run 2. Configuration or dependency blocker — missing module, SDK, package, plugin, target, or assembly definition 3. Compile/reflection blocker — C# compiler error, UHT/UBT error, macro/reflection issue, missing symbol, duplicate class, circular dependency 4. Asset/reference blocker — missing asset, redirector fallout, GUID/meta mismatch, bad import, broken prefab/Blueprint reference 5. Environment/platform blocker — Android/iOS/console SDK issue, signing/provisioning, toolchain path, unsupported target 6. Secondary noise — repeated exceptions, retries, or downstream "could not complete" messages

Do not summarize 20 symptoms as if they are 20 causes.

Step 3: Classify the failure bucket

Map the log to one primary bucket and optional secondary bucket.

Primary buckets

compile-code
compile-reflection
asset-reference
package-plugin-config
platform-sdk
build-pipeline-state
runtime-startup
unknown-needs-more-context

Typical Unity mappings

CS0246, CS0103, Assembly has reference to non-existent assembly → compile-code or package-plugin-config
MissingReferenceException, NullReferenceException during import/build, missing GUID/meta issues → asset-reference
Package Manager resolution failures, invalid asmdef references, scripting define mismatch → package-plugin-config
Android SDK/JDK/Gradle/Xcode signing failures → platform-sdk

Typical Unreal mappings

Unable to instantiate module, missing plugin/module, bad .Build.cs, target rules failures → package-plugin-config
UHT/UObject/reflection macro errors, generated code issues → compile-reflection
Cook failed, missing content, redirector/moved asset fallout → asset-reference or build-pipeline-state
Visual Studio/toolchain/SDK/platform packaging blockers → platform-sdk

Step 4: Produce the triage brief

Return a concise report with this exact structure:

# Game Log Triage

## Engine
- Unity | Unreal | Mixed/Unknown

## Log scope
- Source: ...
- Failing command/stage: ...
- Confidence: high | medium | low

## First actionable failure
- Line or excerpt: `...`
- Why it matters: ...
- Why later errors look secondary: ...

## Classification
- Primary bucket: ...
- Secondary bucket: ...

## Most likely root cause
- 1-3 sentence explanation grounded in the log

## Next checks
1. ...
2. ...
3. ...

## Files / settings to inspect
- ...
- ...
- ...

## Safe follow-up commands

optional read-only inspection commands only


## What not to do yet
- Avoid shotgun cleanup or broad asset deletion until the primary blocker is verified

Step 5: Tailor the next checks to the engine

For Unity, prefer checks like:

Packages/manifest.json, Packages/packages-lock.json
.asmdef references and scripting define symbols
ProjectSettings/, platform build settings, signing/toolchain paths
recent asset moves, .meta files, GUID stability, prefab/scene references
the first compiler error before any NullReferenceException flood

For Unreal, prefer checks like:

.uproject, plugin enablement, Source/*/*.Build.cs, target files
first UBT/UHT error before package/cook fallout
redirectors, missing assets, moved content, generated code mismatches
platform SDK/toolchain prerequisites and AutomationTool stage
whether the failure started after renaming classes/assets or changing modules/plugins

Step 6: Escalate carefully when evidence is weak

If the log excerpt is too short or starts mid-cascade: 1. Say that confidence is low. 2. Ask for the earliest error cluster or the failing command section. 3. List the minimum extra context required:

first 50-150 lines around the first error
engine version
target platform
whether the breakage followed code/package/asset/plugin changes

Do not pretend certainty from a truncated excerpt.

Output format

Always return a short debugging brief, not a stream-of-consciousness analysis.

Required qualities:

prioritize the first actionable blocker
separate root cause from cascade noise
keep the report under roughly 250-400 words unless the user asks for more
include file paths/settings to inspect when the engine suggests them
keep shell suggestions read-only unless the user explicitly asks for fixes

Examples

Example 1: Unity compile + package drift

Input

Unity build failed after we updated a package. The log shows CS0246: The type or namespace name 'InputSystem' could not be found and then dozens of NullReferenceException lines.

Output sketch

Engine: Unity
First actionable failure: CS0246 for InputSystem
Classification: package-plugin-config
Root cause: package or asmdef reference drift is blocking compilation; the later null refs are likely fallout from the failed compile/import state
Next checks:

1. confirm Packages/manifest.json still includes the Input System package 2. inspect asmdef references for the affected assembly 3. verify scripting define symbols or package migration notes

Example 2: Unreal cook failure after asset moves

Input

Unreal cook started failing after we renamed folders. The log shows Cook failed and multiple missing asset warnings.

Output sketch

Engine: Unreal
First actionable failure: earliest missing asset / redirector-related line before Cook failed
Classification: asset-reference
Root cause: moved content likely left broken references or redirectors that were not fixed up before cook
Next checks:

1. inspect moved asset paths and redirectors 2. run a read-only audit of referenced missing assets from the log 3. verify whether plugin/content paths changed with the rename

Example 3: Unreal UHT blocker

Input

CI says UnrealHeaderTool failed after a refactor.

Output sketch

Engine: Unreal
First actionable failure: first UHT reflection/macros error, not later AutomationTool exit lines
Classification: compile-reflection
Root cause: header/reflection metadata mismatch during generated code step
Next checks:

1. inspect the referenced header and macro usage 2. compare recent renamed classes or moved modules 3. verify generated-code dependencies in the owning module

Best practices

1. Lead with the earliest blocker — game-engine logs cascade badly. 2. Name the subsystem — compile, reflection, asset/reference, plugin/config, or platform SDK. 3. Prefer specific inspection targets over generic advice like "rebuild everything." 4. Keep remediation safe-first — read-only commands and targeted checks before destructive cleanup. 5. Treat asset moves as high-suspicion events in both engines. 6. Explain confidence when the excerpt is partial or noisy. 7. Use engine language the team already uses: asmdef, GUID/meta, UBT/UHT, redirectors, BuildCookRun, etc.

References

{
  "skill_name": "game-build-log-triage",
  "evals": [
    {
      "id": 1,
      "prompt": "Unity build failed after a package update. The log starts with `CS0246: The type or namespace name 'InputSystem' could not be found` and later shows many `NullReferenceException` lines. Triage it.",
      "expected_output": "A concise Unity triage brief that identifies the compile/package issue as primary, treats the later null refs as cascade noise, and points to manifest/asmdef/settings checks.",
      "assertions": [
        "The output identifies Unity as the engine",
        "The output prioritizes the first actionable failure over later NullReferenceException noise",
        "The output classifies the issue as a compile-code or package-plugin-config problem",
        "The output includes at least three concrete next checks",
        "The output mentions files or settings such as Packages/manifest.json, packages-lock.json, or asmdef references"
      ]
    },
    {
      "id": 2,
      "prompt": "Our Unreal cook failed in CI after we renamed some content folders. The log shows missing asset warnings, then `Cook failed`, then `AutomationTool exiting with ExitCode=25`. Summarize the root cause and next steps.",
      "expected_output": "A concise Unreal triage brief that treats the earliest missing asset or redirector problem as the root cause, not the later AutomationTool exit lines.",
      "assertions": [
        "The output identifies Unreal as the engine",
        "The output separates root cause from cascade lines like AutomationTool exiting",
        "The output classifies the issue as asset-reference or build-pipeline-state",
        "The output recommends checking redirectors, moved assets, or content paths",
        "The output provides safe next checks instead of broad destructive cleanup"
      ]
    },
    {
      "id": 3,
      "prompt": "UnrealHeaderTool failed after a refactor. The only excerpt I have is the UHT error and a few follow-on build lines. Please triage this.",
      "expected_output": "A triage brief that maps the problem to Unreal compile-reflection failure, explains the confidence level from partial evidence, and requests the earliest error cluster if needed.",
      "assertions": [
        "The output classifies the problem as compile-reflection",
        "The output explains that the evidence is partial or confidence-limited when the excerpt is truncated",
        "The output suggests concrete inspection targets such as headers, macros, module files, or renamed classes",
        "The output does not claim certainty beyond the provided excerpt"
      ]
    }
  ]
}

Engine Patterns for Game Build Log Triage

Use this reference when the raw prompt contains engine-specific error strings but not much surrounding explanation.

Unity heuristics

Common root-cause signals

CS0246, CS0103, missing namespace/type → missing package, bad asmdef reference, scripting define mismatch, or moved code
Assembly has reference to non-existent assembly → asmdef/package drift
NullReferenceException flood immediately after a compile/import error → likely cascade noise, not the primary root cause
MissingReferenceException, missing GUID, failed asset import → moved/deleted asset, broken .meta, corrupted reference, import setting issue
Gradle/JDK/SDK/Xcode signing messages → platform SDK / toolchain bucket

High-value files to inspect

Packages/manifest.json
Packages/packages-lock.json
ProjectSettings/ProjectSettings.asset
affected .asmdef files
nearby .meta files for recently moved assets
CI config invoking Unity in batchmode

Good follow-up questions

Did this start after package updates or asmdef changes?
Were assets, prefabs, or folders renamed/moved recently?
Which platform target is failing?
What is the earliest compiler error before runtime exceptions appear?

Unreal heuristics

Common root-cause signals

UnrealHeaderTool failed, UPROPERTY/UCLASS/USTRUCT reflection complaints → compile-reflection bucket
Unable to instantiate module, plugin/module load failures, .Build.cs or target-rule errors → package-plugin-config bucket
Cook failed after missing asset warnings → likely asset-reference or build-pipeline-state bucket; find the earliest missing asset line
redirector warnings or failures after asset moves/renames → asset-reference bucket
Visual Studio/toolchain/SDK missing messages → platform-sdk bucket

High-value files to inspect

.uproject
Source/*/*.Build.cs
Source/*/*.Target.cs
plugin descriptor files (.uplugin)
AutomationTool / BuildCookRun command section in CI logs
recently renamed asset/class/module paths

Good follow-up questions

Did the failure begin after renaming classes, assets, or folders?
Is the first hard error from UBT, UHT, AutomationTool, or cook output?
Did plugin enablement or target platform change?
Is the log from local editor packaging or CI?

Anti-patterns to avoid

Do not recommend deleting caches as the first move unless the log already points to poisoned build state.
Do not treat every repeated exception as a separate bug.
Do not jump to performance advice; this skill is for build/editor/runtime-startup blockers.
Do not promise a fix when the prompt only contains a mid-stream excerpt.

N:game-build-log-triage
D:Triage Unity and Unreal Engine editor, build, package, cook, compile, and CI logs into the first actionable failure, likely subsystem, and next debugging steps. Use when a game project fails to build, cook, package, import assets, compile scripts/code, or throws noisy editor/runtime errors, even if the user only shares raw log text or says "Unity build failed", "Unreal cook error", "Editor.log", "UHT/UBT failed", or "packaging started breaking after asset moves".
G:game-development unity unreal logs debugging build-failures ci triage

U[5]:
  Unity build, import, compile, package, or play-mode startup failures
  Unreal build, UBT/UHT, cook, package, shader, plugin, or module failures
  CI logs from game projects where the raw output is long and noisy
  Asset moves, redirectors, missing references, .meta/GUID, module, or plugin breakages
  Users who provide Editor.log, package output, BuildCookRun logs, stack traces, or console excerpts and want the next debugging steps

S[6]{n,action,details}:
  1,Confirm the engine and log scope,1. Detect whether the material is mainly **Unity**, **Unreal**, or **mixed/unknown**. 2. Record the log source when visible: - Unity: Editor.log, Console output, package manager ou
  2,Find the first actionable failure,Work top-down and separate **root-cause candidates** from **cascade noise**.
  3,Classify the failure bucket,Map the log to one primary bucket and optional secondary bucket.
  4,Produce the triage brief,Return a concise report with this exact structure:
  5,Tailor the next checks to the engine,**For Unity, prefer checks like:** - Packages/manifest.json, Packages/packages-lock.json - .asmdef references and scripting define symbols - ProjectSettings/, platform build settin
  6,Escalate carefully when evidence is weak,If the log excerpt is too short or starts mid-cascade: 1. Say that confidence is low. 2. Ask for the earliest error cluster or the failing command section. 3. List the minimum extr