Some people have alleged that Visual BASIC is inferior to Visual C because it's buggier.
I think far more often the issues is not that it's buggier, but that it's specifically designed for simplicity at the expense of flexibility (and performance). There are good reasons why literally no systems code in existence is written in any BASIC dialect.
(Also, "Visual C" is not a thing that exists. I assume you meant Visual C++, which is a development environment, not a language.)
Personally I find BASIC, visual or not, many times easier to deal with than C. For one thing, object overloading becomes confusing, makes many C++ programs languages unto themselves.
C and C++ are two different languages.
For another: MAKE. Don't get me started there. I think MAKE turns people off from C++ more than anything else... many people refuse to try to learn it because they know that they have to deal with MAKE.
Using make is by no means mandatory for C/C++ programming. And if you're using Visual C++ or another similar toolchain as mentioned above, it's probably not even going to be part of the equation. The whole reason IDEs exist is to simplify the development process.
Finally, the interpretation burden. I have no difficulty making sense of well-written BASIC. C/++/# on the other hand, even when well written, requires deep concentration to make sense of.
I think this depends primarily on how familiar you are with C and its descendants. While C certainly does have more of a learning curve than any given BASIC dialect, there are so many languages that inherit its syntax that a basic understanding is considered a pretty fundamental skill for most programmers to have.
C also seems to promote shorthand variable names which make code less self-documenting.
No more than any other language does. What's stopping anybody from writing "let a = 5" in BASIC?
That attitude is incomprehensible to me, for several reasons. While it may be true that people who prefer BASIC have less talent as programmers than people who prefer C, there is nonetheless a much larger pool of them, and they tend to be more enthusiastic.
There is basically no correlation whatsoever between enthusiasm and ability. A reasonably skilled programmer (i.e. a non-beginner) can usually pick up the fundamentals of a new programming language more or less over a weekend.
While modern BASIC dialects may be good for a first language, I would absolutely not recommend it to anyone for any kind of long-term production purposes. It's specifically designed to be a simple language for simple tasks; trying to write something as complex as an emulator or debugger in any flavor of BASIC is going to get hairy and cumbersome fast.
Additionally, BASIC, with its GOSUBs and GOTOs, is actually more like ASM than C is (at least on the surface), so it's not a huge learning curve for someone who is familiar with QB64 to start working in Z80 or 6502. In summary: the community is likely to grow if we push BASIC as the language for developing debugging tools.
GOSUB is functionally equivalent to a simple function call in nearly any other language, and GOTO is something that also exists in C, with identical functionality (and is also a really bad thing to encourage people to use except when they absolutely know what they're doing).
Aside from those two things, there is basically no meaningful resemblance between any BASIC dialect and any assembly language - and if there was, why would you encourage people to use it as their primary language? The whole reason people use high(er) level languages is because they are ideally as far from assembly programming as possible.
(Meanwhile, C is basically as low-level as it gets when it comes to non-assembly programming languages, to the point where most compilers support inserting assembly code directly into C programs.)