Funny enough I feel the other way about JetBrains IDEs. They * seem * super powerful, but there is always a lot of config that needs to go into them if I'm doing app, infra, and pipeline work. (Edit, not saying they aren't powerful, just more that as coming into them I'm never sure how to wield it the best out of the box)

In my experience (not saying this is universal), the folks that like JetBrains IDEs came from java/intellij backgrounds, where I hear it really shines.

This all might be a skill issue, as almost all my professional projects have been VSCode based, but since I've only worked at smaller places I definitely can't rule out this was because it was easier to set things up than to fight for Fin to get us all licences.

In your opinion, what makes PyCharm (or CLion if you want to add that in) 'just work'? Do you think it is because you've used it for so long and just know the ins-and-outs? Or is there something you see that they have and VSCode doesn't?

I've always been curious about this as someone who hasn't had a lot of professional exposure to the JetBrains world.

The things that just work that I look for are mouseover to get info on an identifier (local or external), right click to go to the definition, and running code in the debugger with a click. Maybe I just don’t know how to set that up in vscode; I’m a company of one and don’t have a coworker to ask how to do it. My Python work was just making requests, analyzing the data and outputting results to csv’s. This was replaced by Rust and then C. And the C is 60k loc as it does much more. In Clion when you open a cmake project it automatically understands your project structure from the cmake files and provides those need-to-have features I listed.

"Just work" is certainly subjective, but the introspection in all the JetBrains products are what make them ferocious. If one has never heard of all the 18 quadrillion lint tools before, you can immediately get value from opening a file in PyCharm and having it point out the ways it is going to fail on you, including one of my favorite tricks that no VSCode+lint horseshit has ever thought about trying:

  import re
  import sys
  if re.match(r"[A-Za-z}", sys.stdin):
      print("ok")

PyCharm will spot that error immediately, no insaneo configuration required

PyCharm Professional also gets into the SQL side of things:

    with connect(":memory:") as conn:
        c = conn.cursor()
        c.execute("SELECT * FROM oops WHERE NAME IN ('alpha, 'beta')")

instantly spotted, no configuration required

I was going to be cute and use json.loads as an example, but it seems somewhere along the way they botched the fact that the first argument to json.loads is a fucking JSON string. But, it does allow showcasing that you can have PyCharm syntax check the "inner" language of any string literal you'd like via their language injection annotations:

  import json

  # language=json
  bogus = """{"this is subtly wrong"; true}"""

  json.loads(bogus)

  # and the same with tomllib:

  import tomllib
  # language=toml
  bogus = """
  [alpha]
  beta = []onoz
  """
  tomllib.loads(bogus)

  # or, if you have some tricky internal stuff

  def do_the_thing(
    # language=sql
    s: str
  ):
      with connect(something) as conn:
          c = conn.cursor()
          c.execute(s)

  do_the_thing("SELECT * FROM oops WHERE NAME IN ('alpha, 'beta')")
  #            ^^^ also gets syntax checked because it knows the first arg is SQL

Jet brains was so slow on my machines that I got to experience the speed of a physical teletype, decades after they went out of fashion.