diff --git a/action/config_wizard.go b/action/config_wizard.go
new file mode 100644
index 0000000..16886bb
--- /dev/null
+++ b/action/config_wizard.go
@@ -0,0 +1,362 @@
+package action
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"github.com/Masterminds/glide/cache"
+	"github.com/Masterminds/glide/cfg"
+	"github.com/Masterminds/glide/msg"
+	gpath "github.com/Masterminds/glide/path"
+	"github.com/Masterminds/semver"
+	"github.com/Masterminds/vcs"
+)
+
+// ConfigWizard reads configuration from a glide.yaml file and attempts to suggest
+// improvements. The wizard is interactive.
+func ConfigWizard(base string) {
+	_, err := gpath.Glide()
+	glidefile := gpath.GlideFile
+	if err != nil {
+		msg.Info("Unable to find a glide.yaml file. Would you like to create one now? Yes (Y) or No (N)")
+		bres := msg.PromptUntilYorN()
+		if bres {
+			// Guess deps
+			conf := guessDeps(base, false)
+			// Write YAML
+			if err := conf.WriteFile(glidefile); err != nil {
+				msg.Die("Could not save %s: %s", glidefile, err)
+			}
+		} else {
+			msg.Err("Unable to find configuration file. Please create configuration information to continue.")
+		}
+	}
+
+	conf := EnsureConfig()
+
+	err = cache.Setup()
+	if err != nil {
+		msg.Die("Problem setting up cache: %s", err)
+	}
+
+	msg.Info("Looking for dependencies to make suggestions on")
+	msg.Info("--> Scanning for dependencies not using verion ranges")
+	msg.Info("--> Scanning for dependencies using commit ids")
+	var deps []*cfg.Dependency
+	for _, dep := range conf.Imports {
+		if wizardLookInto(dep) {
+			deps = append(deps, dep)
+		}
+	}
+
+	msg.Info("Gathering information on each dependency")
+	msg.Info("--> This may take a moment. Especially on a codebase with many dependencies")
+	msg.Info("--> Gathering release information for dependencies")
+	msg.Info("--> Looking for dependency imports where versions are commit ids")
+	for _, dep := range deps {
+		wizardFindVersions(dep)
+	}
+
+	var changes int
+	for _, dep := range deps {
+		var remote string
+		if dep.Repository != "" {
+			remote = dep.Repository
+		} else {
+			remote = "https://" + dep.Name
+		}
+
+		// First check, ask if the tag should be used instead of the commit id for it.
+		cur := cache.MemCurrent(remote)
+		if cur != "" && cur != dep.Reference {
+			wizardSugOnce()
+			var dres bool
+			asked, use, val := wizardOnce("current")
+			if !use {
+				dres = wizardAskCurrent(cur, dep)
+			}
+			if !asked {
+				as := wizardRemember()
+				wizardSetOnce("current", as, dres)
+			}
+
+			if asked && use {
+				dres = val.(bool)
+			}
+
+			if dres {
+				msg.Info("Updating %s to use the tag %s instead of commit id %s", dep.Name, cur, dep.Reference)
+				dep.Reference = cur
+				changes++
+			}
+		}
+
+		// Second check, if no version is being used and there's a semver release ask about latest.
+		memlatest := cache.MemLatest(remote)
+		if dep.Reference == "" && memlatest != "" {
+			wizardSugOnce()
+			var dres bool
+			asked, use, val := wizardOnce("latest")
+			if !use {
+				dres = wizardAskLatest(memlatest, dep)
+			}
+			if !asked {
+				as := wizardRemember()
+				wizardSetOnce("latest", as, dres)
+			}
+
+			if asked && use {
+				dres = val.(bool)
+			}
+
+			if dres {
+				msg.Info("Updating %s to use the release %s instead of no release", dep.Name, cur)
+				dep.Reference = cur
+				changes++
+			}
+		}
+
+		// Third check, if the version is semver offer to use a range instead.
+		sv, err := semver.NewVersion(dep.Reference)
+		if err == nil {
+			wizardSugOnce()
+			var res string
+			asked, use, val := wizardOnce("range")
+			if !use {
+				res = wizardAskRange(sv, dep)
+			}
+			if !asked {
+				as := wizardRemember()
+				wizardSetOnce("range", as, res)
+			}
+
+			if asked && use {
+				res = val.(string)
+			}
+
+			if res == "m" {
+				r := "^" + sv.String()
+				msg.Info("Updating %s to use the range %s instead of commit id %s", dep.Name, r, dep.Reference)
+				dep.Reference = r
+				changes++
+			} else if res == "p" {
+				r := "~" + sv.String()
+				msg.Info("Updating %s to use the range %s instead of commit id %s", dep.Name, r, dep.Reference)
+				dep.Reference = r
+				changes++
+			}
+		}
+	}
+
+	if changes > 0 {
+		msg.Info("Configuration changes have been made. Would you like to write these")
+		msg.Info("changes to your configuration file? Yes (Y) or No (N)")
+		dres := msg.PromptUntilYorN()
+		if dres {
+			msg.Info("Writing updates to configuration file (%s)", glidefile)
+			if err := conf.WriteFile(glidefile); err != nil {
+				msg.Die("Could not save %s: %s", glidefile, err)
+			}
+			msg.Info("You can now edit the glide.yaml file.:")
+			msg.Info("--> For more information on versions and ranges see https://glide.sh/docs/versions/")
+			msg.Info("--> For details on additional metadata see https://glide.sh/docs/glide.yaml/")
+		} else {
+			msg.Warn("Change not written to configuration file")
+		}
+	} else {
+		msg.Info("No proposed changes found. Have a nice day.")
+	}
+}
+
+var wizardOnceVal = make(map[string]interface{})
+var wizardOnceDo = make(map[string]bool)
+var wizardOnceAsked = make(map[string]bool)
+
+var wizardSuggeseOnce bool
+
+func wizardSugOnce() {
+	if !wizardSuggeseOnce {
+		msg.Info("Here are some suggestions...")
+	}
+	wizardSuggeseOnce = true
+}
+
+// Returns if it's you should prompt, if not prompt if you should use stored value,
+// and stored value if it has one.
+func wizardOnce(name string) (bool, bool, interface{}) {
+	return wizardOnceAsked[name], wizardOnceDo[name], wizardOnceVal[name]
+}
+
+func wizardSetOnce(name string, prompt bool, val interface{}) {
+	wizardOnceAsked[name] = true
+	wizardOnceDo[name] = prompt
+	wizardOnceVal[name] = val
+}
+
+func wizardRemember() bool {
+	msg.Info("Would you like to remember the previous decision and apply it to future")
+	msg.Info("dependencies? Yes (Y) or No (N)")
+	return msg.PromptUntilYorN()
+}
+
+func wizardAskRange(ver *semver.Version, d *cfg.Dependency) string {
+	vstr := ver.String()
+	msg.Info("The package %s appears to use semantic versions (http://semver.org).", d.Name)
+	msg.Info("Would you like to track the latest minor or patch releases (major.minor.path)?")
+	msg.Info("Tracking minor version releases would use '>= %s, < %d.0.0' ('^%s'). Tracking patch version", vstr, ver.Major()+1, vstr)
+	msg.Info("releases would use '>= %s, < %d.%d.0' ('~%s'). For more information on Glide versions", vstr, ver.Major(), ver.Minor()+1, vstr)
+	msg.Info("and ranges see https://glide.sh/docs/versions")
+	msg.Info("Minor (M), Patch (P), or Skip Ranges (S)?")
+	res, err := msg.PromptUntil([]string{"minor", "m", "patch", "p", "skip ranges", "s"})
+	if err != nil {
+		msg.Die("Error processing response: %s", err)
+	}
+	if res == "m" || res == "minor" {
+		return "m"
+	} else if res == "p" || res == "patch" {
+		return "p"
+	}
+
+	return "s"
+}
+
+func wizardAskCurrent(cur string, d *cfg.Dependency) bool {
+	msg.Info("The package %s is currently set to use the version %s.", d.Name, d.Reference)
+	msg.Info("There is an equivalent semantic version (http://semver.org) release of %s. Would", cur)
+	msg.Info("you like to use that instead? Yes (Y) or No (N)")
+	return msg.PromptUntilYorN()
+}
+
+func wizardAskLatest(latest string, d *cfg.Dependency) bool {
+	msg.Info("The package %s appears to have Semantic Version releases (http://semver.org). ", d.Name)
+	msg.Info("The latestrelease is %s. You are currently not using a release. Would you like", latest)
+	msg.Info("to use this release? Yes (Y) or No (N)")
+	return msg.PromptUntilYorN()
+}
+
+func wizardLookInto(d *cfg.Dependency) bool {
+	_, err := semver.NewConstraint(d.Reference)
+
+	// The existing version is already a valid semver constraint so we skip suggestions.
+	if err == nil {
+		return false
+	}
+
+	return true
+}
+
+// Note, this really needs a simpler name.
+var createGitParseVersion = regexp.MustCompile(`(?m-s)(?:tags)/(\S+)$`)
+
+func wizardFindVersions(d *cfg.Dependency) {
+	l, err := cache.Location()
+	if err != nil {
+		msg.Debug("Problem detecting cache location: %s", err)
+	}
+	var remote string
+	if d.Repository != "" {
+		remote = d.Repository
+	} else {
+		remote = "https://" + d.Name
+	}
+
+	key, err := cache.Key(remote)
+	if err != nil {
+		msg.Debug("Problem generating cache key for %s: %s", remote, err)
+	}
+
+	local := filepath.Join(l, "src", key)
+	repo, err := vcs.NewRepo(remote, local)
+	if err != nil {
+		msg.Debug("Problem getting repo instance: %s", err)
+	}
+
+	var useLocal bool
+	if _, err = os.Stat(local); err == nil {
+		useLocal = true
+	}
+
+	// Git endpoints allow for querying without fetching the codebase locally.
+	// We try that first to avoid fetching right away. Is this premature
+	// optimization?
+	cc := true
+	if !useLocal && repo.Vcs() == vcs.Git {
+		out, err2 := exec.Command("git", "ls-remote", remote).CombinedOutput()
+		if err2 == nil {
+			cache.MemTouch(remote)
+			cc = false
+			lines := strings.Split(string(out), "\n")
+			for _, i := range lines {
+				ti := strings.TrimSpace(i)
+				if found := createGitParseVersion.FindString(ti); found != "" {
+					tg := strings.TrimPrefix(strings.TrimSuffix(found, "^{}"), "tags/")
+					cache.MemPut(remote, tg)
+					if d.Reference != "" && strings.HasPrefix(ti, d.Reference) {
+						cache.MemSetCurrent(remote, tg)
+					}
+				}
+			}
+		}
+	}
+
+	if cc {
+		cache.Lock(key)
+		cache.MemTouch(remote)
+		if _, err = os.Stat(local); os.IsNotExist(err) {
+			repo.Get()
+			branch := findCurrentBranch(repo)
+			c := cache.RepoInfo{DefaultBranch: branch}
+			err = cache.SaveRepoData(key, c)
+			if err != nil {
+				msg.Debug("Error saving cache repo details: %s", err)
+			}
+		} else {
+			repo.Update()
+		}
+		tgs, err := repo.Tags()
+		if err != nil {
+			msg.Debug("Problem getting tags: %s", err)
+		} else {
+			for _, v := range tgs {
+				cache.MemPut(remote, v)
+			}
+		}
+		if d.Reference != "" && repo.IsReference(d.Reference) {
+			tgs, err = repo.TagsFromCommit(d.Reference)
+			if err != nil {
+				msg.Debug("Problem getting tags for commit: %s", err)
+			} else {
+				if len(tgs) > 0 {
+					for _, v := range tgs {
+						if !(repo.Vcs() == vcs.Hg && v == "tip") {
+							cache.MemSetCurrent(remote, v)
+						}
+					}
+				}
+			}
+		}
+		cache.Unlock(key)
+	}
+}
+
+func findCurrentBranch(repo vcs.Repo) string {
+	msg.Debug("Attempting to find current branch for %s", repo.Remote())
+	// Svn and Bzr don't have default branches.
+	if repo.Vcs() == vcs.Svn || repo.Vcs() == vcs.Bzr {
+		return ""
+	}
+
+	if repo.Vcs() == vcs.Git || repo.Vcs() == vcs.Hg {
+		ver, err := repo.Current()
+		if err != nil {
+			msg.Debug("Unable to find current branch for %s, error: %s", repo.Remote(), err)
+			return ""
+		}
+		return ver
+	}
+
+	return ""
+}
diff --git a/action/create.go b/action/create.go
index fa72e6b..4d1c0bb 100644
--- a/action/create.go
+++ b/action/create.go
@@ -2,31 +2,20 @@
 
 import (
 	"os"
-	"os/exec"
 	"path/filepath"
-	"regexp"
 	"sort"
 	"strings"
-	"sync"
 
-	"github.com/Masterminds/glide/cache"
 	"github.com/Masterminds/glide/cfg"
 	"github.com/Masterminds/glide/dependency"
 	"github.com/Masterminds/glide/gb"
 	"github.com/Masterminds/glide/godep"
-	"github.com/Masterminds/glide/gom"
 	"github.com/Masterminds/glide/gpm"
 	"github.com/Masterminds/glide/msg"
 	gpath "github.com/Masterminds/glide/path"
 	"github.com/Masterminds/glide/util"
-	"github.com/Masterminds/semver"
-	"github.com/Masterminds/vcs"
 )
 
