Software development is a highly creative human endeavor that requires a concentrated mix of talents: efficient design, organization, architectural strategy, coordination with key business needs, and a deep attention to detail. It’s hard. Almost anyone can sling code if they take a few online classes. But few people can develop stable, extensible software.
Many of the human skills in software development are difficult to acquire and to quantify. Some come with experience, but still only when complemented by skill. There seems to be a natural talent that cannot be taught: many recruiters still look for the mythical “10x” developer who is ten times as productive or effective as others. From these sorts of mysteries and unquantifiable factors come a great deal of “philosophy” and legend about what goes into making great software.
It’s no surprise, therefore, that there is skepticism and even apprehension around the idea of automating any part of a developer’s job. Can machines really replicate any of what great developers do? And should we even try?
What should we automate?
What’s the difference between sculpting marble and breaking rocks?
The difference is in the engagement of the mind. The tools are the same. The medium is the same. How the mind engages with the task is what matters. While both use steel to change the shape of stone, one is drudgery and the other is creative and delightful. Breaking rocks all day burns people out. Sculpting sets the soul on fire.
David Liedle and I were discussing automation the other day and I realized that this is a great analogy for what we should automate. Robots can break rocks. We don’t need humans to break rocks. We do need humans to sculpt.
Are there parts of the software development process that are more like breaking rocks than sculpting? Of course. Would we ask a sculptor to chisel their own rock out of the earth and carry it to their workshop? No: it is a terrible use of their time and does not take advantage of their unique talents.
For software development, we should automate the parts of the process that do not engage the creativity, the strategy, the cleverness, and the organizational strength of a great developer. We should automate the drudging parts that burn people out.
What can we automate?
Perhaps not surprisingly, the tasks we should automate and the tasks we can automate have significant overlap by their very nature. The kinds of tasks that lack the special, human parts that are so hard to quantify are the very ones that are easiest to break into parts and automate in turn.
Right now, and for the foreseeable future, we automate tasks that can be defined and repeated, either deterministically or probabilistically (the latter being what we think of as “AI”). In human history, the tasks which have been automated have been those wherein the human mind is no longer creatively engaged. We have automated picking crops, forming boxes, stacking shelves. We are beginning to automate repetitive tasks on applications using Robotic Process Automation. QA engineers automate the task of manually clicking through an application repeatedly. All of these free up the human mind from drudgery so it can turn its focus towards more beautiful work.
We have seen it in other parts of the software development process: performance analysts used to repeatedly probe applications for performance issues; now Application Performance Management runs on its own when set up. Software deployments used to be heavily-managed events; now they can be done with a click of a button. All of these tasks are not what makes software engineering interesting or valuable to the human mind.
This holds true for the current wave of automation: the jobs being automated are those which have been so proceduralized by management process already that they no longer set the human soul alight. And there’s much more of the software development process that can yet be automated away from human burden.
At ProdPerfect, we seek to combat the drudgery of sitting in a room guessing what’s important to test, and repeatedly re-writing and re-tooling the same end-to-end automation tests. We’re here to fight burnout, to help software teams deal with less BS from broken code and from having to test it, so they can go build the things that help other people avoid burnout, and thrive.
As with every wave of automation, there’s some discomfort and incredulity that anything but an experienced, well-trained human can do the trick. In ten years, we won’t be able to imagine doing it any other way.