diff --git a/cfg/config.go b/cfg/config.go
index 3b46764..f0e1248 100644
--- a/cfg/config.go
+++ b/cfg/config.go
@@ -7,6 +7,7 @@
 	"io/ioutil"
 	"reflect"
 	"sort"
+	"strconv"
 	"strings"
 
 	"github.com/Masterminds/vcs"
@@ -45,8 +46,15 @@
 
 	// Imports contains a list of all dependency constraints for a project. For
 	// more detail on how these are captured see the Dependency type.
+	// TODO rename
+	// TODO mapify
 	Imports Dependencies `yaml:"dependencies"`
 
+	// DevImports contains the test or other development dependency constraints
+	// for a project. See the Dependency type for more details on how this is
+	// recorded.
+	// TODO rename
+	// TODO mapify
 	DevImports Dependencies `yaml:"testDependencies"`
 }
 
@@ -58,22 +66,27 @@
 	License     string       `yaml:"license,omitempty"`
 	Owners      Owners       `yaml:"owners,omitempty"`
 	Ignore      []string     `yaml:"ignore,omitempty"`
-	Imports     Dependencies `yaml:"dependencies"`
+	Imports     Dependencies `yaml:"dependencies,omitempty"`
 	DevImports  Dependencies `yaml:"testDependencies,omitempty"`
+	// used to guarantee that this wil fail on unmarshaling legacy yamls
+	Compat  int `yaml:"import,omitempty"`
+	Compat2 int `yaml:"testImport,omitempty"`
 }
 
 // ConfigFromYaml returns an instance of Config from YAML
