But how do we do that step, "create story"?
For us, at least, sometimes the gap between the idea and the actual story that's ready for implementation can be months or longer. (We tend to have a lot of ideas.) So how do we handle all these proto-stories? How do we keep the ideas around? And how do we intelligently work them into stories, assuming they're important enough for that?
We've come up with a process for this, and I thought I'd share just in case anyone else is in the same boat.
A few caveats up front:
- We've been using this for a couple of years, and it works pretty well for us. Your own mileage may vary.
- This process looks shockingly complicated, but when I sit down to think about it, there's no step we always skip (and is therefore unnecessary).
- This process is contained pretty much outside implementation; it's really just something our "customer" (in our case, product management) uses.
- I'm pretty sure this is not strictly XP. Oh well.
So here's what we do:
- Create a story stub candidate
- Either accept it (story stub) or defer it (deferred) or delete it (not needed!)
- Work the story stubs to add details about what this thing will really do.
- Estimate the story stubs
- All agree that they're complete (make them stories!).
At some point, then, we have each of these things:
Story Stub Candidate
This is the idea. This is usually pretty general: "Hey, let's use bigger drives!" or "Wouldn't it be cool if the system could email you logs automatically when it was sick." Anyone can create a story stub candidate, and in practice they've come from all over - sales, development, product management, support, etc.
When an item is here, the "customer team" (an internal group proxying for real customers) reviews it, and one of three things happens:
- This feature exists, so we delete the idea that's not actually new.
- The feature isn't important now, so we defer it.
- The feature is useful now, so we make it a story stub.
Deferred Story Stubs
These are all the things we thought of that we decided weren't important (or at least not important right now). We go through them every once in a while to make sure they haven't changed in importance, but otherwise they're mostly there as records.
These are proto-stories. With enough work, and estimation, one day they can grow up to be real stories. Basically, story stubs are the ideas we've decided are interesting enough to report on. Each of them gets an owner who is responsible for fleshing out the details, defining acceptance criteria, and getting an estimate on the story.
When a story stub is fully fleshed out, it goes back to the "customer team". The team agrees it's ready and puts it in the product backlog, or else kicks it back to the owner for more information. At this point it becomes a full fledged XP-ish user story, and it goes into the dev cycle from there.
We keep these all in the wiki, and use categories to move stories through this process. Over time it grows to be a pretty big repository of the work we've done and the work we've chosen not to do.
How do you get from idea to story? (or whatever you call story)