# Agile usability engineering

Agile usability engineering is a method created from a combination of agile software development and usability engineering practices. Agile usability engineering attempts to apply the principles of rapid and iterative development to the field of user interface design.
Early implementations of usability engineering in user-centered design came into professional practice during the mid–late 1980s. Early implementations of agile software development evolved in the mid-1990s. It has only been within the past few years that the human-computer interaction community have seen widespread acceptance of agile usability engineering.

## History

When methods such as extreme programming and test driven development were introduced by Kent Beck, usability engineering had to become light-weight in order to work with agile environments. Individuals like Kent Beck have helped to shape the methodology of agile usability engineering by working on projects such as the Chrysler Comprehensive Compensation System. Such time-driven projects have helped individuals experience and understand the best methodologies to practice while working in an agile environment.
An early example of usability engineering in an agile software development environment can be found in the work of Larry Constantine and Lucy Lockwood who designed a browser-resident classroom information management system. During this process, the design team worked directly with an education team, which served as both subject-matter experts and representative end users to develop initial user role models and an inventory of task cases. This process mimics participatory design. With this material, mock-ups were iteratively designed to achieve the desired goal of “the stringent design objective of enabling immediate, productive use of the system based on a single-page tutorial.”
The following table displays the differences and similarities of light-weight processes compared to heavy-weight processes as suggested by Thomas Memmel.
| Heavy-weight processes | Light-weight processes |
| Detailed, up-to-date documentations and models | Card and hand-drawn abstract models Travel light Communicate rather than document |
| High-fidelity prototypes | Abstract prototypes, use simplest tools |
| Develop and prove concepts with user feedback Iterate | Courage Design for needs (user's tasks) rather than user expectations Retrieve design from models rather than continuous user feedback |
| Time-consuming usability evaluations, workshops with intense stakeholder integration | Fast usability inspections No need to evaluate if models are right |

## Methods

Many projects that are used in the agile software development process can benefit from agile usability engineering. Any project that cannot use models and representatives will have issues in an agile usability engineering environment, as the projects must be as light-weight as possible.
Throughout the usability engineering phase in agile development, users work with the product or service in order to provide feedback, problem reports and new requirements to the developers. The process is done interactively with focus directed first on basic functionality and later on with more advanced features. As the process progresses to advanced stages, more users work with the product or service. Solutions are quickly applied based on severity. The phase ends with a milestone.
Paul McInerney and Frank Maurer administered a case study confirming that UI design practices required adjustments; especially in order to adapt an iterative development. However, it was concluded that the resulting UI designs are certainly not worse than what would have been made with the standard heavyweight approach.
The core practices in agile modeling as described by Scott Ambler, help to describe the focus in agile usability engineering. The core practices include Validation, Teamwork, Simplicity, Motivation, Productivity, Documentation, and Iterative & Incremental.
A modified agile development process, with usability instruments included, was developed and presented in the CHI ‘08 Extended Abstracts on Human Factors in Computing Systems. The usability instruments includes extended unit tests for usability evaluations, extreme personas to extend the typical extreme programming user story, user studies to extend the extreme programming concept of the on-site customer, usability expert evaluations to solve ad hoc problems and usability tests to solve on-site customer representative problems.

## Issues

Due to the struggle of incorporating traditional usability engineering methods into an agile environment, many issues have risen. Without comprehensive resources, practitioners have tried to follow the patterns of others who have previously been successful. Table 2 represents the table of Problems, Symptoms, and Possible Solutions developed by Lynn Miller and Desirée Sy and presented in the CHI ‘09 Extended Abstracts on Human Factors in Computing Systems.
The following table is a summary of the main problems experienced by User Experience practitioners while doing Agile UCD.
| Problem | Symptoms | Possible Solutions |
| Not enough design time | • Developers waiting on designs • Design quality drop • Designs not verified with customers | • Separate and parallel UX Design/Developer tracks • Scope UX activities to be small, incremental • RITE formative usability testing • Rapid contextual design • "Design studio" • Design chunking • Combine different UX activities into one session • Bring user (and data) to you • Lighten requirements gathering process |
| Sprints are too short | • Designs can't be finished in time • No time for usability testing • No time to set up customer contact | • Separate and parallel UX Design/Developer tracks • Scope UX activities to be small, incremental • RITE formative usability testing • Rapid contextual design • "Design studio" • Design chunking • Combine different UX activities into one session • Bring user (and data) to you • Lighten requirements gathering process |
| Not enough user feedback | • Feedback not early enough • No data to act on – opinions rule • Product isn't validated | • Separate and parallel UX Design/Developer tracks • Scope UX activities to be small, incremental • RITE formative usability testing • Rapid contextual design • "Design studio" • Design chunking • Combine different UX activities into one session • Bring user (and data) to you • Lighten requirements gathering process |
| Weak agile "customer" | • End-users and clients won't participate • Cannot get buy-in from rest of team • Non informed decisions are made | • UX person can act as Agile customer role • Each UX person works on one scrum team • Choose which scrum teams to work with wisely • Validated designs are passed to developers to implement • UX participates in cycle planning, bringing appropriate user feedback • No features go in unless something comes out |
| UX is not full-time on one agile team | • UX time spent in many meetings instead of on designs and iterations • Demoralized by UX quality drop | • UX person can act as Agile customer role • Each UX person works on one scrum team • Choose which scrum teams to work with wisely • Validated designs are passed to developers to implement • UX participates in cycle planning, bringing appropriate user feedback • No features go in unless something comes out |
| No sprint/cycle planning | • Large backlog of features/bugs • Prioritization feedback ignored • No control over timing of designs | • UX person can act as Agile customer role • Each UX person works on one scrum team • Choose which scrum teams to work with wisely • Validated designs are passed to developers to implement • UX participates in cycle planning, bringing appropriate user feedback • No features go in unless something comes out |
| User feedback is ignored | • Feature set is cast in stone • No time to incorporate changes • No re-ordering of features is allowed | • UX person can act as Agile customer role • Each UX person works on one scrum team • Choose which scrum teams to work with wisely • Validated designs are passed to developers to implement • UX participates in cycle planning, bringing appropriate user feedback • No features go in unless something comes out |
| Missing the "big picture" | • No shared vision or end goal • Too much focus on details • Hard to prioritize/make design decisions | • Persuade agile team to adopt Cycle Zero • Consider design goals from different levels of detail (product, release, capability, design chunk |
| Poor communication | • Misunderstood designs • Agile team doesn't buy-into designs • Important information is lost | • Include developers in design process • Usability included in acceptance criteria • Daily contact to check progress • Design cards for stand-up meetings • Issue cards for usability reporting • Documents are for design team |
| Team isn't co-located | • No sense of team – lack of trust • Language and/or time barriers • Not enough communication | • Remote work tools (phone and web-based replacements • Co-locate for cycle planning |
| Dependency issues | • Requiring input from non-agile teams (e.g., marketing sign-offs, lawyers) | • A scrum leader or facilitator with strong persuasion skills can move things along quickly. |