We rarely document. We are used to being handed a set of PowerPoint slides that describe, on a very high level, the business need for software. We roll our eyes at the slides, and get to work, asking questions, clarifying the needs, hope to understand them and start imagining features and how we can deliver the implementation within the requested timeline.
If we follow the Agile framework, we'll translate the transformed slides into stories. We do so and derive tasks from them. If we're lucky, we might be able to condition the business to accept deliverable milestones that are aligned with those stories.
Using BDD, we'll transcribe the stories into Gherkin and using TDD, we'll start coding tests at that time (rSpec, Cucumber).
As development gets under way, we cycle through iterations and we deliver collaboratively.
After the celebrations, all the good things mentioned above (stories, milestones, BDD, TDD) evaporate as the project starts gliding at low altitude as the business moves to new territories. We're left with mundane maintenance and tickets are opened for small bug fixes and minor enhancements. Stories are no longer written as "it's not worth it" and small changes are never fully documented.
The project stops being documented and over time, as the team members rotate and business rules change, people no longer remember why we check-off the 'accept contract' terms after signup and not on the page where the user enters their email address. It so happens that there will be a major impact on the back-end provisioning system if we change that.
I think the pattern is clear - If we don't use our documents, the whole eco-system of our product degrades to entropy and will ultimately lead us to revival by rewrite, or at least by going through the analysis again and likely to some re-engineering. Time wasted.
What I would love to see is a system whereby the development and maintenance is driven by documentation and that the documentation drives the deliverables.
The pieces are there, we just need to use them:
Participate in the requirements phases, translate them to stories, deliver story implementions. Always, recurringly. Never stopping this cycle.
Months from now, anyone reading your stories will fully understand why the system behaves the way it does - people like to read stories and will understand the system on their own terms. New hires in the business will use them as a guidline on how to perform their jobs. New developers to the team will have a standard to meet when fixing bugs or evaulating new or changed requirements.
We will end up with a document-driven system, accumulating a library of living documents that drove our software development effort. Any new contradictory story will violate the automated validations for previous generations of stories and will stop us in our tracks, showing us exactly where the business flow will break if we add that new feature. No one actually needs to know this in advance: Let the business tell new stories and see how the system reacts. It'll tell us whether we're in violation of any existing processes and alert us automatically.
If you're using Gherkin and Cucumber already, put them front and center of your development workflow and don't let go of them!