diff --git a/Bencodex.Tests/CodecTest.cs b/Bencodex.Tests/CodecTest.cs
index 5762548..f745e12 100644
--- a/Bencodex.Tests/CodecTest.cs
+++ b/Bencodex.Tests/CodecTest.cs
@@ -29,7 +29,7 @@ public void SpecTestSuite(Spec spec)
             _output.WriteLine("Data: {0}", spec.EncodingPath);
             Codec codec = new Codec();
             IValue decoded = codec.Decode(spec.Encoding);
-            _output.WriteLine("Value: {0}", decoded.Inspect(false));
+            _output.WriteLine("Value: {0}", decoded.Inspect());
             Assert.Equal(spec.Semantics, decoded);
             Assert.Equal(spec.Encoding.LongLength, decoded.EncodingLength);
             Assert.Equal(spec.Semantics.EncodingLength, decoded.EncodingLength);
diff --git a/Bencodex.Tests/Types/BinaryTest.cs b/Bencodex.Tests/Types/BinaryTest.cs
index 3694f67..b8f5bcf 100644
--- a/Bencodex.Tests/Types/BinaryTest.cs
+++ b/Bencodex.Tests/Types/BinaryTest.cs
@@ -178,13 +178,11 @@ public void EncodingLength()
             Assert.Equal(13L, new Binary(new byte[10]).EncodingLength);
         }
 
-        [Theory]
-        [InlineData(new object[] { false })]
-        [InlineData(new object[] { true })]
-        public void Inspect(bool loadAll)
+        [Fact]
+        public void Inspect()
         {
-            Assert.Equal("b\"\"", _empty.Inspect(loadAll));
-            Assert.Equal(@"b""\x68\x65\x6c\x6c\x6f""", _hello.Inspect(loadAll));
+            Assert.Equal("b\"\"", _empty.Inspect());
+            Assert.Equal(@"b""\x68\x65\x6c\x6c\x6f""", _hello.Inspect());
         }
 
         [Fact]
diff --git a/Bencodex.Tests/Types/BooleanTest.cs b/Bencodex.Tests/Types/BooleanTest.cs
index 4ce37bc..14e5ebc 100644
--- a/Bencodex.Tests/Types/BooleanTest.cs
+++ b/Bencodex.Tests/Types/BooleanTest.cs
@@ -37,13 +37,11 @@ public void Encode()
             );
         }
 
-        [Theory]
-        [InlineData(false)]
-        [InlineData(true)]
-        public void Inspect(bool loadAll)
+        [Fact]
+        public void Inspect()
         {
-            Assert.Equal("true", _t.Inspect(loadAll));
-            Assert.Equal("false", _f.Inspect(loadAll));
+            Assert.Equal("true", _t.Inspect());
+            Assert.Equal("false", _f.Inspect());
         }
 
         [Fact]
diff --git a/Bencodex.Tests/Types/DictionaryTest.cs b/Bencodex.Tests/Types/DictionaryTest.cs
index f56efd5..dbb08ab 100644
--- a/Bencodex.Tests/Types/DictionaryTest.cs
+++ b/Bencodex.Tests/Types/DictionaryTest.cs
@@ -558,20 +558,18 @@ public void EncodingLength()
             Assert.Equal(33L, _mixedKeys.EncodingLength);
         }
 
-        [Theory]
-        [InlineData(false)]
-        [InlineData(true)]
-        public void Inspect(bool loadAll)
+        [Fact]
+        public void Inspect()
         {
-            Assert.Equal("{}", Dictionary.Empty.Inspect(loadAll));
+            Assert.Equal("{}", Dictionary.Empty.Inspect());
 
             Assert.Equal(
                 "{\n  \"foo\": \"bar\",\n}",
-                _textKey.Inspect(loadAll)
+                _textKey.Inspect()
             );
             Assert.Equal(
                 "{\n  b\"\\x66\\x6f\\x6f\": \"bar\",\n}",
-                _binaryKey.Inspect(loadAll)
+                _binaryKey.Inspect()
             );
             Assert.Equal(
                 @"{
@@ -580,7 +578,7 @@ public void Inspect(bool loadAll)
   },
   ""foo"": ""bar"",
 }".NoCr(),
