diff --git a/action/create.go b/action/create.go
index b66257c..fa72e6b 100644
--- a/action/create.go
+++ b/action/create.go
@@ -2,20 +2,31 @@
 
 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.
@@ -25,17 +36,21 @@
 // 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 bool) {
+func Create(base string, skipImport, noInteract, skipVerSug bool) {
 	glidefile := gpath.GlideFile
 	// Guard against overwrites.
 	guardYAML(glidefile)
 
 	// Guess deps
-	conf := guessDeps(base, skipImport)
+	conf := guessDeps(base, skipImport, noInteract, skipVerSug)
 	// Write YAML
+	msg.Info("Writing glide.yaml file")
 	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/")
 }
 
 // guardYAML fails if the given file already exists.
@@ -54,7 +69,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 bool) *cfg.Config {
+func guessDeps(base string, skipImport, noInteract, skipVerSug bool) *cfg.Config {
 	buildContext, err := util.GetBuildContext()
 	if err != nil {
 		msg.Die("Failed to build an import context: %s", err)
@@ -70,12 +85,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 {
-		guessImportDeps(base, config)
+		deps = guessImportDeps(base)
+		if len(deps) == 0 {
+			msg.Info("No dependencies found to import")
+		}
 	}
 
+	msg.Info("Scanning code to look for dependencies")
+
 	// Resolve dependencies by looking at the tree.
 	r, err := dependency.NewResolver(base)
 	if err != nil {
@@ -97,27 +118,76 @@
 		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 {
-			msg.Info("Found reference to %s\n", n)
-			d := &cfg.Dependency{
-				Name: root,
+			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)
 			}
-			if len(subpkg) > 0 {
-				d.Subpackages = []string{subpkg}
+
+			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)
 			}
+
 			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)
+					}
+				}
 			}
 		}
 	}
@@ -125,7 +195,117 @@
 	return config
 }
 
-func guessImportDeps(base string, config *cfg.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 {
 	msg.Info("Attempting to import from other package managers (use --skip-import to skip)")
 	deps := []*cfg.Dependency{}
 	absBase, err := filepath.Abs(base)
@@ -135,7 +315,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")
@@ -143,12 +323,41 @@
 	} 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
 	}
 
-	for _, i := range deps {
-		msg.Info("Found imported reference to %s\n", i.Name)
-		config.Imports = append(config.Imports, i)
+	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
+			}
+
+			msg.Debug("--> Found imported reference to %s at revision %s", dep.Name, dep.Reference)
+
+			wg.Done()
+		}(i)
+	}
+
+	wg.Wait()
+
+	return deps
 }
 
 func guessImportGodep(dir string) ([]*cfg.Dependency, bool) {
@@ -177,3 +386,165 @@
 
 	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/action/debug.go b/action/debug.go
index 7b8eea6..6af9d26 100644
--- a/action/debug.go
+++ b/action/debug.go
@@ -7,6 +7,15 @@
 // Debug sets the debugging flags across components.
 func Debug(on bool) {
 	msg.Default.IsDebugging = on
+
+	if on == true {
+		msg.Default.IsVerbose = on
+	}
+}
+
+// Verbose sets the verbose flags across components.
+func Verbose(on bool) {
+	msg.Default.IsVerbose = on
 }
 
 // Quiet sets the quiet flags across components.
diff --git a/gb/gb.go b/gb/gb.go
index 1f3b208..7837a42 100644
--- a/gb/gb.go
+++ b/gb/gb.go
@@ -26,6 +26,7 @@
 	}
 
 	msg.Info("Found GB manifest file in %s", gpath.StripBasepath(dir))
+	msg.Info("--> Parsing GB metadata...")
 	buf := []*cfg.Dependency{}
 	file, err := os.Open(path)
 	if err != nil {
diff --git a/glide.go b/glide.go
index 0e1e355..2e01e1c 100644
--- a/glide.go
+++ b/glide.go
@@ -92,8 +92,12 @@
 			Usage: "Quiet (no info or debug messages)",
 		},
 		cli.BoolFlag{
+			Name:  "verbose",
+			Usage: "Print detailed informational messages",
+		},
+		cli.BoolFlag{
 			Name:  "debug",
-			Usage: "Print Debug messages (verbose)",
+			Usage: "Print debug verbose informational messages",
 		},
 		cli.StringFlag{
 			Name:   "home",
@@ -146,9 +150,17 @@
 					Name:  "skip-import",
 					Usage: "When initializing skip importing from other package managers.",
 				},
