diff --git a/json_serialization/format.nim b/json_serialization/format.nim
index 9270dbd..ac31f20 100644
--- a/json_serialization/format.nim
+++ b/json_serialization/format.nim
@@ -106,7 +106,8 @@ template createJsonFlavor*(FlavorName: untyped,
                            requireAllFields = true,
                            omitOptionalFields = true,
                            allowUnknownFields = true,
-                           skipNullFields = false) {.dirty.} =
+                           skipNullFields = false,
+                           automaticPrimitivesSerialization = true) {.dirty.} =
   when declared(SerializationFormat): # Earlier versions lack mimeTypeValue
     createFlavor(Json, FlavorName, mimeTypeValue)
   else:
@@ -137,5 +138,4 @@ template createJsonFlavor*(FlavorName: untyped,
     # Set default to true for backward compatibility
     # but user can call it again later with different value.
     # Or fine tuning use `Flavor.automaticSerialization(type, true/false)`
-    FlavorName.automaticBuiltinSerialization(true)
-
+    FlavorName.automaticBuiltinSerialization(automaticPrimitivesSerialization)
diff --git a/json_serialization/reader_impl.nim b/json_serialization/reader_impl.nim
index e4a017a..003917d 100644
--- a/json_serialization/reader_impl.nim
+++ b/json_serialization/reader_impl.nim
@@ -225,22 +225,66 @@ proc readRecordValue*[T](r: var JsonReader, value: var T)
       else:
         r.raiseUnexpectedField(key, cstring typeName)
 
-template autoSerializeCheck(F: distinct type, T: distinct type) =
+template autoSerializeCheck(F: distinct type, T: distinct type, body) =
   when declared(macrocache.hasKey): # Nim 1.6 have no macrocache.hasKey
     mixin typeAutoSerialize
     when not F.typeAutoSerialize(T):
-      const typeName = typetraits.name(T)
-      {.error: "automatic serialization is not enabled or readValue not implemented for `" &
+      const
+        typeName = typetraits.name(T)
+        flavorName = typetraits.name(F)
+      {.error: flavorName &
+        ": automatic serialization is not enabled or readValue not implemented for `" &
         typeName & "`".}
+    else:
+      body
+  else:
+    body
 
-template autoSerializeCheck(F: distinct type, TC: distinct type, M: distinct type) =
+template autoSerializeCheck(F: distinct type, TC: distinct type, M: distinct type, body) =
   when declared(macrocache.hasKey): # Nim 1.6 have no macrocache.hasKey
     mixin typeClassOrMemberAutoSerialize
     when not F.typeClassOrMemberAutoSerialize(TC, M):
-      const typeName = typetraits.name(M)
-      const typeClassName = typetraits.name(TC)
-      {.error: "automatic serialization is not enabled or readValue not implemented for `" &
+      const
+        typeName = typetraits.name(M)
+        typeClassName = typetraits.name(TC)
+        flavorName = typetraits.name(F)
+      {.error: flavorName  &
+        ": automatic serialization is not enabled or readValue not implemented for `" &
         typeName & "` of typeclass `" & typeClassName & "`".}
+    else:
+      body
+  else:
+    body
+
+template readValueRefOrPtr(r, value) =
+  mixin readValue
+  when compiles(isNotNilCheck(value)):
+    allocPtr value
+    value[] = readValue(r, type(value[]))
+  else:
+    if r.tokKind == JsonValueKind.Null:
+      value = nil
+      r.parseNull()
+    else:
+      allocPtr value
+      value[] = readValue(r, type(value[]))
+
+template readValueObjectOrTuple(Flavor, r, value) =
+  mixin flavorUsesAutomaticObjectSerialization
+
+  const isAutomatic =
+    flavorUsesAutomaticObjectSerialization(Flavor)
+
+  when not isAutomatic:
+    const
+      flavor =
+        "JsonReader[" & typetraits.name(typeof(r).Flavor) & "], " &
+        typetraits.name(T)
+    {.error:
+      "Missing Json serialization import or implementation for readValue(" &
+      flavor & ")".}
+
+  readRecordValue(r, value)
 
 proc readValue*[T](r: var JsonReader, value: var T)
                   {.raises: [SerializationError, IOError].} =
@@ -261,129 +305,110 @@ proc readValue*[T](r: var JsonReader, value: var T)
   type Flavor = JsonReader.Flavor
 
   when value is JsonString:
-    autoSerializeCheck(Flavor, JsonString)
-    value = r.parseAsString()
+    autoSerializeCheck(Flavor, JsonString):
+      value = r.parseAsString()
 
   elif value is JsonNode:
-    autoSerializeCheck(Flavor, JsonNode)
-    value = r.parseJsonNode()
+    autoSerializeCheck(Flavor, JsonNode):
+      value = r.parseJsonNode()
 
   elif value is JsonNumber:
-    autoSerializeCheck(Flavor, JsonNumber)
-    r.parseNumber(value)
+    autoSerializeCheck(Flavor, JsonNumber):
+      r.parseNumber(value)
 
   elif value is JsonVoid:
-    autoSerializeCheck(Flavor, JsonVoid)
-    r.skipSingleJsValue()
+    autoSerializeCheck(Flavor, JsonVoid):
+      r.skipSingleJsValue()
 
   elif value is JsonValueRef:
-    autoSerializeCheck(Flavor, JsonValueRef)
-    r.parseValue(value)
+    autoSerializeCheck(Flavor, JsonValueRef):
+      r.parseValue(value)
 
   elif value is string:
-    autoSerializeCheck(Flavor, string)
-    value = r.parseString()
+    autoSerializeCheck(Flavor, string):
+      value = r.parseString()
 
   elif value is seq[char]:
-    autoSerializeCheck(Flavor, seq[char])
-    let val = r.parseString()
-    value.setLen(val.len)
-    for i in 0..<val.len:
-      value[i] = val[i]
+    autoSerializeCheck(Flavor, seq[char]):
+      let val = r.parseString()
+      value.setLen(val.len)
+      for i in 0..<val.len:
+        value[i] = val[i]
 
   elif isCharArray(value):
-    autoSerializeCheck(Flavor, array, typeof(value))
-    let val = r.parseString()
-    if val.len != value.len:
-      # Raise tkString because we expected a `"` earlier
-      r.raiseUnexpectedToken(etString)
-    for i in 0..<value.len:
-      value[i] = val[i]
+    autoSerializeCheck(Flavor, array, typeof(value)):
+      let val = r.parseString()
+      if val.len != value.len:
+        # Raise tkString because we expected a `"` earlier
+        r.raiseUnexpectedToken(etString)
+      for i in 0..<value.len:
+        value[i] = val[i]
 
   elif value is bool:
-    autoSerializeCheck(Flavor, bool)
-    value = r.parseBool()
+    autoSerializeCheck(Flavor, bool):
+      value = r.parseBool()
 
-  elif value is ref|ptr:
-    when value is ref:
-      autoSerializeCheck(Flavor, ref, typeof(value))
+  elif value is ref:
+    autoSerializeCheck(Flavor, ref, typeof(value)):
+      readValueRefOrPtr(r, value)
 
-    when value is ptr:
-      autoSerializeCheck(Flavor, ptr, typeof(value))
-
-    when compiles(isNotNilCheck(value)):
-      allocPtr value
-      value[] = readValue(r, type(value[]))
-    else:
-      if r.tokKind == JsonValueKind.Null:
-        value = nil
-        r.parseNull()
-      else:
-        allocPtr value
-        value[] = readValue(r, type(value[]))
+  elif value is ptr:
+    autoSerializeCheck(Flavor, ptr, typeof(value)):
+      readValueRefOrPtr(r, value)
 
   elif value is enum:
-    autoSerializeCheck(Flavor, enum, typeof(value))
-    r.parseEnum(value)
+    autoSerializeCheck(Flavor, enum, typeof(value)):
+      r.parseEnum(value)
 
   elif value is SomeInteger:
-    autoSerializeCheck(Flavor, SomeInteger, typeof(value))
-    value = r.parseInt(typeof value,
-      JsonReaderFlag.portableInt in r.lex.flags)
+    autoSerializeCheck(Flavor, SomeInteger, typeof(value)):
+      value = r.parseInt(typeof value,
+        JsonReaderFlag.portableInt in r.lex.flags)
 
   elif value is SomeFloat:
-    autoSerializeCheck(Flavor, SomeFloat, typeof(value))
-    let val = r.parseNumber(uint64)
-    if val.isFloat:
-      value = r.toFloat(val, typeof value)
-    else:
-      value = T(val.integer)
+    autoSerializeCheck(Flavor, SomeFloat, typeof(value)):
+      let val = r.parseNumber(uint64)
+      if val.isFloat:
+        value = r.toFloat(val, typeof value)
+      else:
+        value = T(val.integer)
 
   elif value is seq:
-    autoSerializeCheck(Flavor, seq, typeof(value))
-    r.parseArray:
-      let lastPos = value.len
-      value.setLen(lastPos + 1)
-      readValue(r, value[lastPos])
+    autoSerializeCheck(Flavor, seq, typeof(value)):
+      r.parseArray:
+        let lastPos = value.len
+        value.setLen(lastPos + 1)
+        readValue(r, value[lastPos])
 
   elif value is array:
-    autoSerializeCheck(Flavor, array, typeof(value))
-    type IDX = typeof low(value)
-    r.parseArray(idx):
-      if idx < value.len:
-        let i = IDX(idx + low(value).int)
-        readValue(r, value[i])
-      else:
-        r.raiseUnexpectedValue("Too many items for " & $(typeof(value)))
-
-  elif value is (object or tuple):
-    when declared(macrocache.hasKey): # Nim 1.6 have no macrocache.hasKey
-      when value is object:
-        autoSerializeCheck(Flavor, object, typeof(value))
-
-      when value is tuple:
-        autoSerializeCheck(Flavor, tuple, typeof(value))
-
-    # Keep existing object/tuple auto serialization
-    # But make it deprecated.
-    mixin flavorUsesAutomaticObjectSerialization
+    autoSerializeCheck(Flavor, array, typeof(value)):
+      type IDX = typeof low(value)
+      r.parseArray(idx):
+        if idx < value.len:
+          let i = IDX(idx + low(value).int)
+          readValue(r, value[i])
+        else:
+          r.raiseUnexpectedValue("Too many items for " & $(typeof(value)))
+
+  elif value is object:
+    when declared(macrocache.hasKey): # Nim 1.6 have no macrocache.hasKey and cannot accept `object` param
+      autoSerializeCheck(Flavor, object, typeof(value)):
+        readValueObjectOrTuple(Flavor, r, value)
+    else:
+      readValueObjectOrTuple(Flavor, r, value)
 
-    const isAutomatic =
-      flavorUsesAutomaticObjectSerialization(Flavor)
+  elif value is tuple:
+    when declared(macrocache.hasKey): # Nim 1.6 have no macrocache.hasKey and cannot accept `tuple` param
+      autoSerializeCheck(Flavor, tuple, typeof(value)):
+        readValueObjectOrTuple(Flavor, r, value)
+    else:
+      readValueObjectOrTuple(Flavor, r, value)
 
-    when not isAutomatic:
-      const
-        flavor =
-          "JsonReader[" & typetraits.name(typeof(r).Flavor) & "], " &
-          typetraits.name(T)
-      {.error:
-        "Missing Json serialization import or implementation for readValue(" &
-        flavor & ")".}
-
-    readRecordValue(r, value)
   else:
-    const typeName = typetraits.name(T)
-    {.error: "Failed to convert to JSON an unsupported type: " &
+    const
+      typeName = typetraits.name(T)
+      flavorName = typetraits.name(Flavor)
+    {.error: flavorName & ": Failed to convert from JSON an unsupported type: " &
       typeName.}
 
 iterator readObjectFields*(r: var JsonReader): string {.
diff --git a/json_serialization/writer.nim b/json_serialization/writer.nim
index 33719f6..451f816 100644
--- a/json_serialization/writer.nim
+++ b/json_serialization/writer.nim
@@ -384,25 +384,86 @@ type
   StringLikeTypes = string|cstring|openArray[char]|seq[char]
 
 template isStringLike(v: StringLikeTypes): bool = true
-template isStringLike[N](v: array[N, char]): bool = true
 template isStringLike(v: auto): bool = false
 
-template autoSerializeCheck(F: distinct type, T: distinct type) =
+template isStringLikeArray[N](v: array[N, char]): bool = true
+template isStringLikeArray(v: auto): bool = false
+
+template autoSerializeCheck(F: distinct type, T: distinct type, body) =
   when declared(macrocache.hasKey): # Nim 1.6 have no macrocache.hasKey
     mixin typeAutoSerialize
     when not F.typeAutoSerialize(T):
-      const typeName = typetraits.name(T)
-      {.error: "automatic serialization is not enabled or writeValue not implemented for `" &
+      const
+        typeName = typetraits.name(T)
+        flavorName = typetraits.name(F)
+      {.error: flavorName &
+        ": automatic serialization is not enabled or writeValue not implemented for `" &
         typeName & "`".}
+    else:
+      body
+  else:
+    body
 
-template autoSerializeCheck(F: distinct type, TC: distinct type, M: distinct type) =
+template autoSerializeCheck(F: distinct type, TC: distinct type, M: distinct type, body) =
   when declared(macrocache.hasKey): # Nim 1.6 have no macrocache.hasKey
     mixin typeClassOrMemberAutoSerialize
     when not F.typeClassOrMemberAutoSerialize(TC, M):
-      const typeName = typetraits.name(M)
-      const typeClassName = typetraits.name(TC)
-      {.error: "automatic serialization is not enabled or writeValue not implemented for `" &
+      const
+        typeName = typetraits.name(M)
+        typeClassName = typetraits.name(TC)
+        flavorName = typetraits.name(F)
+      {.error: flavorName &
+        ": automatic serialization is not enabled or writeValue not implemented for `" &
         typeName & "` of typeclass `" & typeClassName & "`".}
+    else:
+      body
+  else:
+    body
+
+template writeValueObjectOrTuple(Flavor, w, value) =
+  mixin flavorUsesAutomaticObjectSerialization
+
+  const isAutomatic =
+    flavorUsesAutomaticObjectSerialization(Flavor)
+
+  when not isAutomatic:
+    const typeName = typetraits.name(type value)
+    {.error: "Please override writeValue for the " & typeName & " type (or import the module where the override is provided)".}
+
+  when value is distinct:
+    writeRecordValue(w, distinctBase(value, recursive = false))
+  else:
+    writeRecordValue(w, value)
+
+template writeValueStringLike(w, value) =
+  w.streamElement(s):
+    when value is cstring:
+      if value == nil:
+        s.write "null"
+        return
+
+    s.write '"'
+
+    template addPrefixSlash(c) =
+      s.write '\\'
+      s.write c
+    const hexChars = "0123456789abcde"
+    for c in value:
+      case c
+      of '\b': addPrefixSlash 'b' # \x08
+      of '\t': addPrefixSlash 't' # \x09
+      of '\n': addPrefixSlash 'n' # \x0a
+      of '\f': addPrefixSlash 'f' # \x0c
+      of '\r': addPrefixSlash 'r' # \x0d
+      of '"' : addPrefixSlash '\"'
+      of '\x00'..'\x07', '\x0b', '\x0e'..'\x1f':
+        s.write "\\u00"
+        s.write hexChars[(uint8(c) shr 4) and 0x0f]
+        s.write hexChars[uint8(c) and 0x0f]
+
+      else: s.write c
+
+    s.write '"'
 
 proc writeValue*[V: not void](w: var JsonWriter, value: V) {.raises: [IOError].} =
   ## Write a generic value as JSON, using type-based dispatch. Overload this
@@ -412,125 +473,104 @@ proc writeValue*[V: not void](w: var JsonWriter, value: V) {.raises: [IOError].}
   type Flavor = JsonWriter.Flavor
 
   when value is JsonNode:
-    autoSerializeCheck(Flavor, JsonNode)
-    w.streamElement(s):
-      s.write if w.hasPrettyOutput: value.pretty
-              else: $value
+    autoSerializeCheck(Flavor, JsonNode):
+      w.streamElement(s):
+        s.write if w.hasPrettyOutput: value.pretty
+                else: $value
 
   elif value is JsonString:
-    autoSerializeCheck(Flavor, JsonString)
-    w.streamElement(s):
-      s.write $value
+    autoSerializeCheck(Flavor, JsonString):
+      w.streamElement(s):
+        s.write $value
 
   elif value is JsonVoid:
-    autoSerializeCheck(Flavor, JsonVoid)
-    discard
+    autoSerializeCheck(Flavor, JsonVoid):
+      discard
 
   elif value is ref:
-    autoSerializeCheck(Flavor, ref, typeof(value))
-    if value.isNil:
-      w.streamElement(s):
-        s.write "null"
-    else:
-      writeValue(w, value[])
+    autoSerializeCheck(Flavor, ref, typeof(value)):
+      if value.isNil:
+        w.streamElement(s):
+          s.write "null"
+      else:
+        writeValue(w, value[])
 
   elif isStringLike(value):
-    when value isnot array:
-      autoSerializeCheck(Flavor, StringLikeTypes, typeof(value))
-    when value is array:
-      autoSerializeCheck(Flavor, array, typeof(value))
-    w.streamElement(s):
-      when value is cstring:
-        if value == nil:
-          s.write "null"
-          return
-
-      s.write '"'
-
-      template addPrefixSlash(c) =
-        s.write '\\'
-        s.write c
-      const hexChars = "0123456789abcde"
-      for c in value:
-        case c
-        of '\b': addPrefixSlash 'b' # \x08
-        of '\t': addPrefixSlash 't' # \x09
-        of '\n': addPrefixSlash 'n' # \x0a
-        of '\f': addPrefixSlash 'f' # \x0c
-        of '\r': addPrefixSlash 'r' # \x0d
-        of '"' : addPrefixSlash '\"'
-        of '\x00'..'\x07', '\x0b', '\x0e'..'\x1f':
-          s.write "\\u00"
-          s.write hexChars[(uint8(c) shr 4) and 0x0f]
-          s.write hexChars[uint8(c) and 0x0f]
-
-        else: s.write c
-
-      s.write '"'
+    autoSerializeCheck(Flavor, StringLikeTypes, typeof(value)):
+      writeValueStringLike(w, value)
+
+  elif isStringLikeArray(value):
+    autoSerializeCheck(Flavor, array, typeof(value)):
+      writeValueStringLike(w, value)
 
   elif value is bool:
-    autoSerializeCheck(Flavor, bool)
-    w.streamElement(s):
-      s.write if value: "true" else: "false"
+    autoSerializeCheck(Flavor, bool):
+      w.streamElement(s):
+        s.write if value: "true" else: "false"
 
   elif value is range:
-    autoSerializeCheck(Flavor, range, typeof(value))
-    when low(typeof(value)) < 0:
-      w.writeValue int64(value)
-    else:
-      w.writeValue uint64(value)
+    autoSerializeCheck(Flavor, range, typeof(value)):
+      when low(typeof(value)) < 0:
+        w.writeValue int64(value)
+      else:
+        w.writeValue uint64(value)
 
   elif value is SomeInteger:
-    autoSerializeCheck(Flavor, SomeInteger, typeof(value))
-    w.streamElement(s):
-      s.writeText value
+    autoSerializeCheck(Flavor, SomeInteger, typeof(value)):
+      w.streamElement(s):
+        s.writeText value
 
   elif value is SomeFloat:
-    autoSerializeCheck(Flavor, SomeFloat, typeof(value))
-    w.streamElement(s):
-      # TODO Implement writeText for floats
-      #      to avoid the allocation here:
-      s.write $value
-
-  elif value is (seq or array or openArray) or
-      (value is distinct and distinctBase(value) is (seq or array or openArray)):
-
-    when value is seq or(value is distinct and distinctBase(value) is seq):
-      autoSerializeCheck(Flavor, seq, typeof(value))
-    when value is array or(value is distinct and distinctBase(value) is array):
-      autoSerializeCheck(Flavor, array, typeof(value))
-    when value is openArray or(value is distinct and distinctBase(value) is openArray):
-      autoSerializeCheck(Flavor, openArray, typeof(value))
-    when value is distinct:
-      w.writeArray(distinctBase value)
-    else:
-      w.writeArray(value)
-
-  elif value is (distinct or object or tuple):
-    when declared(macrocache.hasKey):# Nim 1.6 have no macrocache.hasKey
-      when value is object:
-        autoSerializeCheck(Flavor, object, typeof(value))
-      when value is tuple:
-        autoSerializeCheck(Flavor, tuple, typeof(value))
+    autoSerializeCheck(Flavor, SomeFloat, typeof(value)):
+      w.streamElement(s):
+        # TODO Implement writeText for floats
+        #      to avoid the allocation here:
+        s.write $value
+
+  elif value is seq or(value is distinct and distinctBase(value) is seq):
+    autoSerializeCheck(Flavor, seq, typeof(value)):
       when value is distinct:
-        autoSerializeCheck(Flavor, distinct, typeof(value))
+        w.writeArray(distinctBase value)
+      else:
+        w.writeArray(value)
 
-    mixin flavorUsesAutomaticObjectSerialization
+  elif value is array or(value is distinct and distinctBase(value) is array):
+    autoSerializeCheck(Flavor, array, typeof(value)):
+      when value is distinct:
+        w.writeArray(distinctBase value)
+      else:
+        w.writeArray(value)
 
-    const isAutomatic =
-      flavorUsesAutomaticObjectSerialization(Flavor)
+  elif value is openArray or(value is distinct and distinctBase(value) is openArray):
+    autoSerializeCheck(Flavor, openArray, typeof(value)):
+      when value is distinct:
+        w.writeArray(distinctBase value)
+      else:
+        w.writeArray(value)
 
-    when not isAutomatic:
-      const typeName = typetraits.name(type value)
-      {.error: "Please override writeValue for the " & typeName & " type (or import the module where the override is provided)".}
+  elif value is object:
+    when declared(macrocache.hasKey): # Nim 1.6 have no macrocache.hasKey and cannot accept `object` param
+      autoSerializeCheck(Flavor, object, typeof(value)):
+        writeValueObjectOrTuple(Flavor, w, value)
+    else:
+      writeValueObjectOrTuple(Flavor, w, value)
 
-    when value is distinct:
-      writeRecordValue(w, distinctBase(value, recursive = false))
+  elif value is tuple:
+    when declared(macrocache.hasKey): # Nim 1.6 have no macrocache.hasKey and cannot accept `tuple` param
+      autoSerializeCheck(Flavor, tuple, typeof(value)):
+        writeValueObjectOrTuple(Flavor, w, value)
     else:
-      writeRecordValue(w, value)
+      writeValueObjectOrTuple(Flavor, w, value)
+
+  elif value is distinct:
+    autoSerializeCheck(Flavor, distinct, typeof(value)):
+      writeValueObjectOrTuple(Flavor, w, value)
+
   else:
-    const typeName = typetraits.name(value.type)
-    {.error: "Failed to convert to JSON an unsupported type: " & typeName.}
+    const
+      typeName = typetraits.name(value.type)
+      flavorName = typetraits.name(Flavor)
+    {.error: flavorName & ": Failed to convert to JSON an unsupported type: " & typeName.}
 
 proc toJson*(v: auto, pretty = false, typeAnnotations = false, Flavor = DefaultFlavor): string =
   ## Convert a value to its JSON string representation.