Agile Requirements Engineering in Practice: Status Quo and Critical Problems

Requirements Engineering (RE) is being treated differently in agile development when compared to more traditional development processes. Yet, there is little empirical knowledge on the state of the practice and contemporary problems in agile RE. As part of a bigger survey initiative (Naming the Pain in Requirements Engineering), the main goal of this paper is to build an empirical basis on such aspects of agile RE, based on the responses of representatives from 92 different organisations. Our survey data analyses revealed that agile RE concentrates on free-text documentation of requirements elicited with a variety of techniques. The backlog is the central means to deal with changing requirements. Commonly traces between requirements and code are explicitly managed and testing and RE are typically aligned. Furthermore, continuous improvement of RE is performed due to intrinsic motivation and RE standards are commonly practiced. Among the main problems, we highlight incomplete requirements, communication flaws and moving targets. Those problems were reported to happen commonly in agile projects and to have critical consequences, including project failure. Overall, our findings show that most organisations conduct RE in a way we would expect and that agile RE is in several aspects not so different from RE in other development processes.


Introduction
We have seen a substantial change in the way requirements engineering (RE) is practiced in today's software engineering projects because of the success of agile methods: "No matter the specific method, agile's treatment of requirements is fundamentally different" [12]. Furthermore, recent studies indicate that agile practices are frequently adapted to the particularities of their individual environments [6]. However, although we can experience a growth in the body of knowledge about software engineering practices, knowledge on the current state of practice in requirements engineering in general is limited [5]. Moreover, despite the importance of agile practices, little is yet known about how industrial environments conduct RE in an agile setting [3] and what problems they face. Such an understanding would be needed to steer future research in a problem-driven manner.
NaPiRE (Naming the Pain in Requirements Engineering) is an international initiative which tries to fill this gap and to establish a broad survey investigating the status quo of RE in practice together with problems respondents experience in their project environments. In this paper, we extend our previous publication [19], further investigating RE practices and problems in agile projects based on data from NaPiRE. In this extended version, we describe the results of each research question in further details and address two additional research questions, one on the RE status quo concerning RE standards and one on RE problems concerning their reported criticality and if they tend to lead to project failure.
The remainder of this paper is organised as follows. In Section 2 we provide an overview on related work concerning other empirical studies on agile RE and the NaPiRE initiative. In Section 3 we introduce our research questions, present the survey design, and describe the data collection and analysis procedures. In Section 4 the results for each of the research questions are presented. In Section 5 we discuss the limitations of our study. Finally, in Section 6 we conclude the paper.

Related Work
We briefly review the existing work on empirical studies on agile requirements engineering before we describe the context and previously published materials.

Empirical Studies on Agile RE
Heikkilä et al. [8] conducted a mapping study on requirements engineering in agile software development in 2015. Hence, it gives a good overview of the topic. They state that "the definition of agile RE is vague." This is reflected in the primary studies that often do not specify the concrete process model used. Most of the papers analysed in their mapping study contained some kind of empirical evaluation. We refer to their paper for details. Furthermore, there is a recent systematic literature review by Inayat et al. [9]. They summarise the results of 21 primary studies relating to agile requirements engineering. There is only one paper classified as survey research, which in turn conducts interviews focused on managing uncertainty and requirements changes [18]. Based on interviews with project managers of 16 Italian software companies, 8 using agile methods and 8 using documentation-driven methods, they conclude that agile organizations handle requirements changes differently (i.e., mainly using backlogs instead of formal change requests with impact analysis).
Closely related to our goal of gathering the state of the practice and contemporary problems is the qualitative study conducted by Cao and Ramesh [3] in 16 software development organisations on their agile RE practices. They identified and rated detailed RE practices. They found, for example, that face-to-face communication, prototyping and reviews and tests are common agile RE practices. To some degree comparable is only the survey by Bustard et al. [2]. They investigate the maturity of agile development principles and practices but also touch the topic of requirements. They found that their participants see a process benefit in agile requirements gathering and management. It is also mentioned that while quality requirements were all improved by agile methods, one company stated a "generally weaker treatment of non-functional requirements in an agile approach". Additionally, agile requirements tend to reduce the focus on requirements specification activities, which may lead to documentation debt. A recent retrospective study on the impact of agile requirements documentation debt on software projects indicated that it can have severe consequences on the overall project maintenance effort [13]. This reinforces the interest in further investigating RE problems in the context of agile projects.

