Key Takeaways
1. Prioritize User Experience in Game Development Tools
The main message of the presentation and of this book remains the same: the games industry needs to make the user experience of tools a priority.
Overlooked importance. The game development industry often focuses intensely on the player experience, yet frequently neglects the user experience of its internal development tools. This oversight leads to significant frustration, inefficiency, and lost productivity for content creators, technical artists, and level designers who rely on these tools daily. The author's personal journey highlights this gap, moving from frustration with inefficient tools to advocating for user-centered design.
Real-world impact. Poor tool UX isn't just an annoyance; it's a tangible drain on resources. The infamous Xerox 8200 photocopier, despite its advanced features, failed because users found it "too complicated." Similarly, game developers often blame users for not understanding tools, fostering a "RTFM" (Read The F***ing Manual) culture, when the real problem lies in the design itself.
A call to action. Investing in better tools is not merely a luxury but a strategic imperative. By improving the user experience of game development tools, studios can streamline workflows, reduce errors, accelerate new staff onboarding, and ultimately, make better games more efficiently. This book serves as a guide to achieving that crucial shift in mindset and practice.
2. Build Tools That Are Useful, Usable, and Desirable
In other words, a tool may have a nice-looking user interface (desirable), but if it is difficult to use (not usable) and does not fulfill the user’s needs (not useful), it can result in a bad user experience.
The UX Pyramid. A good user experience is built upon a hierarchy, much like Maslow's hierarchy of needs. A tool must first be useful (fulfilling a core need), then usable (efficient and easy to learn), and finally desirable (aesthetically pleasing and satisfying to use). Many game development tools only achieve the base level of being useful, forcing users to adapt to clunky interfaces.
Beyond basic functionality. Consider the analogy of a Warthog from the Halo franchise. A basic frame with wheels and an engine is useful for transport. Adding pedals, a comfortable seat, and standard controls makes it usable. Finally, features like tinted windows and a sleek paint job make it desirable, conveying quality and inspiring confidence in its protective capabilities. Without usability or desirability, even a useful tool can be frustrating and untrustworthy.
"More human" interactions. Alan Cooper and Don Norman advocate for software that behaves like a "good friend"—remembering preferences, helping clearly, taking responsibility, and being forgiving. Tools like CrazyBump or Unity's automatic normal map detection exemplify this by anticipating user needs and providing intuitive assistance, contrasting sharply with interfaces that feel like interacting with a "frustrating person."
3. Embrace the Iterative User-Centered Design Process
By applying the User-Centered Design process, we accept that we may not get it right the first time.
Continuous improvement. The User-Centered Design (UCD) process is an iterative cycle centered around the user, comprising three core phases: Analysis, Design, and Evaluation. It acknowledges that perfection is rarely achieved on the first attempt, emphasizing quick, constant iterations to refine and improve the user experience over time. This approach mirrors the evolution of popular products like the Apple iPod, which underwent several iterations to perfect its scroll-wheel.
Fail fast, learn cheap. A powerful aspect of UCD is pre-visualization, allowing designers to simulate user interactions before writing any code. Jeff Hawkins' use of wood blocks to prototype the Palm Pilot's form factor demonstrates how inexpensive, early-stage prototypes can prevent costly mistakes and foster a shared vision among teams. This contrasts with the common pitfall of building features without a clear, shared understanding, leading to rework and misunderstandings.
Integrating with Agile. UCD's iterative nature aligns well with Agile methodologies like Scrum. Design and evaluation phases can be integrated directly into sprints, ensuring small, rapid adjustments rather than large, time-consuming overhauls. This approach allows teams to start closer to the target user experience, adapting faster and with greater confidence, even if it means a slight delay in initial coding.
4. Focus on User Goals, Not Just Features
One important point that we need to understand is this: it is not the user’s job to design the user interface.
"We are not the users." A fundamental mistake in tool development is assuming developers inherently understand user needs. Developers, often highly technical, may design tools based on internal data structures or personal preferences, rather than the actual goals and context of the content creators. This leads to overly complicated interfaces packed with features that don't align with how users think or work.
Features vs. goals. Users often struggle to articulate what they want in terms of features, but they are excellent at describing what they want to accomplish. The analogy of a Swiss army knife versus scissors illustrates this: a Swiss army knife has many features but is mediocre at any one; scissors do one thing exceptionally well (cut paper). Understanding the user's goal (e.g., "cut paper") allows designers to create the right tool for the task, rather than just adding more options.
Strategic feature selection. Just as Henry Ford famously (though misattributed) sought a "faster horse" before inventing the automobile, understanding user goals enables innovative solutions. Companies like Google and Apple succeed by focusing on doing "one thing really, really well" and being "proud of the things we haven't done." This means prioritizing features that serve the most frequent users and their core goals, avoiding the exponential complexity that arises from trying to please everyone with every possible feature.
5. Observe Users to Uncover Real-World Problems
To discover which designs work best, watch users as they attempt to perform tasks with the user interface.
Beyond metrics and opinions. While metrics tell us what is happening (e.g., a button isn't clicked), they rarely explain why. Focus groups, often dominated by the loudest voices, also fail to capture the true user experience. The most effective way to understand user behavior is through direct observation, sitting beside them as they work in their natural environment. This qualitative approach uncovers nuances, work-arounds, and unspoken frustrations that quantitative data misses.
Contextual analysis. This technique involves observing users at their desks, with their tools, as they normally would. Key practices include:
- Building rapport: Introduce yourself, ease discomfort, and emphasize that the tool is being evaluated, not them.
- Asking about goals: Redirect feature requests to "What are you trying to accomplish?"
- Master and apprentice: Ask them to demonstrate their workflow, listening more than talking.
- Talking out loud: Encourage users to verbalize their thoughts and decision-making processes.
- Resisting the urge to help: Allow users to struggle; their difficulties reveal critical design flaws.
Uncovering hidden issues. Observing users often reveals "work-arounds"—inefficient methods users adopt because the tool doesn't support their natural workflow. These are often so ingrained that users forget they're even doing them. By understanding these, designers can address the root problem, not just surface symptoms, leading to more impactful improvements.
6. Design for the Human Mind: Action Cycle and Mental Models
Major differences between the user’s mental model and the tool’s conceptual model is one of the key reasons why users have difficulty understanding how a tool works.
The Human-Computer Interaction loop. User interaction is a continuous loop: the human looks at the interface, thinks about what to do, and then acts. The computer responds, and the cycle repeats. Efficient tools minimize time spent in the "look" and "think" phases, allowing users to spend more time "acting." This is influenced by mental loads: cognitive loads (thinking) are heaviest, followed by visual (looking), and then motor (acting). Counterintuitively, more clicks aren't always bad if each click is a "mindless, unambiguous choice" that reduces cognitive load.
Learnability and the learning curve. Tools should be designed to guide users from beginner to expert. Beginners need visible cues and clear explanations (knowledge "in the world"), while experts benefit from shortcuts and customization (knowledge "in the head"). If a tool is difficult to learn, users may stick to inefficient "long ways" of doing things, hindering overall productivity.
Aligning mental and conceptual models. A mental model is how a user thinks a system works, while a conceptual model is how it actually works. Discrepancies cause confusion. For example, a programmer's mental model of a "point light" might involve technical data structures, but an artist's mental model is visual (color, intensity, range). Tools like Photoshop's brush palette or Unity's Tree Creator succeed by presenting complex technical concepts in a way that aligns with the user's intuitive mental model, simplifying learning and use.
7. Leverage Visual Language and Standard Interaction Patterns
When choosing icons for your game development tools, strive for familiarity over a new design.
Speaking the user's language. Just as video games use visual language (e.g., distinct character silhouettes, team colors in Team Fortress 2) to communicate information quickly, tool interfaces should too. This involves consistent use of shapes, colors, and iconography that users can recognize at a glance. Familiar icons, even if technically outdated (like the floppy disk for "save"), are processed faster by the brain than novel, "perfect" representations.
Consistency is paramount. Inconsistent visual language leads to confusion. If variables are blue in one part of a code editor and green in another, it breaks the learned pattern. Similarly, using red for non-critical information when red typically signifies "danger" or "error" can cause unnecessary alarm. Adhering to established color standards (green for OK, yellow for caution, red for danger) and maintaining consistency across the interface is crucial.
Standard interaction patterns. Users develop expectations for how interface elements behave. Radio buttons mean "choose one," checkboxes mean "choose many." Deviating from these established interaction patterns (e.g., using a custom dial instead of tabs for view switching) forces users to learn new behaviors, increasing cognitive load and reducing efficiency. Following guidelines from major platforms like Microsoft and Apple ensures familiarity, allowing users to focus on content creation rather than deciphering the interface.
8. Guide Users with Hierarchy, Constraints, and Progressive Disclosure
Good constraints make the users more confident about using the tool, so they can focus on creating content.
Hierarchy for focus. Graphic design principles of hierarchy (position, thickness, size, contrast) can direct the user's attention to the most important information, reducing time spent scanning the interface. For instance, Google's weather card uses large, bold text for the current temperature, making it instantly noticeable. This helps beginners find key functions and experts quickly locate relevant data.
Constraints for safety. Constraints limit user actions to prevent mistakes, making tools more robust and users more confident. A slider for a numeric input, for example, inherently prevents out-of-range values. Apple's Lightning cable, which can be plugged in either way, is a superior constraint to a USB cable, which still allows for incorrect attempts. Good constraints protect users without requiring them to think about limitations, freeing them to focus on creative tasks.
Progressive disclosure for clarity. Progressive disclosure means showing only the necessary parts of an interface at first, gradually revealing more complexity as the user needs it. This technique is invaluable for managing the exponential complexity that new features introduce. A simple interface for beginners, with options to expand for experts (like Windows' "More details" for file transfers or Adobe's collapsible panels), prevents information overload and allows users to customize their view, enhancing both learnability and efficiency.
9. Provide Clear Feedback and Proactive Feed-Forward
Feedback is all about how the tool communicates with the user.
Responsive communication. Just as humans expect immediate responses in conversation, users expect tools to communicate their status. Feedback informs the user about what the tool is doing now, what just happened, or how much time is left. Jakob Nielsen's research highlights critical response time limits: 0.1 seconds for instantaneous feel, 1 second for uninterrupted thought flow (needs wait cursor), and 10 seconds for maintaining user attention (needs progress bar). Without feedback, users may assume a crash, force-close the application, and lose work.
Managing expectations. Progress bars, like those in Microsoft Windows for file transfers, don't just show progress; they manage user expectations and reduce perceived wait time. They confirm the system is working, allowing users to confidently switch tasks. However, feedback overload can be counterproductive; designers must filter information to provide only what is relevant to the user's goals, avoiding unnecessary "noise."
Anticipating actions. Feed-forward is the opposite of feedback: it shows the user what will happen before they commit to an action. This is crucial for destructive or complex operations. Microsoft Word's style preview, which applies formatting to text on hover, allows users to experiment without committing. Similarly, Unity's material drag-and-drop preview instantly shows how a material will look on an object. Feed-forward reduces cognitive load, encourages exploration, and prevents errors, making the tool more learnable and efficient.
10. Evaluate Designs Early and Often with Pre-visualization and User Tests
The first time the user has a sense of how a tool works is when it is already done, and that is often one of the main reasons why a tool can have a bad user experience.
Choosing the right evaluation method. After designing improvements, the next step is evaluation. The decision to go straight to code or use pre-visualization depends on factors like complexity, available programming resources, and the primary goal (efficiency vs. learnability). Pre-visualization is ideal for complex changes or when measuring learnability, as it's faster and cheaper to iterate on. Coding is better for small changes or when precise efficiency measurements are needed.
Pre-visualization techniques:
- Sketches: Quick, low-fidelity drawings (whiteboard, paper) for rapid ideation and honest feedback.
- Paper Prototypes: Interactive sketches using physical materials, often employing the "Wizard of Oz" technique (one person simulates the interface). Great for simulating interaction cheaply.
- Interactive Prototypes: Digital prototypes created with specialized tools (Axure, Balsamiq) that simulate interface behavior on a computer. Good for remote testing and more complex interactions.
Heuristic evaluation. When users aren't available, a heuristic evaluation (using established usability principles like Jakob Nielsen's 10 heuristics) can identify common usability problems. This involves systematically checking the design against principles like "Visibility of System Status," "Consistency and Standards," and "Error Prevention." While useful, it should always be followed up with actual user testing.
User tests. The most effective way to evaluate UX is through user tests. This involves building a test plan with specific, realistic tasks phrased as questions ("How would you do this?"). Testing with 5-7 users who match the target profile (e.g., all level designers for a level editor) yields the most accurate results. During tests, resist helping, observe closely, and record interactions to gather valuable insights.
11. Measure Improvements to Quantify User Experience ROI
One accurate measurement is worth more than a thousand expert opinions.
Beyond intuition. In game development, we meticulously track performance metrics for CPU, GPU, memory, and budgets. Yet, the efficiency and learnability of development tools are rarely measured. This often leads to relying on "expert opinions" or gut feelings about whether a tool improvement is truly beneficial. As Admiral Grace Hopper famously stated, "One accurate measurement is worth more than a thousand expert opinions."
Establishing baselines and tracking progress. The Analysis phase is crucial for establishing measurable Key Performance Indicators (KPIs) related to efficiency and learnability. For example, timing how long users take to complete specific tasks provides a baseline. After design changes and evaluation, comparing new measurements against this baseline objectively demonstrates whether the improvements are moving the tool in the right direction.
Calculating the return on investment (ROI). Quantifying UX improvements in terms of time and money saved is essential for gaining stakeholder buy-in. The example of improving a cut-scene camera tool showed that an initial investment of $30,000 (for developer time) resulted in a $12,500 return over six months, simply by reducing task completion times. This tangible ROI proves that investing in UX is a sound business decision, not just a "nice-to-have."
12. Foster a Culture Where Everyone Owns User Experience
It’s actually everyone’s job to make the user experience good.
Beyond the designer. The success of companies like Apple isn't solely due to having the "best designers." It's because everyone in the organization—from engineers to project managers—is invested in and contributes to improving the user experience. This requires a fundamental culture shift where UX is seen as a collective responsibility, not just the domain of a specialized team or individual.
Breaking down silos. Traditionally, tools developers might be scheduled for other tasks immediately after a tool's initial release, leaving no one to address user feedback. This leads to stagnant, frustrating tools. A cultural shift means allocating resources throughout the production cycle, allowing for continuous UX improvement based on ongoing user feedback. It means project managers understanding the long-term value of UX investment.
Empowering every role. This book provides concepts and techniques accessible to anyone involved with game development tools—makers, users, and beneficiaries. By internalizing these principles, developers can intuitively apply user-centered thinking, technical artists can better bridge the gap between users and developers, and stakeholders can make informed decisions that reduce risk and save money. Ultimately, when everyone works together to make better tools, the entire game development process benefits, leading to higher quality games and a more satisfying work environment.
Last updated:
