diff --git a/octodns/record/__init__.py b/octodns/record/__init__.py
index 21ab86f..ba5877f 100644
--- a/octodns/record/__init__.py
+++ b/octodns/record/__init__.py
@@ -9,6 +9,8 @@ from ipaddress import IPv4Address, IPv6Address
 from logging import getLogger
 import re
 
+from .geo import GeoCodes
+
 
 class Change(object):
 
@@ -563,11 +565,8 @@ class _DynamicMixin(object):
                                    .format(rule_num))
                 else:
                     for geo in geos:
-                        # TODO: ideally this would validate the actual code...
-                        match = cls.geo_re.match(geo)
-                        if not match:
-                            reasons.append('rule {} invalid geo "{}"'
-                                           .format(rule_num, geo))
+                        reasons.extend(GeoCodes.validate(geo, 'rule {} '
+                                                         .format(rule_num)))
 
         return reasons
 
diff --git a/octodns/record/geo.py b/octodns/record/geo.py
index 9a91c0e..c7b5468 100644
--- a/octodns/record/geo.py
+++ b/octodns/record/geo.py
@@ -9,7 +9,7 @@ class GeoCodes(object):
     __COUNTRIES = None
 
     @classmethod
-    def validate(cls, code):
+    def validate(cls, code, prefix):
         '''
         Validates an octoDNS geo code making sure that it is a valid and
         corresponding:
@@ -22,13 +22,14 @@ class GeoCodes(object):
         pieces = code.split('-')
         n = len(pieces)
         if n > 3:
-            reasons.append('Invalid geo code "{}"'.format(code))
+            reasons.append('{}invalid geo code "{}"'.format(prefix, code))
         elif n > 0 and pieces[0] not in geo_data:
-            reasons.append('Unknown continent code "{}"'.format(code))
+            reasons.append('{}unknown continent code "{}"'
+                           .format(prefix, code))
         elif n > 1 and pieces[1] not in geo_data[pieces[0]]:
-            reasons.append('Unknown country code "{}"'.format(code))
+            reasons.append('{}unknown country code "{}"'.format(prefix, code))
         elif n > 2 and \
                 pieces[2] not in geo_data[pieces[0]][pieces[1]]['provinces']:
-            reasons.append('Unknown province code "{}"'.format(code))
+            reasons.append('{}unknown province code "{}"'.format(prefix, code))
 
         return reasons
diff --git a/tests/test_octodns_record.py b/tests/test_octodns_record.py
index 8f64a30..6be334d 100644
--- a/tests/test_octodns_record.py
+++ b/tests/test_octodns_record.py
@@ -2863,7 +2863,7 @@ class TestDynamicRecords(TestCase):
         }
         with self.assertRaises(ValidationError) as ctx:
             Record.new(self.zone, 'bad', a_data)
-        self.assertEquals(['rule 1 invalid geo "invalid"'],
+        self.assertEquals(['rule 1 unknown continent code "invalid"'],
                           ctx.exception.reasons)
 
         # multiple default rules
diff --git a/tests/test_octodns_record_geo.py b/tests/test_octodns_record_geo.py
index 00e0bdc..6b9cd4e 100644
--- a/tests/test_octodns_record_geo.py
+++ b/tests/test_octodns_record_geo.py
@@ -13,39 +13,41 @@ from octodns.record.geo import GeoCodes
 class TestRecordGeoCodes(TestCase):
 
     def test_validate(self):
+        prefix = 'xyz '
+
         # All valid
-        self.assertEquals([], GeoCodes.validate('NA'))
-        self.assertEquals([], GeoCodes.validate('NA-US'))
-        self.assertEquals([], GeoCodes.validate('NA-US-OR'))
+        self.assertEquals([], GeoCodes.validate('NA', prefix))
+        self.assertEquals([], GeoCodes.validate('NA-US', prefix))
+        self.assertEquals([], GeoCodes.validate('NA-US-OR', prefix))
 
         # Just plain bad
-        self.assertEquals(['Invalid geo code "XX-YY-ZZ-AA"'],
-                          GeoCodes.validate('XX-YY-ZZ-AA'))
-        self.assertEquals(['Unknown continent code "X-Y-Z"'],
-                          GeoCodes.validate('X-Y-Z'))
-        self.assertEquals(['Unknown continent code "XXX-Y-Z"'],
-                          GeoCodes.validate('XXX-Y-Z'))
+        self.assertEquals(['xyz invalid geo code "XX-YY-ZZ-AA"'],
+                          GeoCodes.validate('XX-YY-ZZ-AA', prefix))
+        self.assertEquals(['xyz unknown continent code "X-Y-Z"'],
+                          GeoCodes.validate('X-Y-Z', prefix))
+        self.assertEquals(['xyz unknown continent code "XXX-Y-Z"'],
+                          GeoCodes.validate('XXX-Y-Z', prefix))
 
         # Bad continent
-        self.assertEquals(['Unknown continent code "XX"'],
-                          GeoCodes.validate('XX'))
+        self.assertEquals(['xyz unknown continent code "XX"'],
+                          GeoCodes.validate('XX', prefix))
         # Bad continent good country
-        self.assertEquals(['Unknown continent code "XX-US"'],
-                          GeoCodes.validate('XX-US'))
+        self.assertEquals(['xyz unknown continent code "XX-US"'],
+                          GeoCodes.validate('XX-US', prefix))
         # Bad continent good country and province
-        self.assertEquals(['Unknown continent code "XX-US-OR"'],
-                          GeoCodes.validate('XX-US-OR'))
+        self.assertEquals(['xyz unknown continent code "XX-US-OR"'],
+                          GeoCodes.validate('XX-US-OR', prefix))
 
         # Bad country, good continent
-        self.assertEquals(['Unknown country code "NA-XX"'],
-                          GeoCodes.validate('NA-XX'))
+        self.assertEquals(['xyz unknown country code "NA-XX"'],
+                          GeoCodes.validate('NA-XX', prefix))
         # Bad country, good continent and state
-        self.assertEquals(['Unknown country code "NA-XX-OR"'],
-                          GeoCodes.validate('NA-XX-OR'))
+        self.assertEquals(['xyz unknown country code "NA-XX-OR"'],
+                          GeoCodes.validate('NA-XX-OR', prefix))
         # Good country, good continent, but bad match
-        self.assertEquals(['Unknown country code "NA-GB"'],
-                          GeoCodes.validate('NA-GB'))
+        self.assertEquals(['xyz unknown country code "NA-GB"'],
+                          GeoCodes.validate('NA-GB', prefix))
 
         # Bad province code, good continent and country
-        self.assertEquals(['Unknown province code "NA-US-XX"'],
-                          GeoCodes.validate('NA-US-XX'))
+        self.assertEquals(['xyz unknown province code "NA-US-XX"'],
+                          GeoCodes.validate('NA-US-XX', prefix))