Further note that plenty of supporters of using goto liberally were happy to talk about how goto fit their psychology. They are wrong
I have never seen an objective comparision/study of goto fans versus block fans WRT productivity. If you know of one, please let me see it. Otherwise, you are only speculating.
I suspect their development was just as fast as blockers, but not as fast when reading other's code. This is because there were no accepted lists of "goto patterns" ever developed. Each experienced goto'er developed their own patterns with no known effort to consolidate them. (More on patterns later.)
Plus, they were never able to explain their philosophy in detail, something they have *in common* with OO'ers. Block statements are generally considered more *consistent* from programmer-to-programmer, and nesting of blocks provides visual cues to the nature of the flow that goto's have no identifiable counter-part. I have never heard/read a goto fan claim there is a clear visual component to goto's. (I suppose you could draw lines with pens, but that is an extra step.) Then again, I have not seen many attempts to document the thinking process of goto fans.
What parallels should be drawn to the subject of OO programming is left to the imagination of the reader.
That OO is basically navigational databases of the 60's resurrected as Dawn of the Dead zombies with a new name, and that navigational is the Goto of structuring because it lacks the consistency of relational, and thus parellels the consistency problem that goto's had (see above).
Almost every OO fan's design is significantly different than another's. The Design Pattern movement is an attempt to remedy this, but is as futile as an attempt to form Goto patterns. Second, as the same information has to be involved in multiple patterns, you still end up with a mess. The best solution is a relational database, not yet more overlapped goofy code patterns.
Relational is like code blocks and OO is like goto's: Spehgetti pointers. Goto's are just a big messy graph of flow, and OO is a big messy graph of relationship pointers.