The NaPiRE Initiative
The NaPiRE (Naming the Pain in Requirements Engineering) initiative was started in 2012 in response to the lack of a general empirical basis for RE research. The idea was to establish a broad survey investigating the status quo of RE in practice together with contemporary problems practitioners encounter. This should lead to the identification of interesting further research areas as well as success factors for RE. We created NaPiRE as a means to collaborate with researchers from all over the world to conduct the survey in different countries. This allows us to investigate RE in various cultural environments and increase the overall sample size. Furthermore, we decided to run the survey every two years so that we can cover slightly different areas over time and have the possibility to observe trends. NaPiRE aims to be open, transparent and anonymous while yielding accurate and valid results.
At present, the NaPiRE initiative has over 50 members from 23 countries mostly from Europe but also North-America, South-America and Asia. There have been two runs of the survey so far. The first was the test run performed only in Germany and in the Netherlands in 2012/13. The second run was performed in 10 countries in 2014/15. All up-to-date information on NaPiRE together with links to instruments used, the data, and all publications is available on the web site http://www.re-survey.org. The first run in Germany together with the overall study design was published in [15] with the detailed data and descriptive analysis available as technical report [14]. It already covered the spectrum of status quo and problems. Overall, we were able to get full responses from 58 companies to test a proposed theory on the status quo in RE. We also made a detailed qualitative analysis of the experienced problems and how they manifest themselves.
For the second run, we have published three papers [10][11] [16] concentrating on specific aspects and the data from only one or two countries and one paper [17] focusing on RE problems, causes and effects based on the complete data set. An analysis of the data with a focus on the state of practice of RE in agile projects was recently published [19]. The paper at hand represents its more detailed journal extension.

Survey Design
This paper uses a part of the overall NaPiRE design: we focus on the descriptive analysis of the state of the practice and potential problems in agile requirements engineering. For that, we analyse the data from the second NaPiRE run conducted in 2014/15. In the following, we detail the information on the study design relevant to the analysis presented in this paper.

Research Questions
We aim at understanding the state of practice of requirements engineering in agile projects. This cannot be exhaustive as there are too many aspects potentially relevant to agile requirements engineering. Our objective is to be generic to be able to apply the same instrument to non-agile projects. To this end, we formulate the following six research questions, shown in Table 1, to steer the design of our study. The first question (RQ 1) aims to capture the most basic activities in RE: elicitation and documentation. Yet, a key principle in agile development is that requirements are not stable. Hence, we want to understand how agile projects deal in particular with changing requirements (RQ 2). A further key principle in agile development is the continuous improvement of the development process itself. This should also hold for the RE process. Therefore, we are interested in whether agile projects perform continuous improvement and what is their motivation (RQ 3). Next, while agile methods emphasise flexibility, they still can have a standard way of doing RE. We investigate what kinds of standards agile projects use and how they apply them (RQ 4). As an RE standard, we consider both formal norms but also more informal conventions that guide the way of working in requirements engineering.
After gathering an understanding about the state of the practice, the last two questions focus on RE problems. We want to understand how important various potential problems for RE are in agile projects and what are their causes and effects (RQ 5). We also report on the criticality of the problems as indicated by the survey respondents and if they tend to lead to project failure (RQ 6). It is noteworthy that research questions RQ 4 and RQ 6 had not been addressed in the original version [19] of this extended paper and that the other research questions are also addressed with more details.

