diff --git a/alldocs.go b/alldocs.go
index f6727ea..149a698 100644
--- a/alldocs.go
+++ b/alldocs.go
@@ -25,6 +25,11 @@
 
 fetch vendors an upstream import path.
 
+Recursive dependencies are fetched (at their master/tip/HEAD revision), unless they
+or their parent package are already present.
+
+If a subpackage of a dependency being fetched is already present, it will be deleted.
+
 The import path may include a url scheme. This may be useful when fetching dependencies
 from private repositories that cannot be probed.
 
diff --git a/delete.go b/delete.go
index 899a993..5f97f93 100644
--- a/delete.go
+++ b/delete.go
@@ -36,7 +36,7 @@
 			return fmt.Errorf("delete: you cannot specify path and --all flag at once")
 		}
 
-		m, err := vendor.ReadManifest(manifestFile())
+		m, err := vendor.ReadManifest(manifestFile)
 		if err != nil {
 			return fmt.Errorf("could not load manifest: %v", err)
 		}
@@ -65,12 +65,12 @@
 				return fmt.Errorf("dependency could not be deleted: %v", err)
 			}
 
-			if err := fileutils.RemoveAll(filepath.Join(vendorDir(), filepath.FromSlash(path))); err != nil {
+			if err := fileutils.RemoveAll(filepath.Join(vendorDir, filepath.FromSlash(path))); err != nil {
 				// TODO(dfc) need to apply vendor.cleanpath here to remove indermediate directories.
 				return fmt.Errorf("dependency could not be deleted: %v", err)
 			}
 		}
-		return vendor.WriteManifest(manifestFile(), m)
+		return vendor.WriteManifest(manifestFile, m)
 	},
 	AddFlags: addDeleteFlags,
 }