-// TODO(mattfarina): This file could really use to be cleaned up. It's functional
-// but not all that elegant. This mess of code really needs someone to come
-// along and clean it up. Pretty please.
-
 // Create creates/initializes a new Glide repository.
 //
 // This will fail if a glide.yaml already exists.
@@ -36,21 +25,36 @@
 // If skipImport is set to true, this will not attempt to import from an existing
 // GPM, Godep, or GB project if one should exist. However, it will still attempt
 // to read the local source to determine required packages.
-func Create(base string, skipImport, noInteract, skipVerSug bool) {
+func Create(base string, skipImport, nonInteractive bool) {
 	glidefile := gpath.GlideFile
 	// Guard against overwrites.
 	guardYAML(glidefile)
 
 	// Guess deps
-	conf := guessDeps(base, skipImport, noInteract, skipVerSug)
+	conf := guessDeps(base, skipImport)
 	// Write YAML
-	msg.Info("Writing glide.yaml file")
+	msg.Info("Writing configuration file (%s)", glidefile)
 	if err := conf.WriteFile(glidefile); err != nil {
 		msg.Die("Could not save %s: %s", glidefile, err)
 	}
-	msg.Info("You can now edit the glide.yaml file. Consider:")
-	msg.Info("--> Using versions and ranges. See https://glide.sh/docs/versions/")
-	msg.Info("--> Adding additional metadata. See https://glide.sh/docs/glide.yaml/")
+
+	var res bool
+	if !nonInteractive {
+		msg.Info("Would you like Glide to help you find ways to improve your glide.yaml configuration?")
+		msg.Info("If you want to revisit this step you can use the config-wizard command at any time.")
+		msg.Info("Yes (Y) or No (N)?")
+		res = msg.PromptUntilYorN()
+		if res {
+			ConfigWizard(base)
+		}
+	}
+
+	if !res {
+		msg.Info("You can now edit the glide.yaml file. Consider:")
+		msg.Info("--> Using versions and ranges. See https://glide.sh/docs/versions/")
+		msg.Info("--> Adding additional metadata. See https://glide.sh/docs/glide.yaml/")
+		msg.Info("--> Running the config-wizard command to improve the versions in your configuration")
+	}
 }
 
 // guardYAML fails if the given file already exists.
@@ -69,7 +73,7 @@
 //
 // FIXME: This function is likely a one-off that has a more standard alternative.
 // It's also long and could use a refactor.
-func guessDeps(base string, skipImport, noInteract, skipVerSug bool) *cfg.Config {
+func guessDeps(base string, skipImport bool) *cfg.Config {
 	buildContext, err := util.GetBuildContext()
 	if err != nil {
 		msg.Die("Failed to build an import context: %s", err)
@@ -85,17 +89,18 @@
 
 	// Import by looking at other package managers and looking over the
 	// entire directory structure.
-	var deps cfg.Dependencies
 
 	// Attempt to import from other package managers.
 	if !skipImport {
-		deps = guessImportDeps(base)
-		if len(deps) == 0 {
-			msg.Info("No dependencies found to import")
-		}
+		guessImportDeps(base, config)
 	}
 
-	msg.Info("Scanning code to look for dependencies")
+	importLen := len(config.Imports)
+	if importLen == 0 {
+		msg.Info("Scanning code to look for dependencies")
+	} else {
+		msg.Info("Scanning code to look for dependencies not found in import")
+	}
 
 	// Resolve dependencies by looking at the tree.
 	r, err := dependency.NewResolver(base)
@@ -118,194 +123,39 @@
 		vpath = vpath + string(os.PathSeparator)
 	}
 
-	var count int
-	var all string
-	var allOnce bool
 	for _, pa := range sortable {
 		n := strings.TrimPrefix(pa, vpath)
 		root, subpkg := util.NormalizeName(n)
 
 		if !config.HasDependency(root) && root != config.Name {
-			count++
-			d := deps.Get(root)
-			if d == nil {
-				d = &cfg.Dependency{
-					Name: root,
-				}
-				msg.Info("--> Found reference to %s", n)
-			} else {
-				msg.Info("--> Found imported reference to %s", n)
+			msg.Info("--> Found reference to %s\n", n)
+			d := &cfg.Dependency{
+				Name: root,
 			}
-
-			all, allOnce = guessAskVersion(noInteract, all, allOnce, skipVerSug, d)
-
-			if subpkg != "" {
-				if !d.HasSubpackage(subpkg) {
-					d.Subpackages = append(d.Subpackages, subpkg)
-				}
-				msg.Verbose("--> Noting sub-package %s to %s", subpkg, root)
+			if len(subpkg) > 0 {
+				d.Subpackages = []string{subpkg}
 			}
-
 			config.Imports = append(config.Imports, d)
 		} else if config.HasDependency(root) {
 			if len(subpkg) > 0 {
 				subpkg = strings.TrimPrefix(subpkg, "/")
 				d := config.Imports.Get(root)
 				if !d.HasSubpackage(subpkg) {
+					msg.Info("--> Adding sub-package %s to %s\n", subpkg, root)
 					d.Subpackages = append(d.Subpackages, subpkg)
 				}
-				msg.Verbose("--> Noting sub-package %s to %s", subpkg, root)
 			}
 		}
 	}
 
-	if !skipImport && len(deps) > count {
-		var res string
-		if noInteract {
-			res = "y"
-		} else {
-			msg.Info("%d unused imported dependencies found. These are likely transitive dependencies ", len(deps)-count)
-			msg.Info("(dependencies of your dependencies). Would you like to track them in your")
-			msg.Info("glide.yaml file? Note, Glide will automatically scan your codebase to detect")
-			msg.Info("the complete dependency tree and import the complete tree. If your dependencies")
-			msg.Info("do not track dependency version information some version information may be lost.")
-			msg.Info("Yes (Y) or No (N)?")
-			res, err = msg.PromptUntil([]string{"y", "yes", "n", "no"})
-			if err != nil {
-				msg.Die("Error processing response: %s", err)
-			}
-		}
-		if res == "y" || res == "yes" {
-			msg.Info("Including additional imports in the glide.yaml file")
-			for _, dep := range deps {
-				found := config.Imports.Get(dep.Name)
-				if found == nil {
-					config.Imports = append(config.Imports, dep)
-					if dep.Reference != "" {
-						all, allOnce = guessAskVersion(noInteract, all, allOnce, skipVerSug, dep)
-						msg.Info("--> Adding %s at version %s", dep.Name, dep.Reference)
-					} else {
-						msg.Info("--> Adding %s", dep.Name)
-					}
-				}
-			}
-		}
+	if len(config.Imports) == importLen && importLen != 0 {
+		msg.Info("--> Code scanning found no additional imports")
 	}
 
 	return config
 }
 
-func guessAskVersion(noInteract bool, all string, allonce, skipVerSug bool, d *cfg.Dependency) (string, bool) {
-	if !noInteract && !skipVerSug && d.Reference == "" {
-		// If scanning has not happened already, for example this isn't an
-		// import, try it now.
-		var loc string
-		if d.Repository != "" {
-			loc = d.Repository
-		} else {
-			loc = "https://" + d.Name
-		}
-		if !guessVersionCache.checked(loc) {
-			createGuessVersion(loc, d.Reference)
-		}
-
-		semv := guessVersionCache.get(loc)
-		if semv != "" {
-			msg.Info("The package %s appears to have Semantic Version releases. The latest", d.Name)
-			msg.Info("release is %s. Would you like to use this release? Yes (Y) or No (N)", semv)
-			res, err2 := msg.PromptUntil([]string{"y", "yes", "n", "no"})
-			if err2 != nil {
-				msg.Die("Error processing response: %s", err2)
-			}
-
-			if res == "y" || res == "yes" {
-				d.Reference = semv
-			}
-		}
-
-	}
-
-	if !noInteract && d.Reference != "" {
-		var changedVer bool
-		ver, err := semver.NewVersion(d.Reference)
-		if err != nil && !skipVerSug {
-			var loc string
-			if d.Repository != "" {
-				loc = d.Repository
-			} else {
-				loc = "https://" + d.Name
-			}
-
-			semv := guessVersionCache.get(loc)
-			if semv != "" {
-				msg.Info("The package %s appears to have Semantic Version releases but the imported data", d.Name)
-				msg.Info("is not using them. The latest release is %s but the imported data is using %s.", semv, d.Reference)
-				msg.Info("Would you like to use the latest release version instead? Yes (Y) or No (N)")
-				res, err2 := msg.PromptUntil([]string{"y", "yes", "n", "no"})
-				if err2 != nil {
-					msg.Die("Error processing response: %s", err2)
-				}
-
-				if res == "y" || res == "yes" {
-					d.Reference = semv
-					changedVer = true
-				}
-			}
-		}
-
-		if changedVer {
-			ver, err = semver.NewVersion(d.Reference)
-		}
-		if err == nil {
-			if all == "" {
-				vstr := ver.String()
-				msg.Info("Imported dependency %s (%s) appears to use semantic versions (http://semver.org).", d.Name, d.Reference)
-				msg.Info("Would you like Glide to track the latest minor or patch releases (major.minor.path)?")
-				msg.Info("Tracking minor version releases would use '>= %s, < %d.0.0' ('^%s'). Tracking patch version", vstr, ver.Major()+1, vstr)
-				msg.Info("releases would use '>= %s, < %d.%d.0' ('~%s'). For more information on Glide versions", vstr, ver.Major(), ver.Minor()+1, vstr)
-				msg.Info("and ranges see https://glide.sh/docs/versions")
-				msg.Info("Minor (M), Patch (P), or Skip Ranges (S)?")
-				res, err := msg.PromptUntil([]string{"minor", "m", "patch", "p", "skip ranges", "s"})
-				if err != nil {
-					msg.Die("Error processing response: %s", err)
-				}
-				if res == "m" || res == "minor" {
-					d.Reference = "^" + vstr
-				} else if res == "p" || res == "patch" {
-					d.Reference = "~" + vstr
-				}
-
-				if !allonce {
-					msg.Info("Would you like to same response (%s) for future dependencies? Yes (Y) or No (N)", res)
-					res2, err := msg.PromptUntil([]string{"y", "yes", "n", "no"})
-					if err != nil {
-						msg.Die("Error processing response: %s", err)
-					}
-					if res2 == "yes" || res2 == "y" {
-						return res, true
-					}
-
-					return "", true
-				}
-
-			} else {
-				if all == "m" || all == "minor" {
-					d.Reference = "^" + ver.String()
-				} else if all == "p" || all == "patch" {
-					d.Reference = "~" + ver.String()
-				}
-			}
-
-			return all, allonce
-		}
-
-		return all, allonce
-	}
-
-	return all, allonce
-}
-
-func guessImportDeps(base string) cfg.Dependencies {
+func guessImportDeps(base string, config *cfg.Config) {
 	msg.Info("Attempting to import from other package managers (use --skip-import to skip)")
 	deps := []*cfg.Dependency{}
 	absBase, err := filepath.Abs(base)
@@ -315,7 +165,7 @@
 
 	if d, ok := guessImportGodep(absBase); ok {
 		msg.Info("Importing Godep configuration")
-		msg.Warn("--> Godep uses commit id versions. Consider using Semantic Versions with Glide")
+		msg.Warn("Godep uses commit id versions. Consider using Semantic Versions with Glide")
 		deps = d
 	} else if d, ok := guessImportGPM(absBase); ok {
 		msg.Info("Importing GPM configuration")
@@ -323,41 +173,17 @@
 	} else if d, ok := guessImportGB(absBase); ok {
 		msg.Info("Importing GB configuration")
 		deps = d
-	} else if d, ok := guessImportGom(absBase); ok {
-		msg.Info("Importing GB configuration")
-		deps = d
 	}
 
-	if len(deps) > 0 {
-		msg.Info("--> Attempting to detect versions from imported commit ids")
-	}
-
-	var wg sync.WaitGroup
-
 	for _, i := range deps {
-		wg.Add(1)
-		go func(dep *cfg.Dependency) {
-			var remote string
-			if dep.Repository != "" {
-				remote = dep.Repository
-			} else {
-				remote = "https://" + dep.Name
-			}
-			ver := createGuessVersion(remote, dep.Reference)
-			if ver != dep.Reference {
-				msg.Verbose("--> Found imported reference to %s at version %s", dep.Name, ver)
-				dep.Reference = ver
-			}
+		if i.Reference == "" {
+			msg.Info("--> Found imported reference to %s", i.Name)
+		} else {
+			msg.Info("--> Found imported reference to %s at revision %s", i.Name, i.Reference)
+		}
 
-			msg.Debug("--> Found imported reference to %s at revision %s", dep.Name, dep.Reference)
-
-			wg.Done()
-		}(i)
+		config.Imports = append(config.Imports, i)
 	}
-
-	wg.Wait()
-
-	return deps
 }
 
 func guessImportGodep(dir string) ([]*cfg.Dependency, bool) {
@@ -386,165 +212,3 @@
 
 	return d, true
 }
-
-func guessImportGom(dir string) ([]*cfg.Dependency, bool) {
-	d, err := gom.Parse(dir)
-	if err != nil || len(d) == 0 {
-		return []*cfg.Dependency{}, false
-	}
-
-	return d, true
-}
-
-// Note, this really needs a simpler name.
-var createGitParseVersion = regexp.MustCompile(`(?m-s)(?:tags)/(\S+)$`)
-
-var guessVersionCache = newVersionCache()
-
-func createGuessVersion(remote, id string) string {
-	err := cache.Setup()
-	if err != nil {
-		msg.Debug("Problem setting up cache: %s", err)
-	}
-	l, err := cache.Location()
-	if err != nil {
-		msg.Debug("Problem detecting cache location: %s", err)
-	}
-	key, err := cache.Key(remote)
-	if err != nil {
-		msg.Debug("Problem generating cache key for %s: %s", remote, err)
-	}
-
-	local := filepath.Join(l, "src", key)
-	repo, err := vcs.NewRepo(remote, local)
-	if err != nil {
-		msg.Debug("Problem getting repo instance: %s", err)
-	}
-
-	// Git endpoints allow for querying without fetching the codebase locally.
-	// We try that first to avoid fetching right away. Is this premature
-	// optimization?
-	cc := true
-	if repo.Vcs() == vcs.Git {
-		out, err := exec.Command("git", "ls-remote", remote).CombinedOutput()
-		if err == nil {
-			guessVersionCache.touchChecked(remote)
-			cc = false
-			lines := strings.Split(string(out), "\n")
-			res := ""
-
-			// TODO(mattfarina): Detect if the found version is semver and use
-			// that one instead of the first found.
-			for _, i := range lines {
-				ti := strings.TrimSpace(i)
-				if found := createGitParseVersion.FindString(ti); found != "" {
-					tg := strings.TrimPrefix(strings.TrimSuffix(found, "^{}"), "tags/")
-					if strings.HasPrefix(ti, id) {
-						res = tg
-					}
-
-					ver, err := semver.NewVersion(tg)
-					if err == nil {
-						if guessVersionCache.get(remote) == "" {
-							guessVersionCache.put(remote, tg)
-						} else {
-							ver2, err := semver.NewVersion(guessVersionCache.get(remote))
-							if err == nil {
-								if ver.GreaterThan(ver2) {
-									guessVersionCache.put(remote, tg)
-								}
-							}
-						}
-					}
-				}
-			}
-
-			if res != "" {
-				return res
-			}
-		}
-	}
-
-	if cc {
-		cache.Lock(key)
-		if _, err = os.Stat(local); os.IsNotExist(err) {
-			repo.Get()
-			branch := findCurrentBranch(repo)
-			c := cache.RepoInfo{DefaultBranch: branch}
-			err = cache.SaveRepoData(key, c)
-			if err != nil {
-				msg.Debug("Error saving cache repo details: %s", err)
-			}
-		} else {
-			repo.Update()
-		}
-
-		tgs, err := repo.TagsFromCommit(id)
-		if err != nil {
-			msg.Debug("Problem getting tags for commit: %s", err)
-		}
-		cache.Unlock(key)
-		if len(tgs) > 0 {
-			return tgs[0]
-		}
-	}
-
-	return id
-}
-
-func findCurrentBranch(repo vcs.Repo) string {
-	msg.Debug("Attempting to find current branch for %s", repo.Remote())
-	// Svn and Bzr don't have default branches.
-	if repo.Vcs() == vcs.Svn || repo.Vcs() == vcs.Bzr {
-		return ""
-	}
-
-	if repo.Vcs() == vcs.Git || repo.Vcs() == vcs.Hg {
-		ver, err := repo.Current()
-		if err != nil {
-			msg.Debug("Unable to find current branch for %s, error: %s", repo.Remote(), err)
-			return ""
-		}
-		return ver
-	}
-
-	return ""
-}
-
-type versionCache struct {
-	sync.RWMutex
-	cache map[string]string
-	cd    map[string]bool
-}
-
-func newVersionCache() *versionCache {
-	return &versionCache{
-		cache: make(map[string]string),
-		cd:    make(map[string]bool),
-	}
-}
-
-func (v *versionCache) put(name, version string) {
-	v.Lock()
-	defer v.Unlock()
-	v.cache[name] = version
-	v.cd[name] = true
-}
-
-func (v *versionCache) checked(name string) bool {
-	v.RLock()
-	defer v.RUnlock()
-	return v.cd[name]
-}
-
-func (v *versionCache) touchChecked(name string) {
-	v.Lock()
-	defer v.Unlock()
-	v.cd[name] = true
-}
-
-func (v *versionCache) get(name string) string {
-	v.RLock()
-	defer v.RUnlock()
-	return v.cache[name]
-}
diff --git a/cache/memory.go b/cache/memory.go
new file mode 100644
index 0000000..ff2a0b8
--- /dev/null
+++ b/cache/memory.go
@@ -0,0 +1,137 @@
+package cache
+
+import (
+	"sync"
+
+	"github.com/Masterminds/glide/msg"
+	"github.com/Masterminds/semver"
+)
+
+// Provide an in memory cache of imported project information.
+
+var defaultMemCache = newMemCache()
+
+// MemPut put a version into the in memory cache for a name.
+// This will silently ignore non-semver and make sure the latest
+// is stored.
+func MemPut(name, version string) {
+	defaultMemCache.put(name, version)
+}
+
+// MemTouched returns true if the cache was touched for a name.
+func MemTouched(name string) bool {
+	return defaultMemCache.touched(name)
+}
+
+// MemTouch notes if a name has been looked at.
+func MemTouch(name string) {
+	defaultMemCache.touch(name)
+}
+
+// MemLatest returns the latest, that is most recent, semver release. This
+// may be a blank string if no put value
+func MemLatest(name string) string {
+	return defaultMemCache.getLatest(name)
+}
+
+// MemSetCurrent is used to set the current version in use.
+func MemSetCurrent(name, version string) {
+	defaultMemCache.setCurrent(name, version)
+}
+
+// MemCurrent is used to get the current version in use.
+func MemCurrent(name string) string {
+	return defaultMemCache.current(name)
+}
+
+// An in memory cache.
+type memCache struct {
+	sync.RWMutex
+	latest   map[string]string
+	t        map[string]bool
+	versions map[string][]string
+	c        map[string]string
+}
+
+func newMemCache() *memCache {
+	return &memCache{
+		latest:   make(map[string]string),
+		t:        make(map[string]bool),
+		versions: make(map[string][]string),
+		c:        make(map[string]string),
+	}
+}
+
+func (m *memCache) setCurrent(name, version string) {
+	m.Lock()
+	defer m.Unlock()
+
+	if m.c[name] == "" {
+		m.c[name] = version
+	} else {
+		// If we already have a version try to see if the new or old one is
+		// semver and use that one.
+		_, err := semver.NewVersion(m.c[name])
+		if err != nil {
+			_, err2 := semver.NewVersion(version)
+			if err2 == nil {
+				m.c[name] = version
+			}
+		}
+	}
+}
+
+func (m *memCache) current(name string) string {
+	m.RLock()
+	defer m.RUnlock()
+	return m.c[name]
+}
+
+func (m *memCache) put(name, version string) {
+	m.Lock()
+	defer m.Unlock()
+	m.t[name] = true
+	sv, err := semver.NewVersion(version)
+	if err != nil {
+		msg.Debug("Ignoring %s version %s: %s", name, version, err)
+		return
+	}
+
+	latest, found := m.latest[name]
+	if found {
+		lv, err := semver.NewVersion(latest)
+		if err != nil {
+			if sv.GreaterThan(lv) {
+				m.latest[name] = version
+			}
+		}
+	}
+
+	found = false
+	for _, v := range m.versions[name] {
+		if v == version {
+			found = true
+		}
+	}
+	if !found {
+		m.versions[name] = append(m.versions[name], version)
+	}
+}
+
+func (m *memCache) touch(name string) {
+	m.Lock()
+	defer m.Unlock()
+	m.t[name] = true
+}
+
+func (m *memCache) touched(name string) bool {
+	m.RLock()
+	defer m.RUnlock()
+	return m.t[name]
+}
+
+func (m *memCache) getLatest(name string) string {
+	m.RLock()
+	defer m.RUnlock()
+	return m.latest[name]
+}
diff --git a/glide.go b/glide.go
index 2e01e1c..5bd2894 100644
--- a/glide.go
+++ b/glide.go
@@ -154,13 +154,20 @@
 					Name:  "non-interactive",
 					Usage: "Disable interactive prompts.",
 				},
-				cli.BoolFlag{
-					Name:  "skip-version-suggestions",
-					Usage: "When imported commit ids are found that don't map to versions skip suggesting a version.",
-				},
 			},
 			Action: func(c *cli.Context) {
-				action.Create(".", c.Bool("skip-import"), c.Bool("non-interactive"), c.Bool("skip-version-suggestions"))
+				action.Create(".", c.Bool("skip-import"), c.Bool("non-interactive"))
+			},
+		},
+		{
+			Name:      "config-wizard",
+			ShortName: "cw",
+			Usage:     "Wizard that makes optional suggestions to improve config in a glide.yaml file.",
+			Description: `Glide will analyze a projects glide.yaml file and the imported
+		projects to find ways the glide.yaml file can potentially be improved. It
+		will then interactively make suggestions that you can skip or accept.`,
+			Action: func(c *cli.Context) {
+				action.ConfigWizard(".")
 			},
 		},
 		{
diff --git a/msg/msg.go b/msg/msg.go
index bb8b919..34213fd 100644
--- a/msg/msg.go
+++ b/msg/msg.go
@@ -287,3 +287,27 @@
 func PromptUntil(opts []string) (string, error) {
 	return Default.PromptUntil(opts)
 }
+
+// PromptUntilYorN provides a prompt until the user chooses yes or no. This is
+// not case sensitive and they can input other options such as Y or N.
+// In the response Yes is bool true and No is bool false.
+func (m *Messenger) PromptUntilYorN() bool {
+	res, err := m.PromptUntil([]string{"y", "yes", "n", "no"})
+	if err != nil {
+		m.Die("Error processing response: %s", err)
+	}
+
+	if res == "y" || res == "yes" {
+		return true
+	}
+
+	return false
+}
+
+// PromptUntilYorN provides a prompt until the user chooses yes or no. This is
+// not case sensitive and they can input other options such as Y or N.
+// In the response Yes is bool true and No is bool false.
+// Uses the default setup.
+func PromptUntilYorN() bool {
+	return Default.PromptUntilYorN()
+}