diff --git a/docs/table.clone-locked-metatables.md b/docs/table.clone-locked-metatables.md
index 6395432..31a2a93 100644
--- a/docs/table.clone-locked-metatables.md
+++ b/docs/table.clone-locked-metatables.md
@@ -10,6 +10,38 @@ As proposed by the [`table.clone` RFC](function-table-clone.md), the function `t
 Due to this limitation, it is very un-ergonomic to create shallow copies of arbitrary tables.
 The current behavior of using `table.clone` on a table with a locked metatable is a hard-fail approach where `table.clone` spits out an error instead of having a soft-fail approach wherein a clone is generated without a metatable.
 This hard-fail approach severely hinders the usefulness of `table.clone` due to in practice users having to re-implement the function in many scenarios.
+Example use cases wherein the proposed behavior would allow for elegant behavior and where the current behavior would be extremely unergonomic are:
+
+An example is a JSON serialization function that wants to strip metatables completely before attempting to serialize said table to JSON.
+Other examples where users may want to strip metatables may be security layers that don't want unwanted behavior caused by metatables.
+```lua
+local function JSONEncode(tbl)
+	return JSONSerialize(setmetatable(table.clone(newTbl), nil))
+end
+
+-- This wouldn't be possible nowhere near as elegantly with the current behavior and users would effectively have to re-implement table.clone in Lua.
+-- The point of table.clone after all was to require users to now create shallow copy functions in Lua themselves.
+```
+
+Another example is where you do want to mirror the behavior of the original table after cloning as much as possible.
+With the new behavior, the following code would be possible.
+```lua
+local new = {}
+
+for k, v in old do
+	new[k] = (type(v) == "table" and getmetatable(v) ~= nil) and setmetatable(table.clone(v), {
+		__index = function(_, k)
+			return old[k]
+		end,
+		__newindex = function(_, k, v)
+			old[k] = v
+		end,
+	}) or v
+end
+
+return new
+```
+With the old behavior said code wouldn't be possible, and you once again would have to re-implement the shallow copy function manually. Even using `pcall` for `table.clone` wouldn't work here as the raw keys wouldn't be copied over.
 
 ## Design