In most agile development teams the responsibility of writing user stories falls into the hands of the analyst. The analyst not in all cases may be well versed with the idea of writing stories. This is not because he does not know what to write but sometimes because he does not know the best way to express the story in the chosen story writing platform. This doesn't warrant a developer to pair with an analyst to author a story, In my opinion developers are not welcome to pair with the analyst to author user stories. Allowing this will allow implementation detail to find its way into the stories and sometimes they dictate the users intention.
The best person for your analyst to pair with should be your QA, this proves to be the most useful.
- The QA looks at a story early in the life cycle and ensures all aspects of the story are testable.
- The ownership of the story is with the QA and he/she is able to identify any automation concerns of the story..
- Any scenarios that have not been through in a story due to data related anomalies are identified.
- The QA is involved in this process early on before the iteration in which the story is picked up , this will allow the QA to bring in some valuable information on the size of the story to the planning session.
- Since the QA gets an understanding of the story before a developer is involved his view of the story is as close as possible to the users requirement in the story. This important to make sure the intention of the user is not skewed by the understanding of a developer.
- The QA is able to identify any smoke tests that may be required to be run when a release is deployed to UAT or Live.
In our current project our QA starts automating user stories when he runs out of stories to test. In most cases the QA to dev ratio is 1:2 or 1:3 and so the QA gets bogged down with implementing acceptance criteria so the team has enough stories to dev on. It helps for devs to pair with QAs to automate acceptance tests and my observation has been the following
- On a normal day we developers are more in sync with writing better code than QA’s, developers can always help in writing better test code.
- When developers implement the acceptance criteria in the form of Given When Then, they actually are implementing the story itself.
- Developers will get an idea of how to implement the story and tests required when they actually develop the story.
- Where the story is looking for new elements on the UI, developers can aid in mocking the UI for the story else automating all the steps of the user story could be a night mare for the QA all on his own.
PS : My Selfish reason - Developers learn a new language .. I learnt ruby this way :)
In effect when three different people with different skills are involved in the authoring and automation of the story, this will ensure a lot more analysis happens and more often than not edge cases are discovered ahead of development. Any edge cases which will increase the cost of the story can be identified and a decision made taken if they have any real value in development.