Like many things in life, it depends. I quite like type inference when it's clear from context what the type will be, e.g.: var xs = new List<Int>(); for

Like many things in life, it depends. I quite like type inference when it's clear from context what the type will be, e.g.: var xs = new List<Int>(); for (var x in xs) { ... } I'm pretty happy for it when the type "doesn't matter" because you don't do anything with the value except pass it elsewhere. // Presumably refactored from processSomething(x, y, z, getSomething()) because the line got too long. var something = getSomething(); processSomething(x, y, z, something); And sometimes the type can be sufficiently unwieldy to name, most famously in C++ taking advantage of templates, but also can show up in other languages such as Haskell that encourage this behavior. Finally there's this comment: > A weaker argument I have heard is that you have less code to type with type inference! I'd say that I agree with it as stated, but I'd hope the people making that argument are actually trying to say "it's less code to read/be distracted by". IMO omitting the "less important" type information draws the reader's attention to the ones you did write, which are presumably the more interesting parts of the code. Having said all that, I think my brain is a bit quirky because even in languages like Python I automatically/internally infer all the types based on the names of variables and roughly how/where they're used as I read through. Maybe it's an experience thing (or maybe I don't work with bad/differently-thinking developers), but I find that my first or second guess is right 99% of the time.