-                _textKey.SetItem("baz", _textKey).Inspect(loadAll)
+                _textKey.SetItem("baz", _textKey).Inspect()
             );
         }
 
diff --git a/Bencodex.Tests/Types/IntegerTest.cs b/Bencodex.Tests/Types/IntegerTest.cs
index 651fb08..7ea7601 100644
--- a/Bencodex.Tests/Types/IntegerTest.cs
+++ b/Bencodex.Tests/Types/IntegerTest.cs
@@ -160,13 +160,11 @@ public void EncodingLength()
             Assert.Equal(6L, new Integer(-456).EncodingLength);
         }
 
-        [Theory]
-        [InlineData(new object[] { false })]
-        [InlineData(new object[] { true })]
-        public void Inspect(bool loadAll)
+        [Fact]
+        public void Inspect()
         {
-            Assert.Equal("123", new Integer(123).Inspect(loadAll));
-            Assert.Equal("-456", new Integer(-456).Inspect(loadAll));
+            Assert.Equal("123", new Integer(123).Inspect());
+            Assert.Equal("-456", new Integer(-456).Inspect());
         }
 
         [Fact]
diff --git a/Bencodex.Tests/Types/ListTest.cs b/Bencodex.Tests/Types/ListTest.cs
index 1a3fa33..fd71e69 100644
--- a/Bencodex.Tests/Types/ListTest.cs
+++ b/Bencodex.Tests/Types/ListTest.cs
@@ -98,14 +98,12 @@ public void EncodingLength()
             Assert.Equal(26L, _nest.EncodingLength);
         }
 
-        [Theory]
-        [InlineData(false)]
-        [InlineData(true)]
-        public void Inspect(bool loadAll)
+        [Fact]
+        public void Inspect()
         {
-            Assert.Equal("[]", _zero.Inspect(loadAll));
-            Assert.Equal("[null]", _one.Inspect(loadAll));
-            Assert.Equal("[\n  \"hello\",\n  \"world\",\n]", _two.Inspect(loadAll));
+            Assert.Equal("[]", _zero.Inspect());
+            Assert.Equal("[null]", _one.Inspect());
+            Assert.Equal("[\n  \"hello\",\n  \"world\",\n]", _two.Inspect());
 
             var expected = @"[
   null,
@@ -116,11 +114,11 @@ public void Inspect(bool loadAll)
     ""world"",
   ],
 ]".NoCr();
-            Assert.Equal(expected, _nest.Inspect(loadAll));
+            Assert.Equal(expected, _nest.Inspect());
 
             // If any element is a list/dict it should be indented
-            Assert.Equal("[\n  [],\n]", new List(new IValue[] { _zero }).Inspect(loadAll));
-            Assert.Equal("[\n  {},\n]", new List(Dictionary.Empty).Inspect(loadAll));
+            Assert.Equal("[\n  [],\n]", new List(new IValue[] { _zero }).Inspect());
+            Assert.Equal("[\n  {},\n]", new List(Dictionary.Empty).Inspect());
         }
 
         [Fact]
diff --git a/Bencodex.Tests/Types/NullTest.cs b/Bencodex.Tests/Types/NullTest.cs
index edf173b..4f1e71e 100644
--- a/Bencodex.Tests/Types/NullTest.cs
+++ b/Bencodex.Tests/Types/NullTest.cs
@@ -25,12 +25,10 @@ public void Kind()
             Assert.Equal(ValueKind.Null, Null.Value.Kind);
         }
 
