When I first started working on games professionally in the early nineties, the role of designer was being instituted throughout the industry. Following the mold of prominent designers such as Shigeru Miyamoto and Sid Meier, designers were seen as directors of the game, or at least the people who came up with many of the ideas. The role required communication with the team on a daily basis but not much written documentation.
As technical complexity, team size, and project durations grew, the role of the designer became more delineated. Some projects had teams of designers who specialized in writing stories, scripting, tuning characters, or creating audio. Hierarchies emerged to include lead, senior, associate, or assistant designers, among others.
The overhead of communication with large teams and the cost of longer development efforts led to a demand for certainty from the stakeholders. Large detailed design documents attempted to create that certainty, but at best they only deferred its reckoning.
This chapter examines how Agile can reverse this trend.
“Designers are the chief proponents for the player. This has not changed in 20 years of game development. Though titles and roles have changed, designers look out for gameplay and quality of the product from a player’s perspective.
“When teams were small—with ten or less people—this could be done easily; it was a series of conversations while textures were created and code was written. The design was natural and organic as it emerged from the team. ‘Horse swaps’ could easily occur. For example, trading a very difficult-to-build mechanic for an easy one that still achieved the same gameplay vision was relatively simple.
“However, in the past ten years, teams have begun to balloon, first to the 30- to 50-person teams of the nineties and then finally to the occasional several-hundred-person monstrosities of the 2000s. A single designer could not have all the conversations that needed to happen (even several designers have problems). As a result, documentation began to surface that outlined the product as a whole, from the very high level to the very granular. Although this paints the initial vision of the title, it does away with one of the most important facets of any type of product development: the dialogue.
“Scrum addresses this. Five- to ten-person cross-discipline Scrum teams usually include a designer. Each of these designers is entrusted by the lead designer to understand the key vision elements and speak to the team.”
—Rory McGuire, Game Designer
The Solutions in This Chapter
What are some of the problems that face developers on large projects? The two most common problems are the creation of large detailed plans at the start of a project and the rush at the end of the project to cobble something together to ship. This chapter explores the solutions to these problems.
Designs Do Not Create Knowledge
Originally when designers were asked to write design documents, they rebelled. Writing a design document seemed like an exercise to placate a publisher or commit the designers to decisions they weren’t ready to make. Over time this attitude toward documentation has changed. Writing design documents has become the focus for many designers. It’s felt that this is the easiest way to communicate vision to both the stakeholders and a large project team.
Designers need to create a vision, but design documents can go too far beyond this and speculate instead. Once, on a fantasy shooter game I worked on, the designers not only defined all the weapons in the design document but how many clips the player could hold and how many bullets each clip contained! This level of detail didn’t help the team. In fact, for a while, it led it in the wrong direction.
Do they Really Read the Design Document?
One publisher demanded that our design document be at least 300 pages long. This was a puzzling requirement, but we had to do it to get approval for the rest of the game. As a test, we inserted a paragraph describing how SpongeBob SquarePants would make an appearance in our M-rated game. Our publisher never commented on the inclusion of a licensed character we had no permission for, which confirmed our suspicion that they never read the design document.
It turns out that we didn’t invent this practice. Managers for popular rock bands also include ridiculous requirements in the contracts they make with performance venues. The most notorious example was the requirement that the band be provided with a bowl of brown M&Ms before the show. If there were no brown M&Ms, it meant they didn’t read the contract and could be held in breach. In reality, no one in the band cared very much about the color of their candy.
The Game Emerges at the End
At the end of a typical game project, when all the features are being integrated, optimized, and debugged, life becomes complicated for designers. This is the first time they experience a potentially shippable version of the game. At this point it typically bears little resemblance to what was defined in the design document, but it’s too late to dwell on that. Marketing and QA staffs are ramping up and marketing campaigns are scheduled.
The true performance of the technology begins to emerge, and it’s usually less than what was planned for. This requires that budgets be slashed. For example, waves of enemy characters become trickles, detailed textures are decimated, and props are thinned out.
Because of deadlines, key features that are “at 90 percent” are cut regardless of their value. As a result, the game that emerges at beta is a shadow of what was speculated in the design document. However, it’s time to polish what remains for shipping.
Designing with Scrum
Successful designers collaborate across all disciplines. If an asset doesn’t match the needs of a mechanic, they work with an artist to resolve the issue. If a tuning parameter does not exist, they work with a programmer to add it. They also accept that design ideas come from every member of the team at any time. This doesn’t mean that every idea is valid. Designers are responsible for a consistent design vision, which requires them to filter or adapt these ideas.
Cops and Robbers
In the late nineties, while we were developing Midtown Madness, I was playing “capture the flag” after-hours in the game Team Fortress. One day it occurred to me that a version of “capture the flag” for our city racing game might be fun. I raised this idea with the game designer, and he suggested a creative variation called “cops and robbers.” In it, one group of players were robbers, while the other group were cops. The robbers try to capture gold from a bank and race to return it to their hideout. The cops try to stop the robbers and return the gold. This feature was a big hit with online players and seemed to be even more popular than racing! Good ideas can come from anywhere!
A Designer for Every Team?
A designer should be part of every cross-discipline Scrum team working on a core gameplay mechanic. He should be selected on the basis of the mechanic and his skills. For example, a senior designer should be part of the team working on the shooting mechanic for a first-person shooter. If the team is responsible for the heads-up display (HUD), then a designer with a good sense of usability should join the team.
The Role of Documentation
When designers first start using Scrum, they’ll often approach a Sprint as a mini-waterfall project; they’ll spend a quarter of the Sprint creating a written plan for the work to be done during the remainder. Over time this behavior shifts to daily collaboration and conversation about the emerging goal. This is far more effective.
This doesn’t mean that designers shouldn’t think beyond a Sprint and never write any documentation. A design document should limit itself to what is known about the game and identify, but not attempt to answer, the unknown. Documenting a design forces designers to think through their vision before presenting it to the rest of the team. However, a working game is the best way to address the unknown.
A goal of a design document is to share the vision about the game with the team and stakeholders. Relying solely on a document for sharing vision has a number of weaknesses:
Documents aren’t the best form of communication: Much of the information between an author and reader is lost. Sometimes I’ve discovered that stakeholders don’t read any documentation; it’s merely a deliverable to be checked off!
Vision changes over time: Documents are poor databases of change. Don’t expect team members to revisit the design document to find modifications. Recall the story of the animal requirement for Smuggler’s Run from Chapter 7, “The Product Backlog”; that was a case of failed communication about changing vision.
Daily conversation, meaningful Sprint and release planning, and reviews are all places to share vision. Finding the balance between design documentation and conversation and collaboration is the challenge for every designer on an Agile team.
Conversation Skills are Key
“Being able to have a good conversation is a fundamental part of a game designer’s toolkit. Learn how to ask questions, listen openly, and provide considered and informed answers. Just as important: make space for everyone to participate. The loudest voices, intentional or not, can hamper others’ contributions and understanding.”
—James Everett, Producer, Weta Gameshop
“Stay the %#&$ Out!”
One designer at High Moon Studios had a difficult time shifting his focus away from documentation when he joined his first Scrum team. At the start of every four-week Sprint, he locked himself in an office for a week to write documentation for the Sprint Goal. The team didn’t want to wait and pestered him with questions during this time. The constant interruptions led the designer to post a note on his door that read “Stay the %#&$ out! I’m writing documents!” Eventually, the team performed an “intervention” of sorts with the designer to get him to kick the documentation habit!
Parts on the Garage Floor
Agile planning practices create a prioritized feature Backlog that can be revised as the game emerges. The value of features added is evaluated every Sprint. However, many core mechanics take more than a single Sprint to demonstrate minimum marketable value. As a result, the team and Product Owner need a certain measure of faith that the vision for such mechanics will prove itself. However, too much faith invested in a vision will lead teams down long, uncertain paths, which results in a pile of functional “parts” that don’t mesh well together. I call this the “parts on the garage floor” dysfunction.
We saw one such problem on a project called Bourne Conspiracy. In this third-person action-adventure game, the player had to occasionally prowl around areas populated with guards who raise an alarm if they spot the player. This usually resulted in the player being killed. In these areas, the designers placed doors that the player had to open. At one point, an epic in the Product Backlog read as follows:
As a player, I want the ability to pick locks to get through locked doors and avoid noisy confrontations with the guards.
This is a well-constructed epic story. The problem was that there were no locked doors anywhere. This resulted in another story being created:
As a level designer, I want to have the ability to make doors locked so the player can’t use them without picking the lock.
This story is a little suspect. It represents value to a developer, but it doesn’t communicate any ultimate value to the player. Such stories are common, but they can be a symptom of a debt of parts building up.
The parts continued to accumulate as Sprints went by:
As a player, I want to see a countdown timer on the HUD that represents how much time is remaining until the lock is picked.
As a player, I want to hear lock-picking sounds while I am picking the lock.
As a player, I want to see lock-picking animations on my character while I pick the lock.
This continued Sprint after Sprint; work was being added to the lock-picking mechanic. It was looking more polished every review.
All of these lock-picking stories were building the parts for a mechanic that was still months away from proving itself. The problem was that lock picking made no sense. The player had no choice but to pick the locks. Nothing in the game required the player to choose between picking a lock or taking a longer route. Ultimately, the vision was proven wrong, and lock picking was all but dropped from the game despite all the work dedicated to it.
Figure 14.1 illustrates this problem of “parts on the garage floor.”
The figure shows many parts, developed over three Sprints, finally coming together in the fourth. This represents a debt that could waste a lot of work if it doesn’t pay off. It also prevents multiple iterations on the mechanic over a release cycle, because the parts are integrated only in the last Sprint.
Ideally, each Sprint iterates on a mechanic’s value. Figure 14.2 shows the parts being integrated into a playable mechanic every Sprint or two.
The approach changes the stories on the Product Backlog:
As a designer, I want doors to have a delay before they open. These doors would delay the player by a tunable amount of time to simulate picking a lock while the danger of being seen increases.
Notice that this story expresses some fundamental value to the player, which communicates a vision to both stakeholders and developers.
As a designer, I want to have guards simulating patrols past the locked doors on a regular basis so the timing opportunity for the player to pick the lock is narrow.
As a player, I want to unlock doors in the time that exists between patrols of armed guards to gain access to areas I need to go.
The first few stories are infrastructure stories, but they describe where the game is headed. They build the experience for the player in increments and explain why. The value emerges quickly and enables the Product Backlog to be adapted to maximize value going forward. This is in stark contrast to building parts that assume a distant destination is the best one. Iterating against a fixed plan is not Agile.
It Doesn’t Stop Here
Integration and discovery aren’t limited by a Sprint’s timeboxed iteration. Teams can integrate, explore, and even deploy on a daily basis if their teamwork, practices, and tools support it!
Creating Fun is Iterative and Collaborative by Nature
One year I took my family to Colorado to spend Christmas in a cabin. After a large snowstorm, my sons wanted to sled on the side of a small hill. So, I went to the local hardware store but could only find a couple of cheap plastic sleds. At first, the snow was too thick and the hill was too small for the sleds, so we packed down a path in the snow and built a starting ramp for speed. The sleds kept running off the track, so we packed snow on the sides. To increase speed, we poured water on the track to ice it—it began to look like a luge track!
After a few hours we had a great track. The boys would speed down on their sleds. They built jumps and curves and even a few branches into the track.
My oldest son said, “It’s lucky that you bought the perfect sleds!” I hadn’t done that, so we talked about it. The sleds weren’t perfect; we had merely iterated on the track to match their characteristics. We added elements, such as the sides to the track, to overcome the sled’s lack of control. We added other features, such as the ramp and track ice, to overcome the limitations of the thick snow and low hill. The sleds were the only thing that couldn’t be changed.
I couldn’t help comparing this to game development. We created an experience by iterating on things we had control over and adapted for things we didn’t. In this case, design was entirely constrained to working with the level (the track) and not the player control (the sled), and we were still able to “find the fun”!
When a project begins, the game we imagine is astounding. Players will experience amazing gameplay and explore incredible worlds where every turn reveals a delightful surprise. However, as we develop the game, we start to compromise. Imagination hits the limits of technology, cost, skill, and time. It forces us to make painful decisions. This is a necessary part of creating any product.
Identifying and narrowing down the set of possibilities is part of planning. For example, when we plan to create a real-time strategy game, we eliminate many of the features seen in other genres from consideration (see Figure 14.3).
Planning continues to narrow down the set of possible features. Following a high-level design, many developers refine discipline-centric designs. Designers plan the game design possibilities, programmers plan the technical design possibilities, and artists plan the art design possibilities. These possibilities do not perfectly overlap. For example, the designers may want large cities full of thousands of people, but the technology budget may only allow a dozen characters in linear levels. Figure 14.4 shows how the union of design, art, and technical possibilities overlap to create a set of features that all disciplines agree upon.
As mentioned earlier, the project starts with an area quite large in scope. As time goes by, the project staff gains more knowledge of what is possible, and the range of possibilities shrinks, as shown in Figure 14.5.
This refinement of scope slowly happens through iteration and discovery. It requires cross-discipline collaboration to find a common ground so that effort is spent on a rich set of features possible for everyone to succeed.
Problems occur when the disciplines branch off from one another and plan in isolation. If the disciplines refine their set of possibilities too early or in isolation, then it greatly reduces the set of overlapping options for the game. This approach is called point-based design in which a single discipline design is refined in isolation (usually the game design). The set of design options have been narrowed so much that the overlapping game feature set has been vastly reduced, as shown in Figure 14.6.
This is the reason for cross-discipline planning. It keeps options open and the union of all sets as large as possible, so when more is learned, the project has a wider range of options.
An example of the problem with a point-based design was with a level-streaming decision made early on a game called Darkwatch. Early in development the designers decided that contiguous sections of levels had to be streamed off the game disc in the background during gameplay so that the player felt the game was taking place in one large world. The decision was made although no technical or art tool solutions for such streaming existed.
Entire level designs were created based on the assumption that the technology and tool set would be created and that artists would be able to author the streaming levels efficiently. Unfortunately, these assumptions were proven false. The effort required to implement the full streaming technology left no time to create the tools necessary for the artists to manipulate the levels. As a result, the levels were “chopped up” into small segments, and these segments were loaded while the player waited. The gameplay experience suffered greatly from this.
Another approach to narrowing multidiscipline designs, called set-based design, is used to keep design options alive as a number of solutions are explored, and the best design is converged upon. Set-based design has been shown to produce the best solutions in the shortest possible time (Poppendieck and Poppendieck, 2003).
A set-based design approach to such a problem as the streaming level example is different from a typical point-based design. Instead, a number of options are explored:
A full level-streaming solution
A solution that streams portions of the levels (props and textures)
No streaming at all
As each option matures, knowledge is built to enable a better decision to be made before level production. Potential solutions are dropped as soon as enough is learned about cost, risk, and value to show that they weren’t viable. Although developing three solutions sounds more expensive, it is the best way to reduce cost over the course of the project.
Making decisions too early is a source of many costly mistakes. This is difficult to combat because such decisions are often equated with reducing risk or uncertainty. In point of fact, early decisions do not reduce risk or uncertainty. The delay of the level design decision in the set-based design approach is an example of postponing a decision as long as it can be delayed and no longer. This is an essential part of set-based design.
Learn by Failing Fast
Imagine we are playing the high/low game, where I have a secret number between 0 and 100 and you must discover that secret number by making a guess and having me tell you whether your guess is higher or lower than my secret number.
What do you usually guess first? The usual answer is “50.” How many times is “50” the right answer? Never! So why do you guess it? You guess “50” because it gives you the most information about what range my secret number is in. It eliminates half of the possible numbers with a single guess. No other guess eliminates as many numbers.
The same goes for exploring what is fun. We don’t aim for the right solution, but the one that gives us the most knowledge in the set. We set up experiments to provide us with this knowledge as quickly as possible. Creating huge designs up front is like taking 10 minutes to analyze the likely correct answer to the secret number from 0 to 100 and then announcing that “38” is the right choice. It’s just as likely to be wrong and gives us less knowledge than guessing “50.”
Lead Designer Role
The lead designer’s role is similar to other lead roles; he or she mentors less-experienced designers and ensures that the design role is consistent across multiple Scrum teams. Lead designers meet with the other project designers on a regular basis (often once a week) to discuss design issues across all teams (see Chapter 21, “Scaling Agile Game Teams”).
Scrum demonstrates—through Sprint results—whether the project has enough designers. Scrum teams challenge designers who cannot communicate effectively. A benefit of Scrum is in exposing these problems so that a lead designer will step in to mentor less-experienced designers.
Designer as Product Owner?
Many game development studios using Scrum make the lead designer the Product Owner for a game. This is often a good fit because the Product Owner role creates vision, and when we think of visionaries, we often think of successful designers such as Shigeru Miyamoto, Amy Hennig, Tim Shafer, and Will Wright. Lead designers make excellent Product Owners for the following reasons:
Designers represent the player more than any other discipline.
The product vision is driven primarily by design.
Design is highly collaborative. Experienced designers should be experienced in communicating vision to all disciplines.
On the other hand, designers often lack experience for some Product Owner responsibilities:
Responsible for the return on investment: Most designers I’ve known often need to be reminded of the cost implications of their designs! A Product Owner needs to carefully evaluate costs against the value for each feature.
Project management experience: Teams accomplish many, but not all, of the duties traditionally assigned to someone in a project manager role. Many requirements or resources that have long lead times require a long-term management view.
Avoiding a design bias: Product owners need to understand the issues and limitations for all disciplines. They cannot assume that everything outside the realm of design “can be handled by others.”
For these reasons, having a senior producer or project manager support the “designer as Product Owner” is often beneficial. This support role can be a voice of reason and cost management.
What Good Looks Like
Working with Shigeru Miyamoto taught me that the best designers are always questioning their designs and can objectively judge what players will enjoy. They don’t monopolize the ownership of ideas but actively encourage other disciplines to contribute creatively and to offer feedback based on their deeper knowledge of the opportunities and limitations of their own domains.
When I first learned of Scrum, I felt it was a framework for supporting this type of behavior from all disciplines. Culture and established work patterns slowed its implementation, but as we embraced the principles, we slowly adopted more of the mindset of game designers: thinking of how players might enjoy our game.
Agile reverses the trend of isolation of disciplines. This trend sees designers turning more to long-term plans and documentation to communicate with teams that are ever increasing in size. Scrum practices require the designers to collaborate and communicate face-to-face on small, cross-discipline teams.
In reversing this trend, designers need to embrace the benefit of emergent design. Designers do not have a crystal ball about any mechanic. The limitations of what is possible prevent this. Instead, they need to ensure that their vision is communicated and be open to all potential ideas.
McGuire, R. 2006. Paper burns: Game design with Agile methodologies. http://www.gamasutra.com/view/feature/2742/paper_burns_game_design_with_.php.