I really like the OP's structure and makefile, but it looks like a pain to work against Golang's grain here, even though the methodology makes a lot more sense to me.

Maybe I have misunderstood the documentation, but what I truly, truly don't get about Go's $GOPATH is that it wants (1) my project directory to have some kind of canonical path, and (2) to pollute my project directory with dependencies. I have done a bunch of Go development and I still don't get it.

So for example, I have myproject, which I naturally want to organize in this way:

    $HOME
      Projects
        foo
          .git
          src
            main.go
            stuff.go
          assets
            photo.png
            something.xml
          scripts
            setup_database.sh
          config
            config.sample.json
          Dockerfile
          Makefile

Go wants me to throw this away and structure it like this:

    $HOME
      go
        bin
          [...]
        src
          github.com
            BurntSushi
              toml
                [...]
            zenazn
              goji
                [...]
            myaccount
              myproject
                .git
                main.go
                stuff.go
                assets
                  photo.png
                  something.xml
                scripts
                  setup_database.sh
                config
                  config.sample.json
                Dockerfile
                Makefile

I'm supposed to work within this jungle of dependencies and generated files, in the middle of which sits my project. At least Java, for all its many faults, has the good sense to let you store dependencies nested as JAR files in a subfolder, as opposed to turning your own project into a dependency.

I have tried fixing this by symlinking my project into $GOPATH/src/whatever, but Go doesn't let me to run "go" commands on things outside the $GOPATH, which makes this rather painful to do in a shell.

Adding to the general confusion, Go doesn't manage canonical package paths, so github.com/zenazn/goji/main.go is in the package "goji" and github.com/zenazn/goji/graceful/[asterisk].go are in the package "graceful", but those package names only mean something to the importer. When "goji" wants to use the package "graceful", it imports "github.com/zenazn/goji/graceful", which, being a full URL, must be resolved from a root folder in GOPATH/src.

At least Java (for all its... etc.) had the good sense to make dotted package names mirror the folder structure of a project, not URL, thus being internally consistent. Go wants everything to live in the same sea of things. Vendoring is just half the problem.