How We Designed Our NPC Editor to Be Usable by an Eight-Year-Old

🧸 A confident eight-year-old should be able to give a boss its own patrol route without ever seeing the word "script." That single sentence is close to a design brief. It is also a genuinely hard interface problem, because most tools that let you customize how a character behaves were built for people who are comfortable with menus, parameters, and a little bit of trial and error under pressure. Kids are willing to experiment fearlessly — but only if the interface doesn't punish them for it.

An NPC (non-player character) is any character in a game that's controlled by the game itself rather than a human player — a boss, a shopkeeper, a wandering villager. Lokko's NPC editor exists inside that tension. The tutorials for it are literally titled "CUSTOMIZE NPCs WITH EDITOR" and "NPC BEHAVIOUR," and the game's own homepage invites players to "check out the range of customizable NPCs and bosses." Lokko EDU groups the skills needed to use it — level editors, timers, switches, and NPC behaviors — into an 8-13 age tier. That places the tool squarely in the age range the title references, without us needing to claim a specific study proved it. What follows isn't a case study with a testing log and a quote from a focus group. It's an honest look at the general design principles the editor leans on, and why those principles matter for an audience that hasn't yet built the mental models adults take for granted.

Icon-First, Not Text-First

The first thing a young creator sees in any customization menu matters enormously. If that menu is a wall of labeled dropdowns, a child who isn't yet a fluent reader has to stop and decode it before they can even begin experimenting.

The editor is built around recognizable icons over paragraphs of instructions. A picture of a character walking back and forth communicates "patrol" faster than the word itself, especially to a reader who is still sounding out longer words. This isn't a shortcut for adults either — it's a well-established accessibility principle: icon recognition is faster than text comprehension for almost everyone, and the gap is largest for young or less confident readers.

• Behaviors are represented by simple, literal pictures rather than technical labels.
• Menus favor a small number of large, tappable choices over long scrollable lists.
• Where text does appear, it stays short — a phrase, not a sentence.

Preset Behaviors Instead of Open-Ended Scripting

A powerful NPC editor could, in theory, expose raw logic: conditionals, variables, event chains. That's exactly the kind of system that scares off a young creator, because it turns "make the boss chase me" into an assembly problem with dozens of failure points.

The design leans on presets, not blank-slate scripting. A child chooses from a curated set of behaviors — patrol, chase, guard — instead of building logic from scratch.

This mirrors a broader pattern in tools built for young or first-time creators: constrain the possibility space so every choice is a valid one. You can't "break" an NPC by picking the wrong preset the way you could by writing a malformed script. The tradeoff is real — presets are less flexible than open scripting — but for the target age group, reliability beats flexibility every time. This same philosophy shows up in Lokko's 2D Editor, where hazards, platforms, and triggers are placed as ready-made pieces rather than assembled from primitives.

Why the Same Principle Shows Up Twice

Icon-first menus and preset behaviors look like separate design decisions, but they're really solving the same problem from two angles: both remove a step where a young creator could otherwise get stuck without knowing why. A text-heavy menu risks losing a child at the reading stage, before they even reach a decision; open-ended scripting risks losing them at the logic stage, after they've already invested effort. Presets alone wouldn't help much if the menu presenting them still required fluent reading, and icon-first design alone wouldn't help much if the choices behind those icons still demanded scripting knowledge. Put differently: the editor has to be forgiving at every step a child passes through, not just the first one, or the whole chain breaks at whichever step was overlooked.

Immediate Visual Feedback

Nothing teaches a tool faster than watching it respond instantly. When a child assigns a behavior to an NPC and that character visibly starts patrolling or reacting right away, the connection between "the button I pressed" and "what happened" is obvious. Delay that feedback — force a save, a compile step, or a separate "test mode" toggle — and the connection gets fuzzy, especially for a young learner who hasn't yet built the patience adults have for indirect cause and effect.

Editors aimed at this age group generally treat live preview as non-negotiable rather than a nice-to-have. Seeing a boss immediately guard its assigned spot, or a friendly NPC immediately start wandering, turns the editor into something closer to a toy you're playing with than software you're operating.

Large Targets, Forgiving Undo

Fine motor precision develops over years, and a lot of young players are on tablets or touchscreens where a slightly-off tap is common, not exceptional. Two design choices tend to matter most here:

• Large click and tap targets — small icons crammed together invite mis-taps, and a mis-tap that's hard to notice is worse than one that's obvious.
• Forgiving undo — every choice should be easy to reverse, so a wrong pick is a two-second correction rather than a reason to give up.

Together, these two principles turn mistakes into a non-event. That matters more for kids than for adults, because a young creator who hits a wall they can't recover from is far more likely to simply stop playing than to troubleshoot their way out of it.

A mistake should always feel like a shrug, not a setback. That's the bar a forgiving editor has to clear.

Why This Matters Beyond NPCs

The same reasoning applies everywhere Lokko asks a young creator to make a decision — placing a hazard in the 3D Editor, setting up a switch, or designing a character's look without touching a 3D modeling tool. See our guide on making a game character without 3D modeling for more on that last one. None of these tools assume the person using them already knows how game logic works under the hood. They assume curiosity and a willingness to click around — and they're built to reward that willingness instead of punishing it.

If you're introducing a group of kids to game design in a classroom setting, the same principles — icon-first choices, presets over scripting, instant feedback — are worth applying to whatever activities you plan around the tool. Our classroom game-design activities guide leans on the same idea: give kids a small set of confident choices rather than an open-ended blank page. And if you're weighing several creation tools against each other for a young creator, our comparison of age-appropriate game creation tools walks through how different platforms handle exactly this tradeoff between depth and accessibility.

Key Takeaways

• Lokko's NPC editor is covered by the "CUSTOMIZE NPCs WITH EDITOR" and "NPC BEHAVIOUR" tutorials, and Lokko EDU places these skills in its 8-13 age tier.
• Icon-first menus reduce the reading burden that text-heavy interfaces place on younger or less confident readers.
• Preset behaviors (patrol, chase, guard) replace open-ended scripting, trading some flexibility for reliability and a lower barrier to entry.
• Immediate visual feedback helps young creators connect their choices to what happens on screen without a separate test step.
• Large touch targets and forgiving undo turn mistakes into quick corrections instead of dead ends.
• These same principles carry across Lokko's other free, browser-based tools — the 2D and 3D editors don't require a download or account to start exploring.

Try the NPC Editor Tutorials

See this same read-between-the-lines approach applied to real player feedback in what Early Access feedback changed about our game.