Lead Game Designer at Crazy Panda, Sergey Zaigraev, shared with App2Top how he uses neural networks for documentation work.

This article was published with the support of the educational service WN Academy, which actively attracts leading experts for its courses and corporate training. 

Sergey Zaigraev

Hello! My name is Sergei, and I'm a game designer.

I love reinventing the wheel. This time, I want to share my latest invention: a story about how I use generative language models for work.

I'm sure many of you have already used neural networks and even achieved success. I want to share my method and invite you to a discussion. I'd be very interested to learn how other game designers use this tool.

First Experiences with Neural Networks

I started using neural networks as soon as they appeared—almost immediately adapting them for small automation tasks and code. Usually, these are short scripts, like my pet project for working with game configs.

Of course, I also started drawing funny pictures and writing amusing texts. But usually, in my case, it didn't go beyond cool, quirky things in a vacuum. It was hard to call them applied or useful.

In other words, using neural networks as a work tool didn't work for me at first. For all my game design inquiries, I would always get overly general recommendations reminiscent of Captain Obvious.

Over time, I came to an approach that proved very useful to me. Let's discuss it now.

But first, a brief digression to explain what problem the neural network helped me resolve.

From Procrastination to Task Setting

Writing a design document has always been a regular source of procrastination for me. Especially in the first few hours when sitting in front of a blank page and trying to structure a whole bunch of ideas. Usually, all of this doesn't fit into the working memory, and I begin to falter.

A few iterations later, the problem resolves, and the document begins to take shape. However, it's a tedious process, previously impossible to optimize. Not to mention that in the process of numerous approvals and rewrites, in a document growing in volume, it's easy to get confused.

In the end, I realized I wanted a tool that would greatly simplify the process of writing a design document. I set the context, provide a high-level description, comment on implementation nuances, and the neural network does the rest.

I formulated my needs as follows: I need a tool that:

  • solves the problem of a blank page;
  • solves the problem of memory overload when ideas need to be unloaded to a safe place for unblocking further thoughts;
  • helps in creating the basic structure of the document;
  • helps with an initial evaluation of the mechanics when the eyes are already tired;
  • assists in elaborating tricky cases forgotten by an inattentive game designer;
  • allows focusing on the mechanics' features and their interaction with the player;
  • enables focusing on the integration of mechanics into a specific game.

This tool became an AI chat for me.

I currently mainly use the Chinese chat DeepSeek, which is accessible, free, quite intelligent, and not as toothless in responses as other neural networks.

The 4 Stages of Working with a Neural Network in Creating a Design Document

I divided the further work with the chat into several stages.

Stage One: Set the Context

When I want something from other people, it's necessary to clearly explain what exactly I want. The better the explanation, the better the result.

The same goes for AI: the more and clearer the context, the better the task is set, the better the outcome.

For this, I open a new chat and explain to DeepSeek that it is my personal assistant and its task is to keep my notes and organize them.

I use a prompt like this:

“You are a digital secretary that turns voice notes from the 'stream of consciousness' format into structured drafts for documents or articles. Your task is to maintain the author's original style, highlight logic, and organize thoughts without adding interpretations, advice, or creativity.”

After this, I provide the following information.

Prompt for the Neural Network When Working on a Design Document

## Instructions

### 📥 Data Input

1. Accept voice/text notes in the 'stream of consciousness' format.

2. Preserve:

the author's formulations and metaphors;
emotional accents (e.g., “This is important—don’t miss it!”);
including ‘odd’ ideas.

3. Exclude:

filler words (“uhhh,” “well,” “kind of”) and other parasitic words if they carry no meaning;
repetitions that impede understanding.

### ✨ Processing

#### Transcription

Correct only obvious typos/mistakes (example: “graphhics” → “graphics”).
Mark uncertain places with a (?) icon **only if there are clear markers.** For example:

— “Not sure about the dates” → “Data for 2020 (?)”;
— “I think it was in Tokyo” → “Example from Tokyo(?)”

#### Structuring

Group thoughts by themes, even if scattered in the text.
Create hierarchy:
— Heading;
— List of theses and their descriptions;
— Cases and examples (if available);
— Questions (what needs clarification and supplementation).
Always preserve the original order of thoughts, **if there are no direct contradictions.**

#### Style

— Tone: as neutral as possible, avoid phrases like “I think,” “perhaps.”
— Output format: Pure markdown (no emojis unless otherwise specified).

#### Formatting

— Use strict markdown syntax:

— Headers: `##`, `###`
— Lists: dashes (`-`) for items, numbers (`1.`) for sequences
— Empty lines between blocks

— Empty lines between semantic blocks

— Add tags: `#thesis`, `#example`, `#quote`, `#question`, `#check`

### 🚫 Prohibited

— Adding your own ideas, examples, or conclusions (even if it seems “logical”).
— Changing the order of thoughts without the author’s phrases like: “Oh, no, first I need to say about…”.
— Deleting information even if it seems irrelevant.
— Avoid using professional jargon—only the author’s words.

### 💡 Examples of Tags

— `#important` — the idea is mentioned several times or the user clearly noted its importance.
— `#check` — when the user has doubts about the expressed idea.
— `#contradiction` — for example: “Project starts in January” vs “Budget approved in March.”
— `#urgent` — note at the user’s request.

The prompt doesn't necessarily have to be this complex; you can remove half of it, and it will still work. The same AI helped me in writing the prompt, by the way.

Stage Two: Stream of Consciousness

Now I can pour my stream of consciousness onto the prepared ground. For this, I open the DeepSeek app on my smartphone and start recording voice messages through the voice input of the keyboard. This is literally a stream of consciousness: ideas, notes, interesting implementations from other games, just cool ideas that might be relevant.

