Developer "D" is paid to create software; he must get code in production to get good reviews and keep his job.
Operator "O" is paid to keep the production stable; he must keep unfit code out of production to get good reviews and keep his job.
These two roles work well with conflicts; D quickly creates code, O says "no go", D improves code, O accepts code. D gets a bad review but the company is okay.
When combined in a single person D+O quickly creates code, knows he should say "no go" but als knows he'll get bad reviews if he does. D+O knows it might go wrong, but decides a risk of a bad review is better than an absolute certainty. D+O may make a few minor tweaks to the code that still fit within the deadline but after that it's released.
The trouble is that individually, both the developer and the operator can make good choices from their own perspective. Working together, they're able to make the choice that's best for the company. As a combined role, the DevOp cannot make any good choices because there are no choices that fit both of his perspectives at once. Instead, the DevOp will choose at random at best.
Obviously, the world isn't that binary, but these situations do happen.
FWIW, I have a DevOp role in real life. I'll be very glad to get rid of one of the roles as soon as we can hire additional personel because I'm damn well aware that I have to make these bad choices. As a developer I'm the worst judge of my own code, yet as an operator I'm the only judge standing between the production environment. If you think you're a good judge of your own code, you are in fact much, much worse.