diff --git a/tape/dynamic.go b/tape/dynamic.go
index 73a1e10..dd89055 100644
--- a/tape/dynamic.go
+++ b/tape/dynamic.go
@@ -12,6 +12,7 @@ import "fmt"
 import "reflect"
 
 var dummyMap map[uint16] any
+var dummyBuffer []byte
 
 // EncodeAny encodes an "any" value. Returns an error if the underlying type is
 // unsupported. Supported types are:
@@ -24,26 +25,27 @@ var dummyMap map[uint16] any
 //   - []<supported type>
 //   - map[uint16]<supported type>
 func EncodeAny(encoder *Encoder, value any, tag Tag) (n int, err error) {
-	// TODO use reflection for all of this to ignore type names
 	// primitives
-	switch value := value.(type) {
-	case int:    return encoder.WriteInt32(int32(value))
-	case uint:   return encoder.WriteUint32(uint32(value))
-	case int8:   return encoder.WriteInt8(value)
-	case uint8:  return encoder.WriteUint8(value)
-	case int16:  return encoder.WriteInt16(value)
-	case uint16: return encoder.WriteUint16(value)
-	case int32:  return encoder.WriteInt32(value)
-	case uint32: return encoder.WriteUint32(value)
-	case int64:  return encoder.WriteInt64(value)
-	case uint64: return encoder.WriteUint64(value)
-	case string: return EncodeAny(encoder, []byte(value), tag)
-	case []byte:
+	reflectValue := reflect.ValueOf(value)
+	switch reflectValue.Kind() {
+	case reflect.Int:    return encoder.WriteInt32(int32(reflectValue.Int()))
+	case reflect.Uint:   return encoder.WriteUint32(uint32(reflectValue.Uint()))
+	case reflect.Int8:   return encoder.WriteInt8(int8(reflectValue.Int()))
+	case reflect.Uint8:  return encoder.WriteUint8(uint8(reflectValue.Uint()))
+	case reflect.Int16:  return encoder.WriteInt16(int16(reflectValue.Int()))
+	case reflect.Uint16: return encoder.WriteUint16(uint16(reflectValue.Uint()))
+	case reflect.Int32:  return encoder.WriteInt32(int32(reflectValue.Int()))
+	case reflect.Uint32: return encoder.WriteUint32(uint32(reflectValue.Uint()))
+	case reflect.Int64:  return encoder.WriteInt64(int64(reflectValue.Int()))
+	case reflect.Uint64: return encoder.WriteUint64(uint64(reflectValue.Uint()))
+	case reflect.String: return EncodeAny(encoder, []byte(reflectValue.String()), tag)
+	}
+	if reflectValue.CanConvert(reflect.TypeOf(dummyBuffer)) {
 		if tag.Is(LBA) {
-			nn, err := encoder.WriteUintN(uint64(len(value)), tag.CN() + 1)
+			nn, err := encoder.WriteUintN(uint64(reflectValue.Len()), tag.CN() + 1)
 			n += nn; if err != nil { return n, err }
 		}
-		nn, err := encoder.Write(value)
+		nn, err := encoder.Write(reflectValue.Bytes())
 		n += nn; if err != nil { return n, err }
 		return n, nil
 	}