-        [Theory]
-        [InlineData(new object[] { false })]
-        [InlineData(new object[] { true })]
-        public void Inspect(bool loadAll)
+        [Fact]
+        public void Inspect()
         {
-            Assert.Equal("null", Null.Value.Inspect(loadAll));
+            Assert.Equal("null", Null.Value.Inspect());
         }
 
         [Fact]
diff --git a/Bencodex.Tests/Types/TextTest.cs b/Bencodex.Tests/Types/TextTest.cs
index 1d820b8..38be3ea 100644
--- a/Bencodex.Tests/Types/TextTest.cs
+++ b/Bencodex.Tests/Types/TextTest.cs
@@ -111,16 +111,14 @@ public void Encode()
             );
         }
 
-        [Theory]
-        [InlineData(new object[] { false })]
-        [InlineData(new object[] { true })]
-        public void Inspect(bool loadAll)
+        [Fact]
+        public void Inspect()
         {
-            Assert.Equal("\"\"", _empty.Inspect(loadAll));
-            Assert.Equal("\"\u4f60\u597d\"", _nihao.Inspect(loadAll));
+            Assert.Equal("\"\"", _empty.Inspect());
+            Assert.Equal("\"\u4f60\u597d\"", _nihao.Inspect());
             Assert.Equal(
                 "\"new lines and\\n\\\"quotes\\\" become escaped to \\\\\"",
-                _complex.Inspect(loadAll)
+                _complex.Inspect()
             );
         }
 
diff --git a/Bencodex/Types/Binary.cs b/Bencodex/Types/Binary.cs
index 954acef..6c4038c 100644
--- a/Bencodex/Types/Binary.cs
+++ b/Bencodex/Types/Binary.cs
@@ -317,8 +317,8 @@ public string ToBase64()
             return Convert.ToBase64String(Unsafe.As<ImmutableArray<byte>, byte[]>(ref bytes));
         }
 
-        /// <inheritdoc cref="IValue.Inspect(bool)"/>
-        public string Inspect(bool loadAll)
+        /// <inheritdoc cref="IValue.Inspect()"/>
+        public string Inspect()
         {
             IEnumerable<string> contents = this.Select(b => $"\\x{b:x2}");
             return $"b\"{string.Join(string.Empty, contents)}\"";
@@ -326,6 +326,6 @@ public string Inspect(bool loadAll)
 
         /// <inheritdoc cref="object.ToString()"/>
         public override string ToString() =>
-            $"{nameof(Bencodex)}.{nameof(Bencodex.Types)}.{nameof(Binary)} {Inspect(false)}";
+            $"{nameof(Bencodex)}.{nameof(Bencodex.Types)}.{nameof(Binary)} {Inspect()}";
     }
 }
diff --git a/Bencodex/Types/Boolean.cs b/Bencodex/Types/Boolean.cs
index 2d1168e..26a99e8 100644
--- a/Bencodex/Types/Boolean.cs
+++ b/Bencodex/Types/Boolean.cs
@@ -88,13 +88,12 @@ public override int GetHashCode()
             return Value.GetHashCode();
         }
 
-        /// <inheritdoc cref="IValue.Inspect(bool)"/>
-        public string Inspect(bool loadAll) =>
-            Value ? "true" : "false";
+        /// <inheritdoc cref="IValue.Inspect()"/>
+        public string Inspect() => Value ? "true" : "false";
 
         /// <inheritdoc cref="object.ToString()"/>
         [Pure]
         public override string ToString() =>
-            $"{nameof(Bencodex)}.{nameof(Types)}.{nameof(Boolean)} {Inspect(false)}";
+            $"{nameof(Bencodex)}.{nameof(Types)}.{nameof(Boolean)} {Inspect()}";
     }
 }
