Has anyone encountered someone who was poor at both verbal and written communication but turned out to be excellent at designing and writing maintainable code?
Maintainable code in this case would be a combination of using clear and easy to reason about logic, good names for everything, creating useful non-leaky abstractions, no major performance issues, thoughtful and extensive test cases, good documentation, etc..
Yes, It's not too uncommon to see devs producing good software, but struggling to communicate on a less-technical level, either with non-technical people or with technical people who aren't familiar with the specific subject/domain at hand
Yeah, actually it could be the case, where someone who is so deep into what they are doing, they don't understand how everyone else doesn't understand the intricacies and so they end up explaining and communicating in a way that others don't understand. Even though it is said that if you can't explain a concept to a child, you don't really understand it, but I think there still can be cases in which you are so deep in there, you have hard time grasping what is the best way to make it simple for others considering their understanding.
Especially if you have been working around other people who are deep there and now you are put into a group where people have completely different levels of understanding.
It's sometimes easy to assume that something is common knowledge when it really is not, because it seems so natural to yourself.
And obviously I have faced it the other way in different fields where I absolutely lack all the knowledge and they start to use terms I am clueless about, but I feel stupid about asking about each term because they talk in a way that it seems they think it's so obvious that I should know.
Solving a problem internally within your mind is a form of communication as well. This is also the reason why rubber duck debugging works. The solution is not revealed to you unless you are Ramanujan.
Maintainable code in this case would be a combination of using clear and easy to reason about logic, good names for everything, creating useful non-leaky abstractions, no major performance issues, thoughtful and extensive test cases, good documentation, etc..