Overview
“User story smells” is a term used by Mike Cohn in User Stories Applied. It describes anti-patterns that happen when writing user stories. Mike Cohn provided a number of story smells.
With 9 years Business Analysis experience, I decided to write my top 10 story smells. They are based on my observations. I’ve even created a game for people to try.
Smell 1 – Everything in a Sprint should be written as a user story
This seems to happen with less experienced agile teams. They use the story format for everything in a Sprint (e.g. As a developer … I want … So that).
Why is it bad? User stories are written from the perspective of end users. They ensure what you build is anchored on a user need. Technical tasks can be sub-tasks of user stories (preferred option), or just tasks that need to be done to keep the lights on (e.g. renew a cert).
User stories are one type of item in the product backlog. Other types of item include: bugs, tasks, epics and spikes. Item can be in a Sprint without being user stories. Don’t spend time thinking how a technical sub-task can fit into the user story format. 
Smell 2 – Stories should be sliced by technology layer, because that’s how our development team will approach them
Teams can have different groups of developers (e.g. front end and backend developers). There can be pressure to slice stories accordingly, because each story will be done by a different development team. Another reason is that breaking it down by technology layer removes a dependency on other developer teams. This is an artefact of how the development team is split.
The problem with this approach is that technology slides do not produce a valuable deliverable for the end user. The front end slice must plug into the backend to add value. Vertical slices of functionality are preferred to horizontal technology slices. Vertical slices are much more likely to be potentially shippable.
Smell 3 – Stories don’t need acceptance criteria
This is a strange one – I’ve seen it before. The idea is that the BA/product team should not solutionise. They should present the user need/story to the developer and not come with a list of acceptance criteria/constraints.
The problem is – you need a clear outcome for a story. And there are often clear requirements from the business, or constraints to be considered. Just putting AS I … I WANT … SO THAT and leaving out the acceptance criteria means you won’t know when a ticket is done. It’s not specific enough.
Collaborative specifications, or collaborative specification reviews (e.g. 3 Amigos) work around this. Stories have to have acceptance criteria in order to be testable and closeable.
Smell 4 – The product owner is a user
One of the most common smells. The product owner is a proxy for the user, but 9 times out of 10 they’re not the end user of the service.
The user in a user story has to be an end user of the system. They can be personas/types of user (e.g. admin, front line staff, loyal user etc). Product Owners, BAs, members of the dev team are not the end users.
Writing AS A product owner I WANT something SO THAT value isn’t a user story.
Smell 5 – Acceptance criteria must specify how features look & behave
Some developers like lots of detail. And that’s OK … but generally speaking acceptance criteria specify behaviour (i.e. what the system does in certain scenarios). They don’t need to specify how it looks.
There can be times when describing how a feature looks is useful – or even necessary. Generally attaching a visual or link to a component library is sufficient.
A picture is worth a thousand words.
Smell 6 – System-wide NFRs should be written as NFRs
NFRs are tricky. There are obviously NFRs that affect the end user e.g. system availability. They can be convincingly been written in the user story format.
One problem with writing system-wide NFRs as user stories (e.g. availability, system backups) is that they cut across the entire system. It’s difficult to test these NFRs until the entire system is built. I prefer to have system wide NFRs either as “definition of done criteria” which get tested against each ticket, or as items for regression testing at the end of a release.
Story -specific NFRs might be written as ACs against a ticket (e.g. audit log for a reduction decision).
Smell 7 – Specifying what the user wants is enough!
I’ve seen several people excluding the 3rd line of a user story. It’s the reason why the user wants something – the 3rd line helps us to understand why we’re doing the work.
The 3rd line of the user story (So that … ) can be driven from user research, or observations, or data analytics etc. Either way we need to understand the why before we start to solve the problem. At the minimum a story needs to include “So that”. This helps with prioritisation.
Smell 8 – User stories should be incredibly detailed
User stories should specify the appropriate level of information. There’s a tendency from BAs, and sometimes from the development team, to try to put all the information they have into a ticket.
Having a ticket that is too detailed adds little value. It makes it likely that people will scan over the ticket and miss the most important information. An incredibly detailed ticket is not necessarily better than a less detailed ticket – it’s about having the appropriate level of information.
As a story is worked on it might be that more detail emerges. But a story should contain enough information for the team to develop and test it.
Smell 9 – User stories can depend on other stories in the Sprint
Ideally user stories should meet the INVEST criteria. That means each story should be independent.
Unless it’s agreed at Sprint planning & made visible on the ticket – all user stories should be independent. There may be cases where two dependent stories are brought into the same Sprint – however the goal should be that stories do not depend on other stories.
Smell 10 – Stories should be very small
This is more for teams that are using Gherkin & TDD, however some teams aim to have very small user stories. Almost at the level of a handful of scenarios.
One advantage of smaller user stories is that we can track progress in a Sprint to a more granular level. But a note of caution – small user stories are essentially a grouping of scenarios. They can make the Sprint board less manageable and in themselves deliver very little value to a user. For very small stories it is difficult to make them to be independent and valuable.
The game
Here’s a link to a game we created. It lists the 10 smells + 10 example bad user stories. See if you can match them: https://docs.google.com/presentation/d/1MXP3IMv0s56_FemJ8f_srWdZXphKiUIFpfVT0bLG_aY/edit?usp=sharing
It’s a great team exercise – with either a product or a BA team. It helps reiterate some of the key points above. And makes examples tangible.
Any smells I’ve missed? Enjoy!
Agile Analyst 
I think there are some very pertinent points here, but looking at these points, “smell” can also be a good thing [like roses!].
A) User == End User of Application (Customer/Client). Things change significantly when “user” is “one who makes use of” (Consumer). If I write a class, then any other code/developer that calls the public api is a “user/consumer” of the code.
B) Independence. Really this is a myth. Look at any user story, now starting with ZERO deliver JUST that. Everything has context. Problems arise when things under concurrent development or within prioritization range of each other have significant coupling.
C) Small Stories. Yes there is a risk of this, but far more often teams are on the other side of the balance point.