diff --git a/Bencodex/Types/Dictionary.cs b/Bencodex/Types/Dictionary.cs
index cf21856..022c117 100644
--- a/Bencodex/Types/Dictionary.cs
+++ b/Bencodex/Types/Dictionary.cs
@@ -1676,8 +1676,8 @@ public override int GetHashCode()
             => unchecked(_dict.Aggregate(GetType().GetHashCode(), (accum, next)
                 => (accum * 397) ^ ((next.Key.GetHashCode() * 397) ^ next.Value.GetHashCode())));
 
-        /// <inheritdoc cref="IValue.Inspect(bool)"/>
-        public string Inspect(bool loadAll)
+        /// <inheritdoc cref="IValue.Inspect()"/>
+        public string Inspect()
         {
             if (_dict.Count < 1)
             {
@@ -1685,7 +1685,7 @@ public string Inspect(bool loadAll)
             }
 
             IEnumerable<string> pairs = this.Select(kv =>
-                $"  {kv.Key.Inspect(loadAll)}: {kv.Value.Inspect(loadAll).Replace("\n", "\n  ")},\n"
+                $"  {kv.Key.Inspect()}: {kv.Value.Inspect().Replace("\n", "\n  ")},\n"
             ).OrderBy(s => s);
             string pairsString = string.Join(string.Empty, pairs);
             return $"{{\n{pairsString}}}";
@@ -1693,6 +1693,6 @@ public string Inspect(bool loadAll)
 
         /// <inheritdoc cref="object.ToString()"/>
         public override string ToString() =>
-            $"{nameof(Bencodex)}.{nameof(Types)}.{nameof(Dictionary)} {Inspect(false)}";
+            $"{nameof(Bencodex)}.{nameof(Types)}.{nameof(Dictionary)} {Inspect()}";
     }
 }
diff --git a/Bencodex/Types/IValue.cs b/Bencodex/Types/IValue.cs
index e04feee..8e22885 100644
--- a/Bencodex/Types/IValue.cs
+++ b/Bencodex/Types/IValue.cs
@@ -26,13 +26,9 @@ public interface IValue : IEquatable<IValue>
 
         /// <summary>
         /// Gets a human-readable representation for debugging.
-        /// <para>Unloaded values may be omitted.</para>
         /// </summary>
-        /// <param name="loadAll">Load all unloaded values before showing them.  This option
-        /// is applied to subtrees recursively.</param>
         /// <returns>A human-readable representation for debugging, which looks similar to Python's
-        /// literal syntax.  However, if a value is a complex tree and contains any unloaded
-        /// subvalues, these are omitted and their fingerprints are shown instead.</returns>
-        string Inspect(bool loadAll);
+        /// literal syntax.</returns>
+        string Inspect();
     }
 }
diff --git a/Bencodex/Types/Integer.cs b/Bencodex/Types/Integer.cs
index 5b6479c..3f7d13e 100644
--- a/Bencodex/Types/Integer.cs
+++ b/Bencodex/Types/Integer.cs
@@ -223,13 +223,13 @@ public override int GetHashCode()
             return Value.GetHashCode();
         }
 
-        /// <inheritdoc cref="IValue.Inspect(bool)"/>
-        public string Inspect(bool loadAll) =>
+        /// <inheritdoc cref="IValue.Inspect()"/>
+        public string Inspect() =>
             Value.ToString(CultureInfo.InvariantCulture);
 
         /// <inheritdoc cref="object.ToString()"/>
         public override string ToString() =>
-            $"{nameof(Bencodex)}.{nameof(Types)}.{nameof(Integer)} {Inspect(false)}";
+            $"{nameof(Bencodex)}.{nameof(Types)}.{nameof(Integer)} {Inspect()}";
 
         internal long CountDecimalDigits() =>
             Value.Sign switch
diff --git a/Bencodex/Types/List.cs b/Bencodex/Types/List.cs
index 121d816..7c6814d 100644
--- a/Bencodex/Types/List.cs
+++ b/Bencodex/Types/List.cs
@@ -464,10 +464,10 @@ IEqualityComparer<IValue> equalityComparer
         IImmutableList<IValue> IImmutableList<IValue>.SetItem(int index, IValue value) =>
             new List(_values.SetItem(index, value));
 
