Chapter 12. Agile Design

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 help reverse this trend.

The Problems

What are some of the problems that face developers on large projects? The two most common problems are the creation of large documents at the start of a project and the rush at the end of the project to cobble something together to ship.

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 them in the wrong direction.

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 the designer. 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 disc production and marketing campaigns are scheduled.

The true performance of the technology begins to emerge, and it’s usually less than what was planned for during production. 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%” 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. The designer is responsible for a consistent design vision, which requires them to filter or adapt these ideas.

A Designer for Every Team?

A designer should be part of every cross-discipline Scrum team working on a core gameplay mechanic. They should be selected on the basis of the mechanic and their 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 a designer 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; 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.

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, a user story in the product backlog read as follows:

As a player, I want the ability to pick locks to get through locked doors.

This is a well-constructed 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 12.1 illustrates this problem of “parts on the garage floor.”

Figure 12.1. Integrating a mechanic at the end of a release

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 12.2 shows the parts being integrated into a playable mechanic every sprint or two.

Figure 12.2. Integrating a mechanic every sprint

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.

Set-Based Design

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 12.3).

Figure 12.3. Narrowing the game to a specific genre

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 12.4 shows how the union of design, art, and technical possibilities overlap to create a set of features that all disciplines agree upon.

Figure 12.4. The set of possibilities at the start of a project

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 shrink, as shown in Figure 12.5.

Figure 12.5. The set of possibilities as the project progresses

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 12.6.

Figure 12.6. Narrowing game design too soon

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 since 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.

Lead Designer Role

The lead designer’s role is similar to other lead roles; they mentor less-experienced designers and ensure 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 8, “Teams,” to learn about communities of practice).

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 since the product owner role creates vision, and when we think of visionaries, we often think of successful designers such as Miyamoto, Shafer, Wright, and Meier. 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, it’s often beneficial to have a senior producer support the “designer as product owner.” A producer can be a voice of reason and cost management.

Summary

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. No designer has 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 open to all potential ideas.

Additional Reading

McGuire, R. 2006. Paper burns: Game design with agile methodologies. www.gamasutra.com/view/feature/2742/paper_burns_game_design_with_.php.