Instrument
The instrument used in NaPiRE constitutes in total 35 questions used to collect data on topics including the demographics, how practitioners elicit and document requirements and finally what problems practitioners experience in their RE. In this study, we focus on the status quo using the demographics only as context and to select the companies working in an agile manner. We will also discuss the main problems as rated by these companies, their criticality and if they tend to lead to project failure. Table 2 summarises the excerpt of our questionnaire in scope of this study.
The questions used in this study mainly consist of closed questions with mutually exclusive single choice or multiple-choice answers. Most of the closed multiple-choice questions include a free text option, e.g. "other", so that the respondents can express company-specific deviations. We furthermore use Likert-type scales on an ordinal scale of 5 and define for each a maximum value (e.g., "agree", or "very important"), a minimum value (e.g., "disagree", or "very unimportant"), and the middle ("neutral"). These are used to answer the first question on the problems (Q28) where we let the respondents rate the extent to which a given set of typical RE problems apply to their agile project environments. Respondents also selected the problems that, considering their context, represent the five most critical ones (in ordered relevance). Open text answers were provided for causes and implications of those problems and afterwards the ones considered as major causes for project failure were selected. Considering your personally experienced most critical problems (selected in the previous question), which would you classify as a major cause for project failure?

Data Collection
The survey is conducted by invitation only to have a better control over the distribution of the survey among specific companies and also to control the response rate. The responses were, however, anonymous to allow our respondents to freely share their experiences made within their respective company. For each company, we invited one respondent as a representative of the company. In case of large companies involving several autonomous business units working each in a different industrial sector, we selected a representative for a unit. For the data collection, each country representative defined an invitation list including contacts from different companies and initiated the data collection independently as an own survey (sub-)project. All surveys relied on the same survey tool hosted and administrated by the authors. We conducted the survey in North America (Canada, USA), South America (Brazil), Central Europe (Austria, Germany, Ireland) and Northern Europe (Estonia, Finland, Norway, Sweden). The data collection phases in each country and response rates are shown in Table 3.

Data Analysis and Validity Procedures
In the subset of NaPiRE that we will discuss in this paper, we conduct two types of analysis: The first analysis is frequency counting for questions in which the respondents choose one or more options. This is, for example, the case when they should choose which requirements elicitation techniques they use. We extract the counts using an R script which also creates bar charts from it. The second analysis is necessary for the question about contemporary problems. We analyse the Likert type data by transforming the answers to numbers from 1 to 5. Then, we calculate and report the median and the median absolute deviation (MAD) for each problem also using an R script. We refrain from a detailed qualitative analysis and coding of the free-text answers, because this is out of scope of this paper. Yet, we use them to substantiate the discussion and interpretation of the ranking of importance of the problems. The overall NaPiRE endeavor includes several procedures for checking validity, i.e., concerning the data collection and analysis phases, as described in detail in our previously published material [15].

Results
In the following, we summarise our results structured according to the research questions and beginning with an overview of the study population.

Study Population
Overall, we received 354 answers to the second NaPiRE run in 2014/15 out of which 228 completed the questionnaire. Out of these, we selected the 92 organisations that answered "Scrum" and/or "XP" as their development process model, but not "Waterfall", "V-Model XT" or "Rational Unified Process". Hence, the following results represent the situation of 92 different companies or business units (in case of large companies). To better illustrate the study population, we grouped organisations into small, medium, and large ones. For this grouping, we relied on the number of employees. Organisations with up to 50 employees were considered small, with 51 to 250 medium, and organisations with more than 250 were considered large. Table 4 summarises the distribution of the responses according to the different company sizes and the areas where they are situated.

