Outside of my professional life in Agile software development, I’ve always been a creative person with many interests, including art and painting, performance arts, and sewing.  When COVID-19 hit, visiting galleries and going to shows were activities no longer available to me, but, with time on my hands, an unexpected inheritance of a huge bag of yarn, and a full set of hooks, I decided to take up crotchet.

Over the past six months, I’ve made a lot of progress, moving from a beginner crocheter to a practitioner. In the beginning, my work was confined to practice squares, leading me to explore and learn individual stitches. Still, as a beginner, I ended up with strange gaps and uneven edges. As time went on, and with practice, I gained confidence, and I was able to scale up my implementations into more complex projects and move onto blankets. I hit a familiar roadblock with my blankets—I noticed that they were beginning to resemble my practice squares with weird patterns and lumpy edges. However, this roadblock gave me an understanding of my reoccurring mistakes. With lots of tearing and redoing of stitches, I was able to crochet a blanket that I was happy with.

As I work through my most recent blanket project—which is the most ambitious by far both in scale and number of different stitches required by the pattern—I’ve come to realize that the way I am working has changed. While learning to crochet, I’ve realized that this learning and executing process is similar to what I do in Agile software development; let me explain.

The end state of my blanket is expressed in two ways: a photograph of the final product, along with dimensions of how big the blanket will be. The overall pattern displays the sections of the blanket coherently. I liken this to an architecture and component design, with features like borders, pattern blocks, and transitions set out in a framework representing the final look and feel.

We know that with Agile software development, to execute and deliver a finished product, we must break the work into smaller bits that incrementally build on each other. In the case of my blanket pattern, I develop one row of the blanket at a time, and within that row, I work on different features, e.g. a border, a transition or a section. This process is similar to a user story—by successfully executing each story feature of the blanket, the component design and architecture are ultimately realized.

As I progress on the build of my blanket, I begin to notice how quality metrics and unit testing have come to guide my work. My unit test metrics are tests that I apply against the overall pattern for the project. If I end up with the same number of stitches in a row, and if my stitches match the detailed instructions, without variation, I know I can safely move onto the next row. These unit tests help catch mistakes early and allow me to go back to my row and make small edits before continuing. As a beginner, I didn’t understand or appreciate the value of these unit tests and would blindly carry on. Eventually, I’d realize that a mistake that I made multiple rows ago is now preventing me from moving forward.

The final key component to this build is communicating with the Product Owner, the person I am making the blanket for. In Agile development, we closely collaborate with our Product Owner on progress and frequently demonstrate working software. Where features deviate, we have conversations about corrective actions or next steps. In my case, I regularly send pictures of the build so that my Product Owner can see how their blanket is progressing and give me feedback. In cases where there are small deviations from the pattern, I can ask the Product Owner if those are acceptable.

The realization that Agile development practices we routinely use to deliver software successfully are analogous to my crotchet projects was initially surprising.  Agile software development and delivery is about having an initial high-level design, which is then broken into smaller iterative and incremental pieces that are frequently inspected. Fast feedback throughout the process helps us understand progress, validates the work and shows us when we are going off track so that we can quickly address problems.

On reflection, and with a little bit of imagination, many of these same principles and practices for good software development can be applied to all kinds of domains and projects to guide us to a quality outcome. Similar to how software craftspeople use Agile practices, I’m applying my experience and knowledge of Agile software development to my crocheting, all the while improving my level of proficiency in my craft.