In Go this is never an issue; you can declare an interface that captures the methods you're interested in, and the existing code automatically implements it. It's kind of like duck typing in python (e.g. this function will work on any object that has a method <x>), except it's statically typed.
static fulfilment != semantic fulfilment.
In practice, there is no language that can save you from people with malicious intent to confuse you.
In practice, this is rarely an issue.
When a developer makes a class implement an interface s/he signing a contract thus validating assumptions.
When a type in Go matches an interface, it happens by chance.
Whether or not the function/method's author typed the words "implements Foo" has absolutely no impact on this.
Reader - an interface for reading stuff Writer - an interface for writing stuff
Some things implement Reader and some things implement Writer. Some things implements both. Now you can declare ReadWriter as in
http://golang.org/pkg/io/#ReadWriter
and everything implementing both will automatically be a member of this newly formed interface. You don't have to go back and tag an "implements ReadWriter" on each of the things you want to implement it. The implementation is implicit if you obey both interfaces.
The power is that you can change your interface structure later on in another part of the program, and the existing code just picks it up. You may not even have the source code , or the right to change the source code, so you can't easily tag an 'implements ...' on top of it.