-        /// <inheritdoc cref="IValue.Inspect(bool)"/>
-        public string Inspect(bool loadAll)
+        /// <inheritdoc cref="IValue.Inspect()"/>
+        public string Inspect()
         {
-            string InspectItem(IValue value, bool load) => value.Inspect(load);
+            string InspectItem(IValue value) => value.Inspect();
 
             string inspection;
             switch (_values.Length)
@@ -483,12 +483,12 @@ public string Inspect(bool loadAll)
                         goto default;
                     }
 
-                    inspection = $"[{InspectItem(first, loadAll)}]";
+                    inspection = $"[{InspectItem(first)}]";
                     break;
 
                 default:
                     IEnumerable<string> elements = _values.Select(v =>
-                        $"  {InspectItem(v, loadAll).Replace("\n", "\n  ")},\n"
+                        $"  {InspectItem(v).Replace("\n", "\n  ")},\n"
                     );
                     inspection = $"[\n{string.Join(string.Empty, elements)}]";
                     break;
@@ -499,6 +499,6 @@ public string Inspect(bool loadAll)
 
         /// <inheritdoc cref="object.ToString()"/>
         public override string ToString() =>
-            $"{nameof(Bencodex)}.{nameof(Types)}.{nameof(List)} {Inspect(false)}";
+            $"{nameof(Bencodex)}.{nameof(Types)}.{nameof(List)} {Inspect()}";
     }
 }
diff --git a/Bencodex/Types/Null.cs b/Bencodex/Types/Null.cs
index b9cdf89..4643e45 100644
--- a/Bencodex/Types/Null.cs
+++ b/Bencodex/Types/Null.cs
@@ -43,8 +43,8 @@ bool IEquatable<IValue>.Equals(IValue other) =>
 
         bool IEquatable<Null>.Equals(Null other) => true;
 
-        /// <inheritdoc cref="IValue.Inspect(bool)"/>
-        public string Inspect(bool loadAll) => "null";
+        /// <inheritdoc cref="IValue.Inspect()"/>
+        public string Inspect() => "null";
 
         /// <inheritdoc cref="object.ToString()"/>
         public override string ToString() =>
diff --git a/Bencodex/Types/Text.cs b/Bencodex/Types/Text.cs
index c8b5ecb..2a12df4 100644
--- a/Bencodex/Types/Text.cs
+++ b/Bencodex/Types/Text.cs
@@ -95,8 +95,8 @@ public int CompareTo(object? obj)
             throw new ArgumentException($"Object must be of type {nameof(Text)}");
         }
 
-        /// <inheritdoc cref="IValue.Inspect(bool)"/>
-        public string Inspect(bool loadAll)
+        /// <inheritdoc cref="IValue.Inspect()"/>
+        public string Inspect()
         {
             string contents = Value
                 .Replace("\\", "\\\\")
@@ -107,6 +107,6 @@ public string Inspect(bool loadAll)
 
         /// <inheritdoc cref="object.ToString()"/>
         public override string ToString() =>
-            $"{nameof(Bencodex)}.{nameof(Types)}.{nameof(Text)} {Inspect(false)}";
+            $"{nameof(Bencodex)}.{nameof(Types)}.{nameof(Text)} {Inspect()}";
     }
 }
diff --git a/CHANGES.md b/CHANGES.md
index b62d7e5..49ff260 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -7,8 +7,10 @@ Version 0.16.0
 To be released.
 
  -  Removed `IValue.Inspection` property.  [[#117]]
+ -  Changed `IValue.Inspect(bool)` to `IValue.Inspect()`.  [[#118]]
 
 [#117]: https://github.com/planetarium/bencodex.net/pull/117
+[#118]: https://github.com/planetarium/bencodex.net/pull/118
 
 
 Version 0.15.0