What belongs in an AI bug-fix prompt — and what is just 48 KB of noise

The dump-and-pray prompt

The usual first attempt looks productive. The developer copies the stack trace, then half the Inspector, then the last forty lines of the Console, drops the whole pile into an AI assistant, and types something like: this is broken, fix it. It feels thorough. It is mostly volume.

A 48-kilobyte paste is not context. It is a haystack with a sticky note on top that says the needle is in here somewhere, good luck. The model does what it always does with a wall of text: it reads the beginning, skims the middle, anchors on the end, and produces an answer with more confidence than the input justifies.

The result is the AI equivalent of folklore. A plausible-sounding fix for a bug nobody has actually located, generated from material nobody curated, accepted because it arrived quickly and sounded sure of itself.

Why more context makes worse answers

There is a quiet assumption behind the big paste: that more information can only help, because the model can ignore what it does not need. In practice the opposite is closer to true. Relevant signal does not get stronger when you bury it in irrelevant detail. It gets harder to find.

Long inputs have a well-documented soft spot in the middle, where detail is most likely to be skimmed rather than used. A serialized field that actually explains the bug, sitting in the thirty-first kilobyte between an unrelated shader warning and a verbose third-party log, is exactly the kind of thing that gets read past. The model is not lazy. It is doing pattern completion over a document where you hid the important sentence on purpose.

The honest framing is that there is context, and there is relevant context, and only the second one is worth tokens. Everything else is noise wearing the costume of thoroughness.

One prompt, one question

The version that works is smaller and deliberately shaped. Instead of one prompt that asks for everything, you write a small set of prompts that each ask for one thing: reproduction steps, likely cause, an investigation checklist, a test scaffold. Each is short, framed around a single question, and answerable from material you actually selected.

This is slower to set up and faster to use, which is the right trade. A prompt that asks what would I check first, given this captured state? gets a focused answer. A prompt that asks fix this, with everything attached gets a guess dressed as a conclusion. The structure is doing the work the volume pretended to do.

It also makes the answer auditable. When the prompt is one question against curated context, you can tell whether the model reasoned from the evidence or invented a story. When the prompt is a data dump, you cannot, because neither could the model.

The snapshot is the source, not the prompt

Good AI prompts are downstream of good evidence. The raw material is a structured snapshot taken at the moment the bug was visible: a screenshot, the recent Console logs with stack traces, scene and runtime metadata, the relevant GameObjects with their component state, and the reporter's note about what they expected versus what they saw. That is the same discipline as capturing evidence before the trail goes cold — the prompt just reads from it.

From that snapshot you cut small, targeted prompts. The screenshot and the note frame the question. The relevant component state goes in because it is relevant, not because it was nearby. The unrelated log stays out. The prompt becomes a short brief built from reviewed evidence, not a transcript of everything Unity happened to have in memory.

The difference is that a snapshot is something a person looked at. A scene dump is something a clipboard produced. Only one of them has had a decision applied to it.

Review before you paste

There is a second reason the curation step matters, and it has nothing to do with answer quality. A raw scene dump is a privacy and licensing hazard. Serialized fields can carry secrets, NDA-covered text, unreleased content, or a teammate's work-in-progress. Pasting all of it into a third-party assistant is a disclosure decision made by accident.

Local-first capture with a review step is what makes this safe. The snapshot lives on the machine. Before anything is exported into a prompt, a person looks at it and decides what travels: which logs are relevant, whether a serialized value should be redacted, whether this snapshot can leave the building at all. The export is on demand and deliberate, not automatic.

A tool that streams captures straight to an AI service cannot be used on real projects under NDA or embargo. The review step is not friction. It is the thing that lets evidence-collection coexist with the contracts most studios actually operate under.

Prompts are advice, not a senior engineer

Even a well-built prompt produces advice, not a fix. The model gives a fast first pass on questions like what would I check next, what does this stack trace usually mean, what is a reasonable test to write. Those are genuinely useful when no senior engineer is free for the next hour. They are not a verdict.

The failure mode to avoid is treating a confident answer as a confirmed one. The developer still reads the snapshot, still understands the system, still decides whether the suggested cause survives contact with the code. The AI shortens the first lap. It does not run the race.

Framed that way, the prompt pack is a triage aid: a structured, reviewed, one-question-at-a-time way to get a faster start. Framed as a magic fixer fed by a data dump, it is just a more expensive way to produce folklore.

The discipline, stated plainly

Capture a structured snapshot at the moment the bug is visible. Review it. Cut small prompts that each ask one question against the relevant part of it. Read the answers as advice. That is the whole loop, and it works because every step removes noise instead of adding it.

The deeper point is the same one that runs through evidence-first debugging. The value is not in how much you can hand the model. It is in how little you can hand it while still answering the question. A small, reviewed prompt is the version an AI assistant can actually reason about — which is the only version worth pasting.