+				cli.BoolFlag{
+					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"))
+				action.Create(".", c.Bool("skip-import"), c.Bool("non-interactive"), c.Bool("skip-version-suggestions"))
 			},
 		},
 		{
@@ -664,6 +676,7 @@
 // so it can be used by any Glide command.
 func startup(c *cli.Context) error {
 	action.Debug(c.Bool("debug"))
+	action.Verbose(c.Bool("verbose"))
 	action.NoColor(c.Bool("no-color"))
 	action.Quiet(c.Bool("quiet"))
 	action.Init(c.String("yaml"), c.String("home"))
diff --git a/godep/godep.go b/godep/godep.go
index a7d0525..71291b3 100644
--- a/godep/godep.go
+++ b/godep/godep.go
@@ -55,6 +55,7 @@
 		return []*cfg.Dependency{}, nil
 	}
 	msg.Info("Found Godeps.json file in %s", gpath.StripBasepath(dir))
+	msg.Info("--> Parsing Godeps metadata...")
 
 	buf := []*cfg.Dependency{}
 
diff --git a/gom/gom.go b/gom/gom.go
index 76305e4..51910b0 100644
--- a/gom/gom.go
+++ b/gom/gom.go
@@ -26,6 +26,7 @@
 	}
 
 	msg.Info("Found Gomfile in %s", gpath.StripBasepath(dir))
+	msg.Info("--> Parsing Gomfile metadata...")
 	buf := []*cfg.Dependency{}
 
 	goms, err := parseGomfile(path)
diff --git a/gpm/gpm.go b/gpm/gpm.go
index 45e316f..e58a81d 100644
--- a/gpm/gpm.go
+++ b/gpm/gpm.go
@@ -31,6 +31,7 @@
 		return []*cfg.Dependency{}, nil
 	}
 	msg.Info("Found Godeps file in %s", gpath.StripBasepath(dir))
+	msg.Info("--> Parsing GPM metadata...")
 
 	buf := []*cfg.Dependency{}
 
diff --git a/msg/msg.go b/msg/msg.go
index af49ecf..bb8b919 100644
--- a/msg/msg.go
+++ b/msg/msg.go
@@ -1,6 +1,7 @@
 package msg
 
 import (
+	"bufio"
 	"fmt"
 	"io"
 	"os"
@@ -16,9 +17,12 @@
 	// Quiet, if true, suppresses chatty levels, like Info.
 	Quiet bool
 
-	// IsDebugging, if true, shows verbose levels, like Debug.
+	// IsDebugging, if true, shows Debug.
 	IsDebugging bool
 
+	// IsVerbose, if true, shows detailed informational messages.
+	IsVerbose bool
+
 	// NoColor, if true, will not use color in the output.
 	NoColor bool
 
@@ -28,6 +32,9 @@
 	// Stderr is the location where this prints logs.
 	Stderr io.Writer
 
+	// Stdin is the location where input is read.
+	Stdin io.Reader
+
 	// PanicOnDie if true Die() will panic instead of exiting.
 	PanicOnDie bool
 
@@ -43,9 +50,11 @@
 	m := &Messenger{
 		Quiet:       false,
 		IsDebugging: false,
+		IsVerbose:   false,
 		NoColor:     false,
 		Stdout:      os.Stdout,
 		Stderr:      os.Stderr,
+		Stdin:       os.Stdin,
 		PanicOnDie:  false,
 		ecode:       1,
 	}
@@ -76,7 +85,7 @@
 		return
 	}
 	prefix := "[DEBUG]\t"
-	Msg(prefix+msg, args...)
+	m.Msg(prefix+msg, args...)
 }
 
 // Debug logs debug information using the Default Messenger
@@ -84,6 +93,19 @@
 	Default.Debug(msg, args...)
 }
 
+// Verbose logs detailed information
+func (m *Messenger) Verbose(msg string, args ...interface{}) {
+	if m.Quiet || !m.IsVerbose {
+		return
+	}
+	m.Info(msg, args...)
+}
+
+// Verbose detailed information using the Default Messenger
+func Verbose(msg string, args ...interface{}) {
+	Default.Verbose(msg, args...)
+}
+
 // Warn logs a warning
 func (m *Messenger) Warn(msg string, args ...interface{}) {
 	prefix := m.Color(Yellow, "[WARN]\t")
@@ -238,3 +260,30 @@
 func Color(code, msg string) string {
 	return Default.Color(code, msg)
 }
+
+// PromptUntil provides a prompt until one of the passed in strings has been
+// entered and return is hit. Note, the comparisons are case insensitive meaning
+// Y == y. The returned value is the one from the passed in options (same case).
+func (m *Messenger) PromptUntil(opts []string) (string, error) {
+	reader := bufio.NewReader(os.Stdin)
+	for {
+		text, err := reader.ReadString('\n')
+		if err != nil {
+			return "", err
+		}
+
+		for _, c := range opts {
+			if strings.EqualFold(c, strings.TrimSpace(text)) {
+				return c, nil
+			}
+		}
+	}
+}
+
+// PromptUntil provides a prompt until one of the passed in strings has been
+// entered and return is hit. Note, the comparisons are case insensitive meaning
+// Y == y. The returned value is the one from the passed in options (same case).
+// Uses the default setup.
+func PromptUntil(opts []string) (string, error) {
+	return Default.PromptUntil(opts)
+}