-func ConfigFromYaml(yml []byte) (*Config, bool, error) {
-	cfg := &Config{}
-	err := yaml.Unmarshal([]byte(yml), &cfg)
+func ConfigFromYaml(yml []byte) (cfg *Config, legacy bool, err error) {
+	cfg = &Config{}
+	err = yaml.Unmarshal(yml, cfg)
 	if err != nil {
 		lcfg := &lConfig1{}
-		err = yaml.Unmarshal([]byte(yml), &lcfg)
-		if err != nil {
-			// TODO(sdboyer) convert to new form, then return
+		err = yaml.Unmarshal(yml, &lcfg)
+		if err == nil {
+			legacy = true
+			cfg, err = lcfg.Convert()
 		}
 	}
-	return cfg, false, err
+
+	return
 }
 
 // Marshal converts a Config instance to YAML
@@ -404,7 +417,7 @@
 // A transitive representation of a dependency for yaml import/export.
 type dep struct {
 	Name       string   `yaml:"package"`
-	Reference  string   `yaml:"version,omitempty"`
+	Reference  string   `yaml:"version,omitempty"` // TODO rename
 	Branch     string   `yaml:"branch,omitempty"`
 	Repository string   `yaml:"repo,omitempty"`
 	Arch       []string `yaml:"arch,omitempty"`
@@ -473,6 +486,45 @@
 	return nil
 }
 
+// deduceConstraint tries to puzzle out what kind of version is given in a string -
+// semver, a revision, or as a fallback, a plain tag
+func deduceConstraint(s string) gps.Constraint {
+	// always semver if we can
+	c, err := gps.NewSemverConstraint(s)
+	if err == nil {
+		return c
+	}
+
+	if len(s) == 40 {
+		if _, err = hex.DecodeString(s); err == nil {
+			// Whether or not it's intended to be a SHA1 digest, this is a
+			// valid byte sequence for that, so go with Revision. This
+			// covers git and hg
+			return gps.Revision(s)
+		}
+	}
+	// Next, try for bzr, which has a three-component GUID separated by
+	// dashes. There should be two, but the email part could contain
+	// internal dashes
+	if strings.Count(s, "-") >= 2 {
+		// Work from the back to avoid potential confusion from the email
+		i3 := strings.LastIndex(s, "-")
+		if _, err = hex.DecodeString(s[i3:]); err == nil {
+			i2 := strings.LastIndex(s[:i3], "-")
+			if _, err = strconv.ParseUint(s[i2:i3], 10, 64); err != nil {
+				// Getting this far means it'd pretty much be nuts if it's not a
+				// bzr rev, so don't bother parsing the email.
+				return gps.Revision(s)
+			}
+		}
+	}
+
+	// If not a plain SHA1 or bzr custom GUID, assume a plain version.
+	//
+	// svn, you ask? lol, madame. lol.
+	return gps.NewVersion(s)
+}
+
 // MarshalYAML is a hook for gopkg.in/yaml.v2 in the marshaling process
 func (d *Dependency) MarshalYAML() (interface{}, error) {
 	newDep := &dep{
diff --git a/cfg/config_test.go b/cfg/config_test.go
index 58e0904..db563dd 100644
--- a/cfg/config_test.go
+++ b/cfg/config_test.go
@@ -37,6 +37,7 @@
       - i386
       - arm
   - package: github.com/Masterminds/structable
+    version: v1.0.0
   - package: github.com/Masterminds/cookoo/color
   - package: github.com/Masterminds/cookoo/convert
 
@@ -238,6 +239,58 @@
 	}
 }
 
+func TestLegacyConfigAutoconvert(t *testing.T) {
+	c, leg, err := ConfigFromYaml([]byte(lyml))
+	if err != nil {
+		t.Errorf("ConfigFromYaml failed to detect and autoconvert legacy yaml file with err %s", err)
+	}
+
+	if !leg {
+		t.Errorf("ConfigFromYaml failed to report autoconversion of legacy yaml file")
+	}
+
+	if c.Name != "fake/testing" {
+		t.Error("ConfigFromYaml failed to properly autoconvert legacy yaml file")
+	}
+
+	// Two should survive the conversion
+	if len(c.Imports) != 2 {
+		t.Error("Expected two dep clauses to survive conversion, but got ", len(c.Imports))
+	}
+
+	found := false
+	found2 := false
+	for _, i := range c.Imports {
+		if i.Name == "github.com/Masterminds/convert" {
+			found = true
+			ref := gps.Revision("a9949121a2e2192ca92fa6dddfeaaa4a4412d955")
+			if i.Constraint != ref {
+				t.Errorf("(%s) Expected %q for constraint, got %q", i.Name, ref, i.Constraint)
+			}
+
+			repo := "git@github.com:Masterminds/convert.git"
+			if i.Repository != repo {
+				t.Errorf("(%s) Expected %q for repository, got %q", i.Name, repo, i.Repository)
+			}
+		}
+
+		if i.Name == "github.com/Masterminds/structable" {
+			found2 = true
+			ref := gps.NewVersion("v1.0.0")
+			if i.Constraint != ref {
+				t.Errorf("(%s) Expected %q for constraint, got %q", i.Name, ref, i.Constraint)
+			}
+		}
+	}
+	if !found {
+		t.Error("Unable to find github.com/Masterminds/convert")
+	}
+	if !found2 {
+		t.Error("Unable to find github.com/Masterminds/structable")
+	}
+
+}
+
 func TestConfigFromYaml(t *testing.T) {
 	c, _, err := ConfigFromYaml([]byte(yml))
 	if err != nil {
@@ -255,7 +308,7 @@
 		t.Error("ConfigFromYaml failed to parse yaml for HasDependency")
 	}
 
-	if c.HasDependency("github.com/Masterminds/convert") != true {
+	if !c.HasDependency("github.com/Masterminds/convert") {
 		t.Error("HasDependency failing to pickup depenency")
 	}
 
diff --git a/cfg/legacy.go b/cfg/legacy.go
index 4cf294d..3c78703 100644
--- a/cfg/legacy.go
+++ b/cfg/legacy.go
@@ -2,6 +2,7 @@
 
 import (
 	"fmt"
+	"path"
 	"reflect"
 	"strings"
 
@@ -42,9 +43,54 @@
 	return err
 }
 
+func (c *lConfig1) Convert() (*Config, error) {
+	// This is probably already done, but do it just in case
+	err := c.DeDupe()
+	if err != nil {
+		return nil, err
+	}
+
+	// Pull over the easy values
+	c2 := &Config{
+		Name:        c.Name,
+		Description: c.Description,
+		Home:        c.Home,
+		License:     c.License,
+		Owners:      c.Owners,
+		Ignore:      c.Ignore,
+	}
+
+	// _if_ the name is set, path-prepend it to exclude, and add that to ignore.
+	// Otherwise, we just skip excludes. Not that big a deal, since they're a
+	// root-only property anyway; the user can reasonably recreate.
+
+	if c.Name != "" {
+		for _, excl := range c.Exclude {
+			c.Ignore = append(c.Ignore, path.Join(c.Name, excl))
+			// The trailing * is interpreted by gps as an ignore on that and all
+			// child paths (or, soon - https://github.com/sdboyer/gps/issues/88)
+			c.Ignore = append(c.Ignore, path.Join(c.Name, excl, "*"))
+		}
+	}
+
+	// Quitting early on this might seem risky, but a) all possible errs
+	// _should_ have already been surfaced in the earlier DeDupe(), and b) there
+	// are no new errs introduced by the conversion itself, so this doesn't
+	// actually increase the surface area for failures vis-a-vis pre-gps glide.
+	c2.Imports, err = c.Imports.Convert()
+	if err != nil {
+		return nil, err
+	}
+	c2.DevImports, err = c.DevImports.Convert()
+	if err != nil {
+		return nil, err
+	}
+
+	return c2, nil
+}
+
 // DeDupe consolidates duplicate dependencies on a Config instance
 func (c *lConfig1) DeDupe() error {
-
 	// Remove duplicates in the imports
 	var err error
 	c.Imports, err = c.Imports.DeDupe()
@@ -118,6 +164,35 @@
 
 type lDependencies1 []*lDependency1
 
+func (ds lDependencies1) Convert() (Dependencies, error) {
+	dds, err := ds.DeDupe()
+	if err != nil {
+		return nil, err
+	}
+
+	var ds2 Dependencies
+	for _, d := range dds {
+		// If we have neither a repo nor a reference, then it's pointless to
+		// include this dep in the list (it will add no information to gps)
+		if d.Repository == "" && d.Reference == "" {
+			continue
+		}
+
+		d2 := &Dependency{
+			Name:       d.Name,
+			Repository: d.Repository,
+		}
+
+		d2.Constraint = deduceConstraint(d.Reference)
+		// TODO(sdboyer) if the above result is a plain version, the old
+		// semantics are ambiguous wrt if the user wants a branch or tag. Check
+		// the version list (via source manager) to convert most sanely?
+		ds2 = append(ds2, d2)
+	}
+
+	return ds2, nil
+}
+
 type lDependency1 struct {
 	Name        string   `yaml:"package"`
 	Reference   string   `yaml:"version,omitempty"`
@@ -129,7 +204,7 @@
 	Os          []string `yaml:"os,omitempty"`
 }
 
-// Legacy unmarshaler
+// Legacy unmarshaler for dependency component of yaml files
 func (d *lDependency1) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	newDep := &ldep1{}
 	err := unmarshal(&newDep)