Yes. The interface holds the concrete type of the value, if there is no concrete type it will be nil, so if you assign a nil to an interface-typed variable directly, you'll have a (nil, nil). If you first assign the nil to a pointer type T then assign/convert that to an interface type, you'll get (* T, nil). Here's a trivial demo:

    var a interface{} = nil // (nil, nil)
    var b *int = nil
    var c interface{} = b // (*int, nil)
    fmt.Println(a == c)

Of course most such cases are not that trivial, rather they're cases where a function takes an interface-valued parameter and checks for (param == nil), if the caller passes in an actual object there's no problem, if they pass in a concrete value no problem, but if they extract the nil literal to a concretely-typed context (variable) things go pear-shaped to various levels of fuckedness (depending what is done in the other branch).

And that's vicious because something as seemingly innocuous as "extract variable" on an immutable literal can break your code.

Yes it is. An interface is basically a struct of the concrete type and the value. While the outer interface value still has a type, if no value was assigned to it, the concrete type field is still nil.

That, in fact, is the normal case which is why people are surprised by typed nils.

For example:

    func returnsNil() error { return nil }

    x := returnsNil()
    // x is of type nil and value nil.