Elicitation and Documentation (RQ 1)
We start answering RQ 1 by looking at how agile projects elicit requirements. We used the elicitation technique classification as provided in the SWEBOK (www.swebok.org). How often these elicitation techniques have been selected by our respondents is shown in Fig. 1. The most frequently used techniques are interviews, prototyping, and facilitated meetings. Scenarios are employed by about half of the respondents, observations by less than a third. Additional answers for Other included "Created personas and presented them to our stakeholders", "Questionnaires"/"Surveys" and "It depends on the client". We believe these answers fit very well to the expectations on agile projects. Roles like a product owner in Scrum would use interviews to understand the overall product requirements while the further elicitation is done in workshops with stakeholders and the sprint planning. Prototyping is usually not an explicit part of agile methods but building minimal viable products could be seen as a form of prototyping. Furthermore, paper prototypes or wire frames of user interfaces can also be useful in agile projects. Observations are not frequently used. Maybe there is potential to explore this kind of elicitation in more detail. But it might also be caused by a lack of possibilities for the developers. Next, we asked about the documentation of the most frequent type of requirements: functional requirements. The respondents could choose multiple items from different description techniques, namely (structured requirements lists, domain/business process models, goal models, data models, and use case models) as well as the degree of formality (free form, textual, textual with constraints, and semi-formal or formal).
As shown in Fig. 2, the three most frequent ways to document requirements are as free-form textual domain/business process models, free-form textual structured requirements lists and use case models as text with constraints. But also structured requirements lists as texts with constraints and free-form textual use case models are used by almost a third of the respondents. Data models are almost only used in a semi-formal notation such as the UML. Goal models are rarely used overall. Formal notations for requirements are also rarely used.
This again fits to the expectation of common agile methods: requirements are usually written down as text either in a free form or with some constraints (such as the role/feature/reason schema for user stories). Only data models are documented with a class diagrams or a variation of them. More semi-formal and formal documentation methods are probably too heavy-weight or unnecessary in the presence of automated tests for requirements. Especially the role of automated tests would be interesting to follow-up in further studies.
Finally, we briefly touched also the topic of non-functional requirements (such as security or performance requirements). We found that most respondents document non-functional requirements with text. About half of those document non-functional requirements either in a quantified manner, e.g., by defining concrete measurements, or in a non-quantified manner, e.g., by linking to external reference models or style guides. Answers for Other included "on our user stories" and "user story acceptance criteria". Overall, there seems to be no clear consensus if non-functional requirements should be documented in a quantified or non-quantified way in the given settings.

Changing Requirements (RQ 2)
In RQ 2, we are interested in how agile projects document changes in requirements. First, we asked how the respondents deal with changing requirements after the initial release. The answers are shown in Fig. 3. As to be expected, the overwhelming majority updates the product backlog when requirements change. Yet, 16 % only work with change requests and 15 % even have a requirements specification they regularly change. Answers for Other include "all methods, depends on the project" and "we mix product backlog and change requests". Overall, the product backlog seems to be the common way to work with changing requirements in agile projects, but it is not always clear how it works together with change requests. Next, we were interested in how the respondents analyse the effect of changes to requirements. As shown in Fig. 4, most respondents do impact analysis between requirements. More than a third analyse the impact of requirement changes on the code. A fifth do no analysis of the effect of changes to the requirements. Answers for Other included "test-driven analysis for TDD projects", "rerun test suites", "we discuss with users and decide the best approach" and "team-based discussion before change". Therefore, besides looking at requirements and code, the test suites and direct discussions with stakeholders seem important for impact analyses in agile projects.
A help for impact analysis are traces between requirements and code or between requirements and design documents. Concerning this question, more than half of the respondents answered that they explicitly manage traces between the requirements and the code. A third manages explicitly the traces between requirements and design documents. More than a fifth of the respondents do not explicitly manage traces at all. Finally, we had a question relating requirements and tests. We asked how the respondents align the tests with the requirements. As shown in Fig. 5, in agile RE, it is common to define acceptance criteria. This is what we would expect because specific test-driven practices which have become popular in and through agile methodologies like test-driven development [1] and behaviour-driven development [4] as well as the common user story practices demand to make acceptance criteria explicit. Furthermore, also coverage of requirements by tests is considered in a remarkable number of agile projects. Also in this case, test-driven practices linked to agile methodologies may be a trigger for that. In about half of the projects of the respondents, the testers participate in requirements reviews. This also means that half of the projects do have requirements reviews, which we would not expect from all agile projects as it is not demanded in common agile development processes. Finally, the derivation of tests from system models is only rarely done. Answers for Other include specific techniques ("BDD -Behavior Driven Development") as well as references to the used process model and that it prescribes the relation of requirements and tests ("The user story of the backlog is a good basis for creating a test case to test the base requirement(s) of that user story -Agile/Scrum").