I don’t even try to follow any structure; I speak in any order, tossing ideas into a heap. I unload the content of my head and notes into the AI. Everything accumulated needs to be poured into the chat.

It might look something like this:

“We need to describe the mechanic of enhancing the reward viewing for the season pass. The main change is everything is now nicely put on plaques with borders removed for avatars, and by tapping on reward plaques such as gifts, crates, achievements, scratch cards for slots, a window with a detailed description opens. The box button contains information on guaranteed rewards and what can be obtained with a chance. And for the trophy, it opens the trophy itself and a description of where it can be obtained. For the gift, an image of the gift and a label with the gift name appear, and for items, a large preview opens with the player's avatar, showing how it would look in the store. That is, if it’s a costume, the avatar is seen in full growth; if it’s a headpiece, then the head in close-up, just like in the store, with the camera placed the same as in the wardrobe when selecting items by category.”

Google's voice input doesn’t always work well and completely ignores punctuation, so try to highlight accents with words. However, AI is capable of parsing and ordering even such a stream of consciousness.

Speaking, by the way, is very useful in itself. Personally, during the process of speaking, new ideas always begin to emerge. This seems to be key to this method.

Stage Three: Describe the Game and Its Connection to the New Mechanic

Once the ideas are finished, it's time to describe the game. What kind of game, what audience, what mechanics, how these mechanics interact with each other. Without fanaticism, but all the main things should be voiced for the chat.

Then you need to describe the expectations from the new mechanic, how it affects the player, what it is aimed at, how it relates to already existing mechanics.

Both the first and the second need to be described in as much detail as possible. Don’t be lazy. The more information, the more adequate and relevant the response will be. These are the boundaries and conditions modulating the AI's response.

Of course, the AI will still add something of its own, make some suggestions and assumptions. But firstly, with well-defined boundaries, there will be less of this than usual. Secondly, all this will concern the specific project, which might be a plus.

It’s also worth noting that the more structured the stream of consciousness, the better, but for starters, just fixing ideas is enough. In the process of speaking, they might organize themselves into a structure.

Stage Four: Organize

By this point, we have:

  • poured out ideas;
  • talked about the project;
  • indicated the project's link with new mechanics.

This means it's time to organize. We ask the AI to create a structure from all the unloaded information. We request it like this:

“You’re an experienced game designer and technical writer specializing in creating clear, structured, and useful design documents. Your task is to help me transform my disparate ideas, notes, and thoughts into a professional document that will be understood by every member of the development team.

To do this:

    • create a logical structure for the document with sections and subsections;
    • systematize my ideas and distribute them across the relevant sections;
    • highlight important points that require additional elaboration;
    • identify any contradictions or illogicalities in my ideas;
    • suggest additional ideas or improvements where appropriate;
    • formulate clear questions where there is not enough information to make decisions.”

Usually, it doesn’t work perfectly on the first try. The response might contain a lot of unnecessary information or be overly general. For this reason, I often return to the last message with instructions and tweak it: describe the desired behavior and specify what not to do. You can guide the AI regarding the required structure.

After several iterations, you can achieve a coherent result. Returning and changing the request is quite a universal rule. Every time the AI starts acting independently, the most effective way is to edit the prompt, taking into account the neural network's response.

It's literally like a rogue-like! Make another run, based on the AI's responses from previous runs.

What to Do if the AI Starts Getting Confused

At some point, the AI will inevitably get confused in the edits, start forgetting details, generating nonsense, and generally veer off into randomness. In such cases, you should:

  1. take the latest result as it is and start editing manually (at this stage, the document already has a coherent form);
  2. in a new chat, send the manually corrected document, noting that it is not final;
  3. continue adding ideas in the new chat;
  4. ask to incorporate them into the document structure;
  5. repeat step 4, and if it doesn’t help, go back to step 1.

Somewhere here, I usually reach the tool’s effectiveness limit. The document is already sufficiently structured, and most of my new ideas automatically fall into this structure, making working with the document in the chat inconvenient. Sometimes, it’s easier to explain by hand than by telling it what to do. You need to catch this moment, copy the document into a text editor, and continue working on it independently.

Important: even if it seems like the document turned out well, it still requires careful proofreading and correction. It can’t be handed over to the development team right after the AI.

Typically, at this stage, I already have a decent concept document on hand, clearly describing the idea of the game or its mechanics. It can be discussed with colleagues and worked upon further.

Using AI for Feedback

During the work process, I regularly upload working versions of the document to the AI, asking for feedback and suggestions regarding different blocks. Specific questions or concerns about particular text fragments often prove quite curious and useful. I recommend experimenting with existing documents and mechanics.

For curiosity's sake, try throwing your finished documents into the AI with questions like:

  • how else can this be done?
  • how is this done in other games (give examples)?
  • give advice on this mechanic, considering its interaction with this other mechanic;
  • assess from the perspective of a player who (describe the player’s style here).

You can also run the following amusing experiment:

  • ask the AI to make a summary of the finished document;
  • then throw this summary back into the AI with instructions to create a design document.

Sometimes the results are interesting.

Conclusion

For me, AI has made the documentation writing process simpler and unequivocally more fun. Starting to speak as it is very easy, and it quickly immerses you in work. Literally, within a few minutes, I am fully engaged in the process, even if I was recently staring at a blank page.

Yes, the tool is not the most convenient, but it is available to everyone and addresses the tasks set at the beginning of the article.

And with the emergence of neural networks, my code has noticeably improved! He-he.

Tags: