In the IT business, somehow the perception exists that part of the software development process can be carried out without any form of intelligence. This part is also known under the names of plain coding, plumbing, code monkey food, and many other names.

Somehow, the idea has arisen that writing source code based on a list of requirements is so easy that less qualified people are able to do so perfectly. And I wonder: is it possible to define a specification, which is so detailed, that a programmer with limited skills can implement it? And, if so, is it worth it?

I think there are two ends in the spectrum of software design specifications: on one end we have the vague specification which just defines a few guidelines on how to write the source code. This usually takes the form of a global design defining the main modules, coding standards, which development platform is used, which libraries are used and such.

On the other end, we have a very strict and formal specification that defines everything into such detail that a so called code monkey should be able to understand it and implement it uniformly. In this case, there is no room for the programmer to make decisions of his or her own. The specification provides all design decisions.

I think that, with the first type of design, we can all agree that the developer who implements it will have to make design decisions because they are not all provided in the specification. And thus, a code monkey will not have the skills needed to implement such software, for he or she is only able to do plain coding. The set of design decisions in this case could be called implementation design. All the details lacking from the global design are defined in this development phase.

So, the only designs that code monkeys should be able to understand and implement in a single, straightforward way are the formal ones that go into great detail.

Now, we could ask ourselves: "Is it possible to define a specification to such detail that any code monkey would be capable of building the software as requested?"

And if so, wouldn't it also be possible to build a compiler that translates this specification into the requested piece of software, has no room for its own design decisions and is therefore deterministic?

Well, I think not. If you write such a specification, you've essentially already built the software. No more work is then required by a human, for it is so formal that the translation to machine language could be automated.

You could of course argue that code monkeys do have added value above a compiler, since they do more than just compiling the specifications into source code; specifications, however detailed, are not that formal and deterministic. There are always a few decisions left to be made, if only small ones.

But from a management view, it seems like the whole idea about code monkeys is that they are less skilled people doing a job where almost no risk to the project's delivery is involved.

However, if we decide that it is impossible to write a compiler to automate the code monkey's job, and we also decide that the code monkey's influence on the quality of the end product should be very small (because their work should pose little risk to the project), what range of decisions can we allow them to make?

The management's assumption is that they will make errors, but because all the thinking is already done, the code monkey's own contributions represent a negligible impact on the quality of the end product.

This sounds paradoxical to me.

If this were true, we could still build a compiler that implements an application based on the formal definitions of the design. And for the small gaps, which normally the code monkey would have filled in, we let the compiler do something random. It wouldn't matter, because the influence on the end product would be very small, as we concluded above.

I don't think there are specifications that are completely trivial to implement and therefore I don't think anyone can build good software without being able to make an (implementation) design and truly understanding what the system is all about. Even when your job is to build a small module, which is part of a huge system, you will still have to make your own design decisions to tackle the problems encountered in writing that module. Those problems a compiler can't fix for you, for if it could, why are we still paying people to do a machine's job?