I agree. Despite what we want to believe, it's not as if the act of coding is in itself a skill that requires 5 years to learn. Especially considering that a large majority of code is not necessarily going into Google, but into some enterprise software where bubble sort is fine, and they're running on such fast machines anyways that it doesn't need to be using bit twiddling tricks to win a handful of cycles per second.
I think what we need to move more towards is getting CS people out of coding and into becoming software architects. Most software can be easily divided into (relatively) simple chunks, and if you have enough skills put into actually building software, instead of writing code (which is probably the least important part of the process), then the divisions become trivial.
We'll always need the super-skilled programmer to work on the single blocking function that eats up 90% of CPU time, and requries intricate knowledge of all the subsystems involved. But most of the time the code itself is just a translation of pretty simple ideas. Anyone with enough time and motivation can absorb the knowledge necessary to work on them. Think of all the Excel spreadsheets in the world, and how many people who would never say they are programmers actually build complex systems in them, because programming in itself isn't hard. What's hard is building something that is clear and maintanable.
CS grads, who do have (if superficial) knowledge of many different systems, have the knowledge to do the very sort of big picture design that is necessary to building maintanable software. We need to get these guys out of the workshop and into the design bureaus, because they are the ones with the knowledge necessary to become the architects of software. Much like how architects don't build houses, software architects shouldn't be relegated to writing code.
A well-designed system might have many small parts that can be hard to maintain, since it might've been written badly. But if the system is well-designed, the intent of the code will have been set on the outset, so you could rewrite it. And if it's small, a person with enough courage and time could decipher it. But the inverse situation is a true nightmare. A single "genius" programmer might by himself write the most amazing subroutines the world has ever seen, but if the general structure is incomprehensible, then the program will be maintanable.
Let's get CS grads out of coding, and into places where they're really needed.