RE Improvement (RQ 3)
Also, and maybe in particular, requirements engineering processes need to be improved. In an agile context, we would expect this improvement to be done continuously. We asked whether the organisations improve their RE continuously and who is responsible for this improvement. The results in Fig. 6 show that in more than half of the responding organisations, the RE is continuously improved and this improvement is under sovereignty of the project team. This is in tune with our expectations because of the deeply entrenched idea to regularly work on the development processes with, for example, retrospectives in Scrum.
Yet, also almost a third of the respondents have an own business unit or role responsible for the continuous improvement. Only few respondents use external consultants for that. Still, about 14 % of the respondents do not continuously improve their RE. At this point, we wanted to dig a bit deeper and understand the reasoning behind doing continuous improvement. As shown in Fig. 7, most of the respondents who do it because it helps them to determine their individual strengths and weaknesses and to act accordingly. Hence, the motivation is mostly intrinsic. Only a quarter or below give extrinsic reasons such as the expectation of the customer, certifications or regulations. Answers for the category Other include "Better efficiency", "To improve the quality in project development" and "We adopt an agile method that has inspection as one of the principles and adopt them to promote continuous improvement". Hence, continuous improvement in general as well as in RE is widespread in agile projects in practice. The motivation is intrinsic based on a perceived improved efficiency and because it is postulated by agile process models.

RE Standard (RQ 4)
As an RE standard, we consider both formal norms but also more informal conventions that guide the way of working in requirements engineering. Classical RE is often aligned with organisational or industrial software development or software life cycle standards to guarantee the quality of specified requirements and the overall RE process. In an agile context, we would expect that standards play a minor role.
For this reason, we asked what RE company standards are established in the respective organisation. The results in Fig. 8 show that in about half of the companies the RE standard is predefined by the development process. Taking a closer look into typical agile processes, this is not surprising because requirements artefacts play a prominent role to link customers and development and customer collaboration is even an important principle in the Manifesto for Agile Software Development [7]. In Scrum, for instance, the product backlog typically consists of user stories which often follow a specific format and which can be considered as requirements artefacts.
Standards that are predefined by a regulation, own standards that define artefacts, milestones and phases, as well as own standards that define artefacts and offer document templates are each equally used by about one fifth of the organisation. These more plan-driven types of standards seem therefore rather seldom in light-weight agile requirements engineering. Using other standards or not using a standard at all has been stated rather rarely. We then asked whether the applied requirements engineering standards are mandatory and practiced. The results in Fig. 9 shows that about two-third of the RE standards are actually practiced, although only about half of them are also mandatory. Standards in requirements engineering of agile projects are thus more commonly practiced than one might assume. On the contrary, only about 10 percent of the RE standards are mandatory but not practiced. This additionally emphasises that RE standards are actually practiced in agile projects even without external pressure as they seem to be beneficial for the overall project success. About 13 percent of the RE standards are neither mandatory nor practiced.

