diff --git a/Makefile b/Makefile
index 7203311..e3b3c2c 100644
--- a/Makefile
+++ b/Makefile
@@ -3,14 +3,14 @@
 
 GOLINT = $(GOBIN)/golint
 GEN_ATOMICINT = $(GOBIN)/gen-atomicint
-GEN_VALUEWRAPPER = $(GOBIN)/gen-valuewrapper
+GEN_ATOMICWRAPPER = $(GOBIN)/gen-atomicwrapper
 
 GO_FILES ?= $(shell find . '(' -path .git -o -path vendor ')' -prune -o -name '*.go' -print)
 
 # Also update ignore section in .codecov.yml.
 COVER_IGNORE_PKGS = \
 	go.uber.org/atomic/internal/gen-atomicint \
-	go.uber.org/atomic/internal/gen-valuewrapper
+	go.uber.org/atomic/internal/gen-atomicwrapper
 
 .PHONY: build
 build:
@@ -29,8 +29,8 @@
 $(GOLINT):
 	go install golang.org/x/lint/golint
 
-$(GEN_VALUEWRAPPER): $(wildcard ./internal/gen-valuewrapper/*)
-	go build -o $@ ./internal/gen-valuewrapper
+$(GEN_ATOMICWRAPPER): $(wildcard ./internal/gen-atomicwrapper/*)
+	go build -o $@ ./internal/gen-atomicwrapper
 
 $(GEN_ATOMICINT): $(wildcard ./internal/gen-atomicint/*)
 	go build -o $@ ./internal/gen-atomicint
@@ -54,7 +54,7 @@
 	go tool cover -html=cover.out -o cover.html
 
 .PHONY: generate
-generate: $(GEN_ATOMICINT) $(GEN_VALUEWRAPPER)
+generate: $(GEN_ATOMICINT) $(GEN_ATOMICWRAPPER)
 	go generate ./...
 
 .PHONY: generatenodirty
diff --git a/error.go b/error.go
index 8657849..cedbc91 100644
--- a/error.go
+++ b/error.go
@@ -1,4 +1,4 @@
-// @generated Code generated by gen-valuewrapper.
+// @generated Code generated by gen-atomicwrapper.
 
 // Copyright (c) 2020 Uber Technologies, Inc.
 //
@@ -23,22 +23,18 @@
 package atomic
 
 // Error is an atomic type-safe wrapper for error values.
-type Error struct{ v Value }
+type Error struct {
+	nocmp // disallow non-atomic comparison
 
-type storedError struct{ Value error }
-
-func wrapError(v error) storedError {
-	return storedError{v}
+	v Value
 }
 
-func unwrapError(v storedError) error {
-	return v.Value
-}
+var _zeroError error
 
 // NewError creates a new Error.
 func NewError(v error) *Error {
 	x := &Error{}
-	if v != nil {
+	if v != _zeroError {
 		x.Store(v)
 	}
 	return x
@@ -46,16 +42,10 @@
 
 // Load atomically loads the wrapped error.
 func (x *Error) Load() error {
-	v := x.v.Load()
-	if v == nil {
-		return nil
-	}
-	return unwrapError(v.(storedError))
+	return unpackError(x.v.Load())
 }
 
 // Store atomically stores the passed error.
-//
-// NOTE: This will cause an allocation.
 func (x *Error) Store(v error) {
-	x.v.Store(wrapError(v))
+	x.v.Store(packError(v))
 }
diff --git a/error_ext.go b/error_ext.go
new file mode 100644
index 0000000..ffe0be2
--- /dev/null
+++ b/error_ext.go
@@ -0,0 +1,39 @@
+// Copyright (c) 2020 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package atomic
+
+// atomic.Value panics on nil inputs, or if the underlying type changes.
+// Stabilize by always storing a custom struct that we control.
+
+//go:generate bin/gen-atomicwrapper -name=Error -type=error -wrapped=Value -pack=packError -unpack=unpackError -file=error.go
+
+type packedError struct{ Value error }
+
+func packError(v error) interface{} {
+	return packedError{v}
+}
+
+func unpackError(v interface{}) error {
+	if err, ok := v.(packedError); ok {
+		return err.Value
+	}
+	return nil
+}
diff --git a/gen.go b/gen.go
index 03c8ac9..50d6b24 100644
--- a/gen.go
+++ b/gen.go
@@ -24,6 +24,3 @@
 //go:generate bin/gen-atomicint -name=Int64 -wrapped=int64 -file=int64.go
 //go:generate bin/gen-atomicint -name=Uint32 -wrapped=uint32 -unsigned -file=uint32.go
 //go:generate bin/gen-atomicint -name=Uint64 -wrapped=uint64 -unsigned -file=uint64.go
-
-//go:generate bin/gen-valuewrapper -name=String -type=string -zero="" -file=string.go
-//go:generate bin/gen-valuewrapper -name=Error -type=error -zero=nil -file=error.go
diff --git a/internal/gen-atomicwrapper/main.go b/internal/gen-atomicwrapper/main.go
new file mode 100644
index 0000000..0bb180e
--- /dev/null
+++ b/internal/gen-atomicwrapper/main.go
@@ -0,0 +1,300 @@
+// Copyright (c) 2020 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+// gen-atomicwrapper generates wrapper types around other atomic types.
+//
+// It supports plugging in functions which convert the value inside the atomic
+// type to the user-facing value. For example,
+//
+// Given, atomic.Value and the functions,
+//
+//  func packString(string) interface{}
+//  func unpackString(interface{}) string
+//
+// We can run the following command:
+//
+//  gen-atomicwrapper -name String -wrapped Value \
+//    -type string -pack fromString -unpack tostring
+//
+// This wil generate approximately,
+//
+//  type String struct{ v Value }
+//
+//  func (s *String) Load() string {
+//    return unpackString(v.Load())
+//  }
+//
+//  func (s *String) Store(s string) {
+//    return s.v.Store(packString(s))
+//  }
+//
+// The packing/unpacking logic allows the stored value to be different from
+// the user-facing value.
+//
+// Without -pack and -unpack, the output will be cast to the target type,
+// defaulting to the zero value.
+package main
+
+import (
+	"bytes"
+	"errors"
+	"flag"
+	"fmt"
+	"go/format"
+	"io"
+	"log"
+	"os"
+	"sort"
+	"strings"
+	"text/template"
+)
+
+func main() {
+	log.SetFlags(0)
+	if err := run(os.Args[1:]); err != nil {
+		log.Fatalf("%+v", err)
+	}
+}
+
+type stringList []string
+
+func (sl *stringList) String() string {
+	return strings.Join(*sl, ",")
+}
+
+func (sl *stringList) Set(s string) error {
+	for _, i := range strings.Split(s, ",") {
+		*sl = append(*sl, strings.TrimSpace(i))
+	}
+	return nil
+}
+
+func run(args []string) error {
+	var opts struct {
+		Name    string
+		Wrapped string
+		Type    string
+
+		Imports      stringList
+		Pack, Unpack string
+
+		CAS  bool
+		Swap bool
+		JSON bool
+
+		File string
+	}
+
+	flag := flag.NewFlagSet("gen-atomicwrapper", flag.ContinueOnError)
+
+	// Required flags
+	flag.StringVar(&opts.Name, "name", "",
+		"name of the generated type (e.g. Duration)")
+	flag.StringVar(&opts.Wrapped, "wrapped", "",
+		"name of the wrapped atomic (e.g. Int64)")
+	flag.StringVar(&opts.Type, "type", "",
+		"name of the type exposed by the atomic (e.g. time.Duration)")
+
+	// Optional flags
+	flag.Var(&opts.Imports, "imports",
+		"comma separated list of imports to add")
+	flag.StringVar(&opts.Pack, "pack", "",
+		"function to transform values with before storage")
+	flag.StringVar(&opts.Unpack, "unpack", "",
+		"function to reverse packing on loading")
+	flag.StringVar(&opts.File, "file", "",
+		"output file path (default: stdout)")
+
+	// Switches for individual methods. Underlying atomics must support
+	// these.
+	flag.BoolVar(&opts.CAS, "cas", false,
+		"generate a `CAS(old, new) bool` method; requires -pack")
+	flag.BoolVar(&opts.Swap, "swap", false,
+		"generate a `Swap(new) old` method; requires -pack and -unpack")
+	flag.BoolVar(&opts.JSON, "json", false,
+		"generate `MarshalJSON/UnmarshJSON` methods")
+
+	if err := flag.Parse(args); err != nil {
+		return err
+	}
+
+	if len(opts.Name) == 0 || len(opts.Wrapped) == 0 || len(opts.Type) == 0 {
+		return errors.New("flags -name, -wrapped, and -type are required")
+	}
+
+	if (len(opts.Pack) == 0) != (len(opts.Unpack) == 0) {
+		return errors.New("either both, or neither of -pack and -unpack must be specified")
+	}
+
+	if opts.CAS && len(opts.Pack) == 0 {
+		return errors.New("flag -cas requires -pack")
+	}
+
+	if opts.Swap && len(opts.Pack) == 0 {
+		return errors.New("flag -swap requires -pack and -unpack")
+	}
+
+	var w io.Writer = os.Stdout
+	if file := opts.File; len(file) > 0 {
+		f, err := os.Create(file)
+		if err != nil {
+			return fmt.Errorf("create %q: %v", file, err)
+		}
+		defer f.Close()
+
+		w = f
+	}
+
+	// Import encoding/json if needed.
+	if opts.JSON {
+		found := false
+		for _, imp := range opts.Imports {
+			if imp == "encoding/json" {
+				found = true
+				break
+			}
+		}
+
+		if !found {
+			opts.Imports = append(opts.Imports, "encoding/json")
+		}
+	}
+
+	sort.Strings([]string(opts.Imports))
+
+	var buff bytes.Buffer
+	if err := _tmpl.Execute(&buff, opts); err != nil {
+		return fmt.Errorf("render template: %v", err)
+	}
+
+	bs, err := format.Source(buff.Bytes())
+	if err != nil {
+		return fmt.Errorf("reformat source: %v", err)
+	}
+
+	_, err = w.Write(bs)
+	return err
+}
+
+var _tmpl = template.Must(template.New("int.go").Parse(`// @generated Code generated by gen-atomicwrapper.
+
+// Copyright (c) 2020 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package atomic
+
+{{ with .Imports }}
+import (
+	{{ range . -}}
+		{{ printf "%q" . }}
+	{{ end }}
+)
+{{ end }}
+
+// {{ .Name }} is an atomic type-safe wrapper for {{ .Type }} values.
+type {{ .Name }} struct{
+	nocmp // disallow non-atomic comparison
+
+	v {{ .Wrapped }}
+}
+
+var _zero{{ .Name }} {{ .Type }}
+
+
+// New{{ .Name }} creates a new {{ .Name }}.
+func New{{ .Name}}(v {{ .Type }}) *{{ .Name }} {
+	x := &{{ .Name }}{}
+	if v != _zero{{ .Name }} {
+		x.Store(v)
+	}
+	return x
+}
+
+// Load atomically loads the wrapped {{ .Type }}.
+func (x *{{ .Name }}) Load() {{ .Type }} {
+	{{ if .Unpack -}}
+		return {{ .Unpack }}(x.v.Load())
+	{{- else -}}
+		if v := x.v.Load(); v != nil {
+			return v.({{ .Type }})
+		}
+		return _zero{{ .Name }}
+	{{- end }}
+}
+
+// Store atomically stores the passed {{ .Type }}.
+func (x *{{ .Name }}) Store(v {{ .Type }}) {
+	{{ if .Pack -}}
+		x.v.Store({{ .Pack }}(v))
+	{{- else -}}
+		x.v.Store(v)
+	{{- end }}
+}
+
+{{ if .CAS -}}
+	// CAS is an atomic compare-and-swap for {{ .Type }} values.
+	func (x *{{ .Name }}) CAS(o, n {{ .Type }}) bool {
+		return x.v.CAS({{ .Pack }}(o), {{ .Pack }}(n))
+	}
+{{- end }}
+
+{{ if .Swap -}}
+	// Swap atomically stores the given {{ .Type }} and returns the old
+	// value.
+	func (x *{{ .Name }}) Swap(o {{ .Type }}) {{ .Type }} {
+		return {{ .Unpack }}(x.v.Swap({{ .Pack }}(o)))
+	}
+{{- end }}
+
+{{ if .JSON -}}
+	// MarshalJSON encodes the wrapped {{ .Type }} into JSON.
+	func (x *{{ .Name }}) MarshalJSON() ([]byte, error) {
+		return json.Marshal(x.Load())
+	}
+
+	// UnmarshalJSON decodes a {{ .Type }} from JSON.
+	func (x *{{ .Name }}) UnmarshalJSON(b []byte) error {
+		var v {{ .Type }}
+		if err := json.Unmarshal(b, &v); err != nil {
+			return err
+		}
+		x.Store(v)
+		return nil
+	}
+{{- end }}
+
+`))
diff --git a/internal/gen-valuewrapper/main.go b/internal/gen-valuewrapper/main.go
deleted file mode 100644
index 520701e..0000000
--- a/internal/gen-valuewrapper/main.go
+++ /dev/null
@@ -1,173 +0,0 @@
-// Copyright (c) 2020 Uber Technologies, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-package main
-
-import (
-	"bytes"
-	"errors"
-	"flag"
-	"fmt"
-	"go/format"
-	"io"
-	"log"
-	"os"
-	"text/template"
-)
-
-func main() {
-	log.SetFlags(0)
-	if err := run(os.Args[1:]); err != nil {
-		log.Fatalf("%+v", err)
-	}
-}
-
-func run(args []string) error {
-	var opts struct {
-		Name string
-		Type string
-		Zero string
-		File string
-	}
-
-	flag := flag.NewFlagSet("gen-atomicint", flag.ContinueOnError)
-
-	flag.StringVar(&opts.Name, "name", "", "name of the generated type (e.g. Int32)")
-	flag.StringVar(&opts.Type, "type", "", "name of the wrapped type (e.g. int32)")
-	flag.StringVar(&opts.Zero, "zero", "", "zero value of the wrapped type (e.g. nil)")
-	flag.StringVar(&opts.File, "file", "", "output file path (default: stdout)")
-
-	if err := flag.Parse(args); err != nil {
-		return err
-	}
-
-	if len(opts.Name) == 0 || len(opts.Type) == 0 || len(opts.Zero) == 0 {
-		return errors.New("flags -name, -type, and -zero are required")
-	}
-
-	var w io.Writer = os.Stdout
-	if file := opts.File; len(file) > 0 {
-		f, err := os.Create(file)
-		if err != nil {
-			return fmt.Errorf("create %q: %v", file, err)
-		}
-		defer f.Close()
-
-		w = f
-	}
-
-	data := struct {
-		Name     string
-		Type     string
-		Zero     string
-		Nillable bool
-	}{
-		Name:     opts.Name,
-		Type:     opts.Type,
-		Zero:     opts.Zero,
-		Nillable: opts.Zero == "nil",
-	}
-
-	var buff bytes.Buffer
-	if err := _tmpl.Execute(&buff, data); err != nil {
-		return fmt.Errorf("render template: %v", err)
-	}
-
-	bs, err := format.Source(buff.Bytes())
-	if err != nil {
-		return fmt.Errorf("reformat source: %v", err)
-	}
-
-	_, err = w.Write(bs)
-	return err
-}
-
-var _tmpl = template.Must(template.New("int.go").Parse(`// @generated Code generated by gen-valuewrapper.
-
-// Copyright (c) 2020 Uber Technologies, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-package atomic
-
-// {{ .Name }} is an atomic type-safe wrapper for {{ .Type }} values.
-type {{ .Name }} struct{ v Value }
-
-{{/* atomic.Value panics for nil values. Generate a wrapper for these types. */}}
-{{ $stored := .Type }}
-{{ $wrap := .Type }}
-{{ $unwrap := .Type }}
-{{ if .Nillable -}}
-	{{ $stored = printf "stored%s" .Name }}
-	{{ $wrap = printf "wrap%s" .Name }}
-	{{ $unwrap = printf "unwrap%s" .Name }}
-
-	type {{ $stored }} struct{ Value {{ .Type }} }
-
-	func {{ $wrap }}(v {{ .Type }}) {{ $stored }} {
-		return {{ $stored }}{v}
-	}
-
-	func {{ $unwrap }}(v {{ $stored }}) {{ .Type }} {
-		return v.Value
-	}
-{{- end }}
-
-// New{{ .Name }} creates a new {{ .Name }}.
-func New{{ .Name }}(v {{ .Type }}) *{{ .Name }} {
-	x := &{{ .Name }}{}
-	if v != {{ .Zero }} {
-		x.Store(v)
-	}
-	return x
-}
-
-// Load atomically loads the wrapped {{ .Type }}.
-func (x *{{ .Name }}) Load() {{ .Type }} {
-	v := x.v.Load()
-	if v == nil {
-		return {{ .Zero }}
-	}
-	return {{ $unwrap }}(v.({{ $stored }}))
-}
-
-// Store atomically stores the passed {{ .Type }}.
-//
-// NOTE: This will cause an allocation.
-func (x *{{ .Name }}) Store(v {{ .Type }}) {
-	x.v.Store({{ $wrap }}(v))
-}
-`))
diff --git a/string.go b/string.go
index 8829c48..8e3ac35 100644
--- a/string.go
+++ b/string.go
@@ -1,4 +1,4 @@
-// @generated Code generated by gen-valuewrapper.
+// @generated Code generated by gen-atomicwrapper.
 
 // Copyright (c) 2020 Uber Technologies, Inc.
 //
@@ -23,12 +23,18 @@
 package atomic
 
 // String is an atomic type-safe wrapper for string values.
-type String struct{ v Value }
+type String struct {
+	nocmp // disallow non-atomic comparison
+
+	v Value
+}
+
+var _zeroString string
 
 // NewString creates a new String.
 func NewString(v string) *String {
 	x := &String{}
-	if v != "" {
+	if v != _zeroString {
 		x.Store(v)
 	}
 	return x
@@ -36,16 +42,13 @@
 
 // Load atomically loads the wrapped string.
 func (x *String) Load() string {
-	v := x.v.Load()
-	if v == nil {
-		return ""
+	if v := x.v.Load(); v != nil {
+		return v.(string)
 	}
-	return string(v.(string))
+	return _zeroString
 }
 
 // Store atomically stores the passed string.
-//
-// NOTE: This will cause an allocation.
 func (x *String) Store(v string) {
-	x.v.Store(string(v))
+	x.v.Store(v)
 }
diff --git a/string_ext.go b/string_ext.go
index a346358..3a95582 100644
--- a/string_ext.go
+++ b/string_ext.go
@@ -20,6 +20,8 @@
 
 package atomic
 
+//go:generate bin/gen-atomicwrapper -name=String -type=string -wrapped=Value -file=string.go
+
 // String returns the wrapped value.
 func (s *String) String() string {
 	return s.Load()