diff --git a/internal/impl/convert_list.go b/internal/impl/convert_list.go
index 1c86942..fe9384a 100644
--- a/internal/impl/convert_list.go
+++ b/internal/impl/convert_list.go
@@ -119,6 +119,14 @@
 func (ls *listReflect) Append(v pref.Value) {
 	ls.v.Elem().Set(reflect.Append(ls.v.Elem(), ls.conv.GoValueOf(v)))
 }
+func (ls *listReflect) AppendMutable() pref.Value {
+	if _, ok := ls.conv.(*messageConverter); !ok {
+		panic("invalid AppendMutable on list with non-message type")
+	}
+	v := ls.NewElement()
+	ls.Append(v)
+	return v
+}
 func (ls *listReflect) Truncate(i int) {
 	ls.v.Elem().Set(ls.v.Elem().Slice(0, i))
 }
diff --git a/internal/impl/convert_map.go b/internal/impl/convert_map.go
index fcb1450..3ef36d3 100644
--- a/internal/impl/convert_map.go
+++ b/internal/impl/convert_map.go
@@ -89,6 +89,17 @@
 	rk := ms.keyConv.GoValueOf(k.Value())
 	ms.v.SetMapIndex(rk, reflect.Value{})
 }
+func (ms *mapReflect) Mutable(k pref.MapKey) pref.Value {
+	if _, ok := ms.valConv.(*messageConverter); !ok {
+		panic("invalid Mutable on map with non-message value type")
+	}
+	v := ms.Get(k)
+	if !v.IsValid() {
+		v = ms.NewValue()
+		ms.Set(k, v)
+	}
+	return v
+}
 func (ms *mapReflect) Range(f func(pref.MapKey, pref.Value) bool) {
 	iter := mapRange(ms.v)
 	for iter.Next() {
diff --git a/reflect/protoreflect/value.go b/reflect/protoreflect/value.go
index 5ea914d..2149446 100644
--- a/reflect/protoreflect/value.go
+++ b/reflect/protoreflect/value.go
@@ -200,7 +200,10 @@
 	// Append is a mutating operation and unsafe for concurrent use.
 	Append(Value)
 
-	// TODO(blocks): Should there be a AppendMutable method?
+	// AppendMutable appends a new, empty, mutable message value to the end
+	// of the list and returns it.
+	// It panics if the list does not contain a message type.
+	AppendMutable() Value
 
 	// Truncate truncates the list to a smaller length.
 	//
@@ -258,7 +261,11 @@
 	// Set is a mutating operation and unsafe for concurrent use.
 	Set(MapKey, Value)
 
-	// TODO(blocks): Should there be a Mutable method?
+	// Mutable retrieves a mutable reference to the entry for the given key.
+	// If no entry exists for the key, it creates a new, empty, mutable value
+	// and stores it as the entry for the key.
+	// It panics if the map value is not a message.
+	Mutable(MapKey) Value
 
 	// NewValue returns a new value assignable as a map value.
 	// For enums, this returns the first enum value.
diff --git a/testing/prototest/prototest.go b/testing/prototest/prototest.go
index 050a61d..0c6b700 100644
--- a/testing/prototest/prototest.go
+++ b/testing/prototest/prototest.go
@@ -296,16 +296,37 @@
 		t.Errorf("non-existent map key in %q: Map.Get(%v).IsValid() = %v, want %v", name, formatValue(missingKey.Value()), got, want)
 	}
 	mapv.Clear(missingKey) // noop
+
+	// Mutable.
+	if fd.MapValue().Message() == nil {
+		if !panics(func() {
+			mapv.Mutable(newMapKey(fd, 1))
+		}) {
+			t.Errorf("Mutable on %q succeeds, want panic", name)
+		}
+	} else {
+		k := newMapKey(fd, 1)
+		v := mapv.Mutable(k)
+		if got, want := mapv.Len(), 1; got != want {
+			t.Errorf("after Mutable on %q, Map.Len() = %v, want %v", name, got, want)
+		}
+		populateMessage(v.Message(), 1, nil)
+		if !valueEqual(mapv.Get(k), v) {
+			t.Errorf("after Mutable on %q, changing new mutable value does not change map entry", name)
+		}
+		mapv.Clear(k)
+	}
 }
 
 type testMap map[interface{}]pref.Value
 
-func (m testMap) Get(k pref.MapKey) pref.Value    { return m[k.Interface()] }
-func (m testMap) Set(k pref.MapKey, v pref.Value) { m[k.Interface()] = v }
-func (m testMap) Has(k pref.MapKey) bool          { return m.Get(k).IsValid() }
-func (m testMap) Clear(k pref.MapKey)             { delete(m, k.Interface()) }
-func (m testMap) Len() int                        { return len(m) }
-func (m testMap) NewValue() pref.Value            { panic("unimplemented") }
+func (m testMap) Get(k pref.MapKey) pref.Value     { return m[k.Interface()] }
+func (m testMap) Set(k pref.MapKey, v pref.Value)  { m[k.Interface()] = v }
+func (m testMap) Has(k pref.MapKey) bool           { return m.Get(k).IsValid() }
+func (m testMap) Clear(k pref.MapKey)              { delete(m, k.Interface()) }
+func (m testMap) Mutable(k pref.MapKey) pref.Value { panic("unimplemented") }
+func (m testMap) Len() int                         { return len(m) }
+func (m testMap) NewValue() pref.Value             { panic("unimplemented") }
 func (m testMap) Range(f func(pref.MapKey, pref.Value) bool) {
 	for k, v := range m {
 		if !f(pref.ValueOf(k).MapKey(), v) {
@@ -383,19 +404,39 @@
 			t.Errorf("after truncating %q to %d:\nMessage.Get(%v) = %v, want %v", name, n, num, formatValue(got), formatValue(want))
 		}
 	}
+
+	// AppendMutable.
+	if fd.Message() == nil {
+		if !panics(func() {
+			list.AppendMutable()
+		}) {
+			t.Errorf("AppendMutable on %q succeeds, want panic", name)
+		}
+	} else {
+		v := list.AppendMutable()
+		if got, want := list.Len(), 1; got != want {
+			t.Errorf("after AppendMutable on %q, list.Len() = %v, want %v", name, got, want)
+		}
+		populateMessage(v.Message(), 1, nil)
+		if !valueEqual(list.Get(0), v) {
+			t.Errorf("after AppendMutable on %q, changing new mutable value does not change list item 0", name)
+		}
+		want.Truncate(0)
+	}
 }
 
 type testList struct {
 	a []pref.Value
 }
 