diff --git a/fetch.go b/fetch.go
index 89547a8..cb9814c 100644
--- a/fetch.go
+++ b/fetch.go
@@ -3,12 +3,11 @@
 import (
 	"flag"
 	"fmt"
-	"go/build"
 	"log"
 	"net/url"
+	"os"
 	"path/filepath"
-	"runtime"
-	"sort"
+	"strings"
 
 	"github.com/FiloSottile/gvt/fileutils"
 	"github.com/FiloSottile/gvt/gbvendor"
@@ -22,8 +21,6 @@
 	insecure  bool // Allow the use of insecure protocols
 	tests     bool
 	all       bool
-
-	recurse bool // should we fetch recursively
 )
 
 func addFetchFlags(fs *flag.FlagSet) {
@@ -42,8 +39,10 @@
 	Short:     "fetch a remote dependency",
 	Long: `fetch vendors an upstream import path.
 
-Recursive dependencies are fetched at their master/tip/HEAD revision, unless they
-or their parent package is already present.
+Recursive dependencies are fetched (at their master/tip/HEAD revision), unless they
+or their parent package are already present.
+
+If a subpackage of a dependency being fetched is already present, it will be deleted.
 
 The import path may include a url scheme. This may be useful when fetching dependencies
 from private repositories that cannot be probed.
@@ -73,8 +72,7 @@
 			return fmt.Errorf("fetch: import path missing")
 		case 1:
 			path := args[0]
-			recurse = !noRecurse
-			return fetch(path, recurse)
+			return fetch(path)
 		default:
 			return fmt.Errorf("more than one import path supplied")
 		}
@@ -82,31 +80,102 @@
 	AddFlags: addFetchFlags,
 }
 
-func fetch(path string, recurse bool) error {
-	m, err := vendor.ReadManifest(manifestFile())
+var (
+	fetchRoot    string   // where the current session started
+	fetchedToday []string // packages fetched during this session
+)
+
+func fetch(path string) error {
+	m, err := vendor.ReadManifest(manifestFile)
 	if err != nil {
 		return fmt.Errorf("could not load manifest: %v", err)
 	}
 
-	repo, extra, err := vendor.DeduceRemoteRepo(path, insecure)
-	if err != nil {
-		return err
+	fetchRoot = stripscheme(path)
+	return fetchRecursive(m, path, 0)
+}
+
+func fetchRecursive(m *vendor.Manifest, fullPath string, level int) error {
+	path := stripscheme(fullPath)
+
+	// Don't even bother the user about skipping packages we just fetched
+	for _, p := range fetchedToday {
+		if contains(p, path) {
+			return nil
+		}
 	}
 
-	// strip of any scheme portion from the path, it is already
-	// encoded in the repo.
-	path = stripscheme(path)
-
+	// First, check if this or a parent is already vendored
 	if m.HasImportpath(path) {
-		return fmt.Errorf("%s is already vendored", path)
+		if level == 0 {
+			return fmt.Errorf("%s or a parent of it is already vendored", path)
+		} else {
+			// TODO: print a different message for packages fetched during this session
+			logIndent(level, "Skipping (existing):", path)
+			return nil
+		}
 	}
 
-	wc, err := GlobalDownloader.Get(repo, branch, tag, revision)
+	// Next, check if we are trying to vendor from the same repository we are in
+	if importPath != "" && contains(importPath, path) {
+		if level == 0 {
+			return fmt.Errorf("refusing to vendor a subpackage of \".\"")
+		} else {
+			logIndent(level, "Skipping (subpackage of \".\"):", path)
+			return nil
+		}
+	}
 
+	if level == 0 {
+		log.Println("Fetching:", path)
+	} else {
+		logIndent(level, "Fetching recursive dependency:", path)
+	}
+
+	// Finally, check if we already vendored a subpackage and remove it
+	parentOfRoot := false
+	for _, subp := range m.GetSubpackages(path) {
+		if contains(subp.Importpath, fetchRoot) {
+			// Through dependencies we ended up fetching a parent of the starting package
+			parentOfRoot = true // use the requested tag/branch/revision
+		} else {
+			ignore := false
+			for _, d := range fetchedToday {
+				if contains(d, subp.Importpath) {
+					ignore = true // No need to warn the user if we just downloaded it
+				}
+			}
+			if !ignore {
+				logIndent(level, "Deleting existing subpackage to prevent overlap:", subp.Importpath)
+			}
+		}
+		if err := m.RemoveDependency(subp); err != nil {
+			return fmt.Errorf("failed to remove subpackage: %v", err)
+		}
+	}
+	if err := fileutils.RemoveAll(filepath.Join(vendorDir, path)); err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("failed to remove existing folder: %v", err)
+	}
+
+	// Find and download the repository
+
+	repo, extra, err := vendor.DeduceRemoteRepo(fullPath, insecure)
 	if err != nil {
 		return err
 	}
 
+	var wc vendor.WorkingCopy
+	if level == 0 || parentOfRoot {
+		wc, err = GlobalDownloader.Get(repo, branch, tag, revision)
+	} else {
+		wc, err = GlobalDownloader.Get(repo, "", "", "")
+	}
+	if err != nil {
+		return err
+	}
+
+	// Add the dependency to the manifest
+
 	rev, err := wc.Revision()
 	if err != nil {
 		return err
@@ -132,7 +201,9 @@
 		return err
 	}
 
-	dst := filepath.Join(vendorDir(), dep.Importpath)
+	// Copy the code to the vendor folder
+
+	dst := filepath.Join(vendorDir, dep.Importpath)
 	src := filepath.Join(wc.Dir(), dep.Path)
 
 	if err := fileutils.Copypath(dst, src, !dep.NoTests, dep.AllFiles); err != nil {
@@ -143,59 +214,36 @@
 		return err
 	}
 
-	if err := vendor.WriteManifest(manifestFile(), m); err != nil {
+	if err := vendor.WriteManifest(manifestFile, m); err != nil {
 		return err
 	}
 
-	if !recurse {
-		return nil
-	}
+	// Recurse
 
-	// if we are recursing, overwrite branch, tag and revision
-	// values so recursive fetching checks out from HEAD.
-	branch = ""
-	tag = ""
-	revision = ""
+	fetchedToday = append(fetchedToday, path)
 
-	for done := false; !done; {
-
-		paths := []struct {
-			Root, Prefix string
-		}{
-			{filepath.Join(runtime.GOROOT(), "src"), ""},
+	if !noRecurse {
+		// Look for dependencies in src, not going past wc.Dir() when looking for /vendor/,
+		// knowing that wc.Dir() corresponds to rootRepoPath
+		if !strings.HasSuffix(dep.Importpath, dep.Path) {
+			return fmt.Errorf("unable to derive the root repo import path")
 		}
-		m, err := vendor.ReadManifest(manifestFile())
+		rootRepoPath := strings.TrimRight(strings.TrimSuffix(dep.Importpath, dep.Path), "/")
+		deps, err := vendor.ParseImports(src, wc.Dir(), rootRepoPath)
 		if err != nil {
-			return err
-		}
-		for _, d := range m.Dependencies {
-			paths = append(paths, struct{ Root, Prefix string }{filepath.Join(vendorDir(), filepath.FromSlash(d.Importpath)), filepath.FromSlash(d.Importpath)})
+			return fmt.Errorf("failed to parse imports: %s", err)
 		}
 
-		dsm, err := vendor.LoadPaths(paths...)
-		if err != nil {
-			return err
-		}
-
-		is, ok := dsm[filepath.Join(vendorDir(), path)]
-		if !ok {
-			return fmt.Errorf("unable to locate depset for %q", path)
-		}
-
-		missing := findMissing(pkgs(is.Pkgs), dsm)
-		switch len(missing) {
-		case 0:
-			done = true
-		default:
-
-			// sort keys in ascending order, so the shortest missing import path
-			// with be fetched first.
-			keys := keys(missing)
-			sort.Strings(keys)
-			pkg := keys[0]
-			log.Printf("fetching recursive dependency %s", pkg)
-			if err := fetch(pkg, false); err != nil {
-				return err
+		for d := range deps {
+			if strings.Index(d, ".") == -1 { // TODO: replace this silly heuristic
+				continue
+			}
+			if err := fetchRecursive(m, d, level+1); err != nil {
+				if strings.HasPrefix(err.Error(), "error fetching") { // I know, ok?
+					return err
+				} else {
+					return fmt.Errorf("error fetching %s: %s", d, err)
+				}
 			}
 		}
 	}
@@ -203,88 +251,10 @@
 	return nil
 }
 
-func keys(m map[string]bool) []string {
-	var s []string
-	for k := range m {
-		s = append(s, k)
-	}
-	return s
-}
-
-func pkgs(m map[string]*vendor.Pkg) []*vendor.Pkg {
-	var p []*vendor.Pkg
-	for _, v := range m {
-		p = append(p, v)
-	}
-	return p
-}
-
-func findMissing(pkgs []*vendor.Pkg, dsm map[string]*vendor.Depset) map[string]bool {
-	missing := make(map[string]bool)
-	imports := make(map[string]*vendor.Pkg)
-	for _, s := range dsm {
-		for _, p := range s.Pkgs {
-			imports[p.ImportPath] = p
-		}
-	}
-
-	// make fake C package for cgo
-	imports["C"] = &vendor.Pkg{
-		Depset: nil, // probably a bad idea
-		Package: &build.Package{
-			Name: "C",
-		},
-	}
-	stk := make(map[string]bool)
-	push := func(v string) {
-		if stk[v] {
-			panic(fmt.Sprintln("import loop:", v, stk))
-		}
-		stk[v] = true
-	}
-	pop := func(v string) {
-		if !stk[v] {
-			panic(fmt.Sprintln("impossible pop:", v, stk))
-		}
-		delete(stk, v)
-	}
-
-	// checked records import paths who's dependencies are all present
-	checked := make(map[string]bool)
-
-	var fn func(string)
-	fn = func(importpath string) {
-		p, ok := imports[importpath]
-		if !ok {
-			missing[importpath] = true
-			return
-		}
-
-		// have we already walked this arm, if so, skip it
-		if checked[importpath] {
-			return
-		}
-
-		sz := len(missing)
-		push(importpath)
-		for _, i := range p.Imports {
-			if i == importpath {
-				continue
-			}
-			fn(i)
-		}
-
-		// if the size of the missing map has not changed
-		// this entire subtree is complete, mark it as such
-		if len(missing) == sz {
-			checked[importpath] = true
-		}
-		pop(importpath)
-	}
-	for _, pkg := range pkgs {
-		fn(pkg.ImportPath)
-	}
-	return missing
+func logIndent(level int, v ...interface{}) {
+	prefix := strings.Repeat("·", level)
+	v = append([]interface{}{prefix}, v...)
+	log.Println(v...)
 }
 
 // stripscheme removes any scheme components from url like paths.
@@ -295,3 +265,8 @@
 	}
 	return u.Host + u.Path
 }
+
+// Package a contains package b?
+func contains(a, b string) bool {
+	return a == b || strings.HasPrefix(b, a+"/")
+}
diff --git a/gbvendor/depset.go b/gbvendor/depset.go
deleted file mode 100644
index b4c40d8..0000000
--- a/gbvendor/depset.go
+++ /dev/null
@@ -1,114 +0,0 @@
-package vendor
-
-import (
-	"fmt"
-	"go/build"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-// Pkg describes a Go package.
-type Pkg struct {
-	*Depset
-	*build.Package
-}
-
-// Depset describes a set of related Go packages.
-type Depset struct {
-	Root   string
-	Prefix string
-	Pkgs   map[string]*Pkg
-}
-
-// LoadPaths returns a map of paths to Depsets.
-func LoadPaths(paths ...struct{ Root, Prefix string }) (map[string]*Depset, error) {
-	m := make(map[string]*Depset)
-	for _, p := range paths {
-		set, err := LoadTree(p.Root, p.Prefix)
-		if err != nil {
-			return nil, err
-		}
-		m[set.Root] = set
-	}
-	return m, nil
-}
-
-// LoadTree parses a tree of source files into a map of *pkgs.
-func LoadTree(root string, prefix string) (*Depset, error) {
-	d := Depset{
-		Root:   root,
-		Prefix: prefix,
-		Pkgs:   make(map[string]*Pkg),
-	}
-	fn := func(dir string, fi os.FileInfo) error {
-		importpath := filepath.Join(prefix, dir[len(root)+1:])
-
-		// if we're at the root of a tree, skip it
-		if importpath == "" {
-			return nil
-		}
-
-		p, err := loadPackage(&d, dir)
-		if err != nil {
-			if _, ok := err.(*build.NoGoError); ok {
-				return nil
-			}
-			return fmt.Errorf("loadPackage(%q, %q): %v", dir, importpath, err)
-		}
-		p.ImportPath = filepath.ToSlash(importpath)
-		if p != nil {
-			d.Pkgs[p.ImportPath] = p
-		}
-		return nil
-	}
-
-	// handle root of the tree
-	fi, err := os.Stat(root)
-	if err != nil {
-		return nil, err
-	}
-	if err := fn(root+string(filepath.Separator), fi); err != nil {
-		return nil, err
-	}
-
-	// walk sub directories
-	err = eachDir(root, fn)
-	return &d, err
-}
-
-func loadPackage(d *Depset, dir string) (*Pkg, error) {
-	p := Pkg{
-		Depset: d,
-	}
-	var err error
-
-	// expolit local import logic
-	p.Package, err = build.ImportDir(dir, build.ImportComment)
-	return &p, err
-}
-
-func eachDir(dir string, fn func(string, os.FileInfo) error) error {
-	f, err := os.Open(dir)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-	files, err := f.Readdir(-1)
-	for _, fi := range files {
-		if !fi.IsDir() {
-			continue
-		}
-		if strings.HasPrefix(fi.Name(), "_") || strings.HasPrefix(fi.Name(), ".") || fi.Name() == "testdata" {
-			continue
-		}
-		path := filepath.Join(dir, fi.Name())
-		if err := fn(path, fi); err != nil {
-			return err
-		}
-		if err := eachDir(path, fn); err != nil {
-			return err
-		}
-	}
-	return nil
-}
diff --git a/gbvendor/imports.go b/gbvendor/imports.go
index 373e3f9..db64a5b 100644
--- a/gbvendor/imports.go
+++ b/gbvendor/imports.go
@@ -57,15 +57,13 @@
 //
 // It returns the path to pkgName inside the vendor folder, relative to root.
 func findVendor(root, start, pkgName string) string {
-	if !strings.HasPrefix(root, start) {
-		log.Fatal("Assertion failed:", root, "prefix of", start)
+	if !strings.HasPrefix(start, root) {
+		log.Fatalln("Assertion failed:", root, "prefix of", start)
 	}
 
 	levels := strings.Split(strings.TrimPrefix(start, root), string(filepath.Separator))
-	log.Println(root, start, levels, pkgName)
 	for {
-		candidate := filepath.Join(append(append([]string{root}, levels...), pkgName)...)
-		log.Println(candidate)
+		candidate := filepath.Join(append(append([]string{root}, levels...), "vendor", pkgName)...)
 
 		files, err := ioutil.ReadDir(candidate)
 		if err != nil {
diff --git a/gbvendor/manifest.go b/gbvendor/manifest.go
index 6d68e74..0c3334b 100644
--- a/gbvendor/manifest.go
+++ b/gbvendor/manifest.go
@@ -6,6 +6,7 @@
 	"errors"
 	"fmt"
 	"io"
+	"log"
 	"os"
 	"reflect"
 	"sort"
@@ -24,19 +25,19 @@
 }
 
 var (
-	depPresent       = errors.New("dependency already present")
-	depSubPkgPresent = errors.New("subpackages of this dependency are already present")
-	depMissing       = errors.New("dependency does not exist")
+	DepPresent       = errors.New("dependency already present")
+	DepSubPkgPresent = errors.New("subpackages of this dependency are already present")
+	DepMissing       = errors.New("dependency does not exist")
 )
 
 // AddDependency adds a Dependency to the current Manifest.
 // If the dependency exists already then it returns and error.
 func (m *Manifest) AddDependency(dep Dependency) error {
 	if m.HasImportpath(dep.Importpath) {
-		return depPresent
+		return DepPresent
 	}
 	if m.GetSubpackages(dep.Importpath) != nil {
-		return depSubPkgPresent
+		return DepSubPkgPresent
 	}
 	m.Dependencies = append(m.Dependencies, dep)
 	return nil
@@ -51,7 +52,7 @@
 			return nil
 		}
 	}
-	return depMissing
+	return DepMissing
 }
 
 // HasImportpath reports whether the Manifest contains the import path,
@@ -66,7 +67,7 @@
 // If the dependency does not exist it returns an error.
 func (m *Manifest) GetDependencyForImportpath(path string) (Dependency, error) {
 	for _, d := range m.Dependencies {
-		if strings.HasPrefix(path, d.Importpath) {
+		if path == d.Importpath || strings.HasPrefix(path, d.Importpath+"/") {
 			return d, nil
 		}
 	}
@@ -169,16 +170,18 @@
 
 	var m Manifest
 	d := json.NewDecoder(f)
-	err = d.Decode(&m)
+	if err := d.Decode(&m); err != nil {
+		return nil, err
+	}
 
 	// Pass all dependencies through AddDependency to detect overlap
 	deps := m.Dependencies
 	m.Dependencies = nil
 	sort.Sort(byImportpath(deps)) // so that subpackages come after parents
 	for _, d := range deps {
-		if err := m.AddDependency(d); err == depPresent {
-			fmt.Fprintln(os.Stderr, "WARNING: overlapping dependency detected:", d.Importpath)
-			fmt.Fprintln(os.Stderr, "The subpackage will be ignored to fix undefined behavior. See https://git.io/vwK4B")
+		if err := m.AddDependency(d); err == DepPresent {
+			log.Println("WARNING: overlapping dependency detected:", d.Importpath)
+			log.Println("The subpackage will be ignored to fix undefined behavior. See https://git.io/vwK4B")
 		} else if err != nil {
 			return nil, err
 		}
diff --git a/gbvendor/stringset.go b/gbvendor/stringset.go
deleted file mode 100644
index 007eae5..0000000
--- a/gbvendor/stringset.go
+++ /dev/null
@@ -1,52 +0,0 @@
-package vendor
-
-// union returns the union of a and b.
-func union(a, b map[string]bool) map[string]bool {
-	r := make(map[string]bool)
-	for k := range a {
-		r[k] = true
-	}
-	for k := range b {
-		r[k] = true
-	}
-	return r
-}
-
-// intersection returns the intersection of a and b.
-func intersection(a, b map[string]bool) map[string]bool {
-	r := make(map[string]bool)
-	for k := range a {
-		if b[k] {
-			r[k] = true
-		}
-	}
-	return r
-}
-
-// difference returns the symetric difference of a and b.
-func difference(a, b map[string]bool) map[string]bool {
-	r := make(map[string]bool)
-	for k := range a {
-		if !b[k] {
-			r[k] = true
-		}
-	}
-	for k := range b {
-		if !a[k] {
-			r[k] = true
-		}
-	}
-	return r
-}
-
-// contains returns true if a contains all the elements in s.
-func contains(a map[string]bool, s ...string) bool {
-	var r bool
-	for _, e := range s {
-		if !a[e] {
-			return false
-		}
-		r = true
-	}
-	return r
-}
diff --git a/gbvendor/stringset_test.go b/gbvendor/stringset_test.go
deleted file mode 100644
index d8781a4..0000000
--- a/gbvendor/stringset_test.go
+++ /dev/null
@@ -1,147 +0,0 @@
-package vendor
-
-import "testing"
-import "reflect"
-
-func set(args ...string) map[string]bool {
-	r := make(map[string]bool)
-	for _, a := range args {
-		r[a] = true
-	}
-	return r
-}
-
-func TestUnion(t *testing.T) {
-	tests := []struct {
-		a, b map[string]bool
-		want map[string]bool
-	}{{
-		a: nil, b: nil,
-		want: set(),
-	}, {
-		a: nil, b: set("b"),
-		want: set("b"),
-	}, {
-		a: set("a"), b: nil,
-		want: set("a"),
-	}, {
-		a: set("a"), b: set("b"),
-		want: set("b", "a"),
-	}, {
-		a: set("c"), b: set("c"),
-		want: set("c"),
-	}}
-
-	for _, tt := range tests {
-		got := union(tt.a, tt.b)
-		if !reflect.DeepEqual(tt.want, got) {
-			t.Errorf("union(%v, %v) want: %v, got %v", tt.a, tt.b, tt.want, got)
-		}
-	}
-}
-
-func TestIntersection(t *testing.T) {
-	tests := []struct {
-		a, b map[string]bool
-		want map[string]bool
-	}{{
-		a: nil, b: nil,
-		want: set(),
-	}, {
-		a: nil, b: set("b"),
-		want: set(),
-	}, {
-		a: set("a"), b: nil,
-		want: set(),
-	}, {
-		a: set("a"), b: set("b"),
-		want: set(),
-	}, {
-		a: set("c"), b: set("c"),
-		want: set("c"),
-	}, {
-		a: set("a", "c"), b: set("b", "c"),
-		want: set("c"),
-	}}
-
-	for _, tt := range tests {
-		got := intersection(tt.a, tt.b)
-		if !reflect.DeepEqual(tt.want, got) {
-			t.Errorf("intersection(%v, %v) want: %v, got %v", tt.a, tt.b, tt.want, got)
-		}
-	}
-}
-
-func TestDifference(t *testing.T) {
-	tests := []struct {
-		a, b map[string]bool
-		want map[string]bool
-	}{{
-		a: nil, b: nil,
-		want: set(),
-	}, {
-		a: nil, b: set("b"),
-		want: set("b"),
-	}, {
-		a: set("a"), b: nil,
-		want: set("a"),
-	}, {
-		a: set("a"), b: set("b"),
-		want: set("a", "b"),
-	}, {
-		a: set("c"), b: set("c"),
-		want: set(),
-	}, {
-		a: set("a", "c"), b: set("b", "c"),
-		want: set("a", "b"),
-	}}
-
-	for _, tt := range tests {
-		got := difference(tt.a, tt.b)
-		if !reflect.DeepEqual(tt.want, got) {
-			t.Errorf("difference(%v, %v) want: %v, got %v", tt.a, tt.b, tt.want, got)
-		}
-	}
-}
-
-func TestContains(t *testing.T) {
-	tests := []struct {
-		a    map[string]bool
-		s    []string
-		want bool
-	}{{
-		a: nil, s: nil,
-		want: false,
-	}, {
-		a: set("a"), s: nil,
-		want: false,
-	}, {
-		a: set("a"), s: []string{"a"},
-		want: true,
-	}, {
-		a: set("a"), s: []string{"b"},
-		want: false,
-	}, {
-		a: set("a", "b"), s: []string{"b"},
-		want: true,
-	}, {
-		a: set("a"), s: []string{"a", "b"},
-		want: false,
-	}, {
-		a: set("a", "b", "c"), s: []string{"a", "b"},
-		want: true,
-	}, {
-		a: set("a", "b", "c"), s: []string{"x", "b"},
-		want: false,
-	}, {
-		a: set("a", "b", "c"), s: []string{"b", "c", "d"},
-		want: false,
-	}}
-
-	for _, tt := range tests {
-		got := contains(tt.a, tt.s...)
-		if !reflect.DeepEqual(tt.want, got) {
-			t.Errorf("contains(%v, %v) want: %v, got %v", tt.a, tt.s, tt.want, got)
-		}
-	}
-}
diff --git a/list.go b/list.go
index 49e7e89..95b50a9 100644
--- a/list.go
+++ b/list.go
@@ -31,7 +31,7 @@
 
 `,
 	Run: func(args []string) error {
-		m, err := vendor.ReadManifest(manifestFile())
+		m, err := vendor.ReadManifest(manifestFile)
 		if err != nil {
 			return fmt.Errorf("could not load manifest: %v", err)
 		}
diff --git a/main.go b/main.go
index 129b95b..c83d694 100644
--- a/main.go
+++ b/main.go
@@ -3,9 +3,11 @@
 import (
 	"flag"
 	"fmt"
+	"go/build"
 	"log"
 	"os"
 	"path/filepath"
+	"strings"
 )
 
 var fs = flag.NewFlagSet(os.Args[0], flag.ContinueOnError)
@@ -78,16 +80,22 @@
 	os.Exit(3)
 }
 
-const manifestfile = "manifest"
+var (
+	vendorDir, manifestFile string
+	importPath              string
+)
 
-func vendorDir() string {
+func init() {
 	wd, err := os.Getwd()
 	if err != nil {
 		log.Fatal(err)
 	}
-	return filepath.Join(wd, "vendor")
-}
-
-func manifestFile() string {
-	return filepath.Join(vendorDir(), manifestfile)
+	vendorDir = filepath.Join(wd, "vendor")
+	manifestFile = filepath.Join(vendorDir, "manifest")
+	srcTree := filepath.Join(build.Default.GOPATH, "src") + string(filepath.Separator)
+	if build.Default.GOPATH == "" || !strings.HasPrefix(wd, srcTree) {
+		log.Println("WARNING: for go vendoring to work your project needs to be somewhere under $GOPATH/src/")
+	} else {
+		importPath = filepath.ToSlash(strings.TrimPrefix(wd, srcTree))
+	}
 }
diff --git a/restore.go b/restore.go
index 3601291..dc0b1e3 100644
--- a/restore.go
+++ b/restore.go
@@ -47,7 +47,7 @@
 	Run: func(args []string) error {
 		switch len(args) {
 		case 0:
-			return restore(manifestFile())
+			return restore(manifestFile)
 		default:
 			return fmt.Errorf("restore takes no arguments")
 		}
@@ -69,7 +69,7 @@
 		go func() {
 			defer wg.Done()
 			for d := range depC {
-				if err := downloadDependency(d, &errors, vendorDir(), false); err != nil {
+				if err := downloadDependency(d, &errors, vendorDir, false); err != nil {
 					log.Printf("%s: %v", d.Importpath, err)
 					atomic.AddUint32(&errors, 1)
 				}
diff --git a/update.go b/update.go
index 8f6c6f1..9c73a49 100644
--- a/update.go
+++ b/update.go
@@ -46,7 +46,7 @@
 			return fmt.Errorf("update: you cannot specify path and -all flag at once")
 		}
 
-		m, err := vendor.ReadManifest(manifestFile())
+		m, err := vendor.ReadManifest(manifestFile)
 		if err != nil {
 			return fmt.Errorf("could not load manifest: %v", err)
 		}
@@ -101,12 +101,12 @@
 				AllFiles:   d.AllFiles,
 			}
 
-			if err := fileutils.RemoveAll(filepath.Join(vendorDir(), filepath.FromSlash(d.Importpath))); err != nil {
+			if err := fileutils.RemoveAll(filepath.Join(vendorDir, filepath.FromSlash(d.Importpath))); err != nil {
 				// TODO(dfc) need to apply vendor.cleanpath here to remove intermediate directories.
 				return fmt.Errorf("dependency could not be deleted: %v", err)
 			}
 
-			dst := filepath.Join(vendorDir(), filepath.FromSlash(dep.Importpath))
+			dst := filepath.Join(vendorDir, filepath.FromSlash(dep.Importpath))
 			src := filepath.Join(wc.Dir(), dep.Path)
 
 			if err := fileutils.Copypath(dst, src, !d.NoTests, d.AllFiles); err != nil {
@@ -121,7 +121,7 @@
 				return err
 			}
 
-			if err := vendor.WriteManifest(manifestFile(), m); err != nil {
+			if err := vendor.WriteManifest(manifestFile, m); err != nil {
 				return err
 			}
 		}