I think it refers to Rust's ability to "indirectly" infer a type by it's later usage which can be somewhere entirely else in the function (for instance when it's used as return value), while Zig has a more direct type inference (but IMHO Rust's approach definitely isn't "obviously better", because sometimes one needs to read and understand the entire code of a function to get an idea what type a variable might be).
I understand what it is doing, but the fact that changing the return type of a method will change what previous code will compile to is something that I find extremely non obvious and surprising.
Inferring what the type is from the current code, sure. That saves me typing, but from what happens elsewhere looks like time travel.
I just always find it a PITA that Rust can't do global type inference and that I have to type most of the types for myself.
There's no coherent reason why it'd be OK for Rust to conclude that x is a u64 from
let x = some_u64.add(6); // the u64 type implement Add returning a u64
let x = someFunction(); // someFunction was defined to return u64
let x = str.parse()?;
someFunc(x);
With global type inference, the whole program is inferred for example.
let foo: T = bar.parse()?;
// or let foo = bar.parse::<u32>()?;
baz(foo);
In my experience I've never found this to be surprising behavior, or unclear.