Common Problems in Agile RE (RQ 5)
Finally, after getting an overview of the current state of practice (RQ1-3), we wanted to know what common problems the respondents experience in their respective project environments. To this end, we presented a list of common RE problems and asked the respondents whether they agree that these problems occur in their setting. Table 5 summarises the problems, ordered from top to bottom according to the agreement by the respondents.
The problems ranked as low where not surprising to us considering the agile RE setting. For instance, volatility in the customer's business domain seems not to be a critical problem. Indeed, changes in processes or requirements are what agile processes are designed for and this shows in the little relevance of this problem in practice.
Similarly, unclear responsibilities are rarely experienced as a problem. The clear roles in agile processes seem to provide a good understanding here. Respondents who experienced this problem informed problems on the developer side or customer side to really understand and live up to their corresponding roles. Hence, the roles in agile RE seem to support clear responsibilities but they need to be clearly understood.
Some of the top ranked problems in turn can be argued based on the current state resulting from the agile process models used, such as unclear / unmeasurable non-functional requirements or underspecified requirements. The latter is caused by general problems in the capabilities of the involved people either on the development team ("Ability to write requirements and analyse customer needs") or on the customer side ("Customer clueless about functions of the system"). But also communication between the developers and the customers seem to cause these problems ("Developer may do their own wrong interpretation"). Furthermore, also in agile projects, it seems to be problematic to rush too quickly through defining what needs to be done ("Not enough time spent defining to the level of detail required").
For unclear or unmeasurable non-functional requirements, the cause seems to be mostly the reliance on experience ("Boils down to experience, on both ends. Non-functional requirements are easy to miss.") and unsuccessful communication ("think we talk about the same thing but not"). Agile RE might be able to provide more structure and terminology in this area to avoid consequences such as "Lots of surprises in deployment" and "unhappy end-users".
Some of the top-ranked problems, however, are at the same time surprising to us given that those problems also form a natural condition for agile projects. We refer in particular to moving targets and incomplete requirements which are stated as problems and which should motivate the use of agile practices. Even more, communication flaws within the project development team as well as communication flaws between developers and the customer are stated under the top problems. The moving target problem is caused by "Changing priorities", "Changes and instability in the customer organization are not isolated from our process. Their problems leak through." and "Mostly the reason is that the business is constantly learning at the same time or changes in management." This leads to "already specified requirements may become obsolete". Hence, fixing requirements during a sprint as, for example, emphasised in Scrum seems important to address these causes. Yet, overall the effects can be small: "If parties are on board that things are changing then the project won't have problems in term of budget, timeline etc. because everybody knows these are flexible as long as targets are moving. It will cause stress for dev team though." In many agile RE approaches, requirements are not meant to be complete but a cause for discussions with the customer. Hence, incomplete requirements are to be expected. When does this become a problem? It is a problem if the effect is "Rework or delivery that does not fully meet the customer's need." or "customer dissatisfaction (delivery that does not meet customer expectations)". It is caused by "Hidden requirements that are obvious to the customer" and inexperience of the product owner and customer ("Lack of experience of the Product Owner; Lack of clarity/understanding of the client"). Hence, the role of the on-site customer or product owner is a central one that needs to be filled with a person being able to understand the customers and elicit all important requirements.
The communication flaws seem to be mostly caused by missing time ("Also related to an attempt to gain time in developing.", "high need for meetings and documentation versus time") and more general communication problems ("Lack of open dialogue on the team.", "Our developers don't know the flows to generate questions to other teams."). These communication problems can lead to unnecessary work ("we waste time trying to develop new features that were developed by other teams previously") and generating unnecessary risks ("Unsolved problems due to the lack of dialogue between people.").
We interpret this as that the prerequisite on which agile RE relies, i.e. human-intensive continuous exchange, can quickly manifest itself as a critical problem. That is, agile RE does not necessarily solve all problems plandriven process models often have, but they become explicit once key prerequisites for successful RE are not met: human-intensive exchange and collaboration. Yet, it would be interesting to understand in more detail the causes and effects of these problems in agile projects.