-func (l *testList) Append(v pref.Value)     { l.a = append(l.a, v) }
-func (l *testList) Get(n int) pref.Value    { return l.a[n] }
-func (l *testList) Len() int                { return len(l.a) }
-func (l *testList) Set(n int, v pref.Value) { l.a[n] = v }
-func (l *testList) Truncate(n int)          { l.a = l.a[:n] }
-func (l *testList) NewElement() pref.Value  { panic("unimplemented") }
-func (l *testList) IsValid() bool           { return true }
+func (l *testList) Append(v pref.Value)       { l.a = append(l.a, v) }
+func (l *testList) AppendMutable() pref.Value { panic("unimplemented") }
+func (l *testList) Get(n int) pref.Value      { return l.a[n] }
+func (l *testList) Len() int                  { return len(l.a) }
+func (l *testList) Set(n int, v pref.Value)   { l.a[n] = v }
+func (l *testList) Truncate(n int)            { l.a = l.a[:n] }
+func (l *testList) NewElement() pref.Value    { panic("unimplemented") }
+func (l *testList) IsValid() bool             { return true }
 
 // testFieldFloat exercises some interesting floating-point scalar field values.
 func testFieldFloat(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
@@ -605,9 +646,6 @@
 		mapv.Set(newMapKey(fd, n), newMapValue(fd, mapv, newSeed(n, 0), stack))
 		return pref.ValueOfMap(mapv)
 	case fd.Message() != nil:
-		//if n == 0 {
-		//	return m.New().Get(fd)
-		//}
 		return populateMessage(m.NewField(fd).Message(), n, stack)
 	default:
 		return newScalarValue(fd, n)
diff --git a/types/dynamicpb/dynamic.go b/types/dynamicpb/dynamic.go
index 991624a..f206c18 100644
--- a/types/dynamicpb/dynamic.go
+++ b/types/dynamicpb/dynamic.go
@@ -314,13 +314,14 @@
 	desc pref.FieldDescriptor
 }
 
-func (x emptyList) Len() int                { return 0 }
-func (x emptyList) Get(n int) pref.Value    { panic(errors.New("out of range")) }
-func (x emptyList) Set(n int, v pref.Value) { panic(errors.New("modification of immutable list")) }
-func (x emptyList) Append(v pref.Value)     { panic(errors.New("modification of immutable list")) }
-func (x emptyList) Truncate(n int)          { panic(errors.New("modification of immutable list")) }
-func (x emptyList) NewElement() pref.Value  { return newListEntry(x.desc) }
-func (x emptyList) IsValid() bool           { return false }
+func (x emptyList) Len() int                  { return 0 }
+func (x emptyList) Get(n int) pref.Value      { panic(errors.New("out of range")) }
+func (x emptyList) Set(n int, v pref.Value)   { panic(errors.New("modification of immutable list")) }
+func (x emptyList) Append(v pref.Value)       { panic(errors.New("modification of immutable list")) }
+func (x emptyList) AppendMutable() pref.Value { panic(errors.New("modification of immutable list")) }
+func (x emptyList) Truncate(n int)            { panic(errors.New("modification of immutable list")) }
+func (x emptyList) NewElement() pref.Value    { return newListEntry(x.desc) }
+func (x emptyList) IsValid() bool             { return false }
 
 type dynamicList struct {
 	desc pref.FieldDescriptor
@@ -345,6 +346,15 @@
 	x.list = append(x.list, v)
 }
 
+func (x *dynamicList) AppendMutable() pref.Value {
+	if x.desc.Message() == nil {
+		panic(errors.New("%v: invalid AppendMutable on list with non-message type", x.desc.FullName()))
+	}
+	v := x.NewElement()
+	x.Append(v)
+	return v
+}
+
 func (x *dynamicList) Truncate(n int) {
 	// Zero truncated elements to avoid keeping data live.
 	for i := n; i < len(x.list); i++ {
@@ -374,7 +384,18 @@
 }
 func (x *dynamicMap) Has(k pref.MapKey) bool { return x.Get(k).IsValid() }
 func (x *dynamicMap) Clear(k pref.MapKey)    { delete(x.mapv, k.Interface()) }
-func (x *dynamicMap) Len() int               { return len(x.mapv) }
+func (x *dynamicMap) Mutable(k pref.MapKey) pref.Value {
+	if x.desc.MapValue().Message() == nil {
+		panic(errors.New("%v: invalid Mutable on map with non-message value type", x.desc.FullName()))
+	}
+	v := x.Get(k)
+	if !v.IsValid() {
+		v = x.NewValue()
+		x.Set(k, v)
+	}
+	return v
+}
+func (x *dynamicMap) Len() int { return len(x.mapv) }
 func (x *dynamicMap) NewValue() pref.Value {
 	if md := x.desc.MapValue().Message(); md != nil {
 		return pref.ValueOfMessage(NewMessage(md).ProtoReflect())