Critical Problems in Agile RE (RQ 6)
While the previous section provided an overview on the problems commonly occurring in the context of agile projects, we also wanted to further understand how the criticality of those problems is judged by practitioners. Therefore, respondents were asked to select up to five most critical experienced problems. Additionally, they were asked which of those problems they would classify as a major cause for project failure. The results concerning problem criticality are shown in Table 6, which shows the list of problems ordered by the number of times each problem was cited as a critical one. It is possible to observe that the previously discussed problems incomplete requirements, communication flaws and moving targets are at the top of the list of criticality. It is also noteworthy that some problems that are not among the most frequent ones can have severe implications. For instance, insufficient support by the customer does not very commonly apply to agile projects (median 3, cf. Table 5) and was cited as a critical one in their projects by only 15 respondents, however, 10 (67%) of those respondents considered that this problem represents a major cause for project failure. Thus, the information contained in Table 5 and Table 6 is complimentary and should be interpreted together when aiming to base future research on agile RE on relevant problems faced in practice by the industry.

Limitations
Although our analysis is based on a broad family of surveys, we are aware that our study has limitations. First, our results emerge from a reasonable but still limited sample with a limited context model. We therefore cannot make concrete statements about how generalisable the results eventually are, let alone because we still are not able to estimate the representativeness of our population. Therefore, we need to follow our design of a family of surveys and further steer our continuous replications while capturing the context more precisely. Concerning the context, there is also a considerable number of projects claiming to follow Scrum or Extreme Programming and not working in that way. To some degree, this supports our findings from [6] that many companies claiming that they do Scrum actually deviate heavily from it. Therefore, in future surveys, we will need to differentiate in more detail.
Also, inherent to survey research is that surveys can only reveal stakeholders' perceptions on current practices rather than empirically backed-up knowledge about those practices. Although we were interested in revealing those perceptions, the answers given by our respondents might still be biased. We mitigated this threat by conducting the survey anonymously. Another threat related to survey research is that questions might eventually have been misunderstood. To help mitigating this threat we piloted the survey with selected industry participants before the trial to check if questions were clearly stated and easy to understand. However, we are aware that additional empirical methods should be applied to further explore the field based on project data.
Finally, NaPiRE was not intentionally designed to explore RE in agile contexts. This has two implications. First, the selection of our sample was based on the self-assessment of the respondents based on a predefined list of options in the process models. Second, although we could analyse different variations in the status quo of how our respondents do their RE, our instrument does not yet capture the particularities of agile practices (e.g. considering agile artefacts such as user stories). A richer investigation of facets important to agile RE forms part of future work where we redesign the instrument to give more attention to agile practices.

Conclusions
In this paper, we reported on the results from an analysis of the current state of practice and potential problems in agile requirements engineering. Our analysis is based on data gathered from a globally distributed family of practitioner surveys. The results shed some light on how requirements are elicited and documented, how our respondents deal with changing requirements, why and how RE is improved, how RE standards are used, and on common and critical RE problems. These results provide a further understanding on common practices and problems in the context of agile RE, helping to steer future research towards improving these practices and/or addressing these problems.
Concerning the agile RE status quo, we found that most of the responding organisations conduct RE in a way we would expect in agile projects. The documentation of requirements is dominated by free-text documents with some constraints. The backlog is the central means to deal with changing requirements. Code and requirements are explicitly linked and RE is continuously improved because of an intrinsic motivation. Furthermore, RE standards commonly practiced in agile projects as they seem to be beneficial for the overall project success. Hence, in terms of the current state of practice concerning elicitation, documentation, changes, improvement, and standards, agile RE is not so different from classical RE after all.
Regarding the contemporary RE problems, we compiled information on their occurrence and criticality. Our concluding analysis revealed that some of the problems often seen to come along the use of plan-driven process models do not commonly apply to agile projects. Others, however, which are often seen as a motivation for agile RE, e.g., moving targets, can still become dominant. Among the main problems we highlight incomplete requirements, communication flaws and moving targets. Those problems were reported to happen commonly and to have critical consequences, including project failure.
In future work we will dig deeper into specifics of agile RE to better understand which agile RE practices are related to which problems or their mitigation. The application of additional empirical methods to further investigate agile RE phenomena is also part of our plans.