diff --git a/FirstClassErrors.RequestBinder.UnitTests/BindingContractTests.cs b/FirstClassErrors.RequestBinder.UnitTests/BindingContractTests.cs
index e5fc3c9..aa4a89e 100644
--- a/FirstClassErrors.RequestBinder.UnitTests/BindingContractTests.cs
+++ b/FirstClassErrors.RequestBinder.UnitTests/BindingContractTests.cs
@@ -3,6 +3,8 @@
 using System.Linq.Expressions;
 using System.Reflection;
 
+using FirstClassErrors.Testing;
+
 using NFluent;
 
 #endregion
@@ -30,8 +32,8 @@ public void ConverterMayFailWithAPrimaryPortError() {
         var bind = Bind.PropertiesOf(Request()).FailWith(BookingEnvelopeError.CommandInvalid);
 
         bind.SimpleProperty(r => r.GuestEmail).AsRequired(_ => Outcome<EmailAddress>.Failure(
-            PrimaryPortError.Create(ErrorCode.Create("TEST_PORT_LEVEL_REJECTION"), "Rejected at the port.", Transience.NonTransient)
-                            .WithPublicMessage("Rejected.")));
+            PrimaryPortError.Create(ErrorCode.Create("TEST_PORT_LEVEL_REJECTION"), Any.DiagnosticMessage(), Any.Transience())
+                            .WithPublicMessage(Any.ShortMessage())));
 
         Outcome<string> outcome = bind.New(_ => "never");
         Error invalid = outcome.Error!.InnerErrors.Single();
@@ -44,9 +46,9 @@ public void ConverterFailingWithAnotherFamilyIsABug() {
         var bind = Bind.PropertiesOf(Request()).FailWith(BookingEnvelopeError.CommandInvalid);
 
         InfrastructureError foreignFamily =
-            InfrastructureError.Create(ErrorCode.Create("TEST_FOREIGN_FAMILY"), "A family the port envelope cannot hold.",
-                                       InteractionDirection.Outgoing, Transience.Unknown)
-                               .WithPublicMessage("Foreign.");
+            InfrastructureError.Create(Any.ErrorCode(), Any.DiagnosticMessage(),
+                                       Any.InteractionDirection(), Transience.Unknown)
+                               .WithPublicMessage(Any.ShortMessage());
 
         InvalidOperationException exception = Assert.Throws<InvalidOperationException>(
             () => { bind.SimpleProperty(r => r.GuestEmail).AsRequired(_ => Outcome<EmailAddress>.Failure(foreignFamily)); });
@@ -87,9 +89,9 @@ public void BareNestedElementFailureIsWrapped() {
     }
 
     private static PrimaryPortError LeafPortError() {
-        return PrimaryPortError.Create(ErrorCode.Create("TEST_NESTED_PORT_LEAF"), "A bare port-level leaf, not a build-terminal envelope.",
-                                       Transience.NonTransient)
-                               .WithPublicMessage("Rejected.");
+        return PrimaryPortError.Create(ErrorCode.Create("TEST_NESTED_PORT_LEAF"), Any.DiagnosticMessage(),
+                                       Any.Transience())
+                               .WithPublicMessage(Any.ShortMessage());
     }
 
     [Fact(DisplayName = "A required nested binding that fails with a bare PrimaryPortError leaf (not its build-terminal envelope) is wrapped, so the path survives.")]
diff --git a/FirstClassErrors.RequestBinder.UnitTests/RequestBinderTests.cs b/FirstClassErrors.RequestBinder.UnitTests/RequestBinderTests.cs
index ad52e17..5826766 100644
--- a/FirstClassErrors.RequestBinder.UnitTests/RequestBinderTests.cs
+++ b/FirstClassErrors.RequestBinder.UnitTests/RequestBinderTests.cs
@@ -2,6 +2,8 @@
 
 using System.Reflection;
 
+using FirstClassErrors.Testing;
+
 using NFluent;
 
 #endregion
@@ -24,8 +26,8 @@ private static Outcome<Stay> BindStay(RequestBinder<StayDto> stay) {
     private static Outcome<Stay> AssembleStay(BookingDate checkIn, BookingDate checkOut) {
         return checkOut.Value > checkIn.Value
                    ? Outcome<Stay>.Success(new Stay(checkIn, checkOut))
-                   : Outcome<Stay>.Failure(DomainError.Create(CheckOutNotAfterCheckIn, "Check-out must be after check-in.")
-                                                      .WithPublicMessage("The stay dates are inconsistent."));
+                   : Outcome<Stay>.Failure(DomainError.Create(CheckOutNotAfterCheckIn, Any.DiagnosticMessage())
+                                                      .WithPublicMessage(Any.ShortMessage()));
     }
 
     [Fact(DisplayName = "New assembles the command exactly once when every property bound.")]
diff --git a/FirstClassErrors.UnitTests/ErrorCodeFactory.cs b/FirstClassErrors.UnitTests/ErrorCodeFactory.cs
deleted file mode 100644
index 1734129..0000000
--- a/FirstClassErrors.UnitTests/ErrorCodeFactory.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-namespace FirstClassErrors.UnitTests {
-
-    public static class ErrorCodeFactory {
-
-        #region Static members
-
-        public static ErrorCode CreateAny() {
-            return ErrorCode.Create("ANY");
-        }
-
-        #endregion
-
-    }
-
-}
\ No newline at end of file
diff --git a/FirstClassErrors.UnitTests/ErrorCodeTests.cs b/FirstClassErrors.UnitTests/ErrorCodeTests.cs
index 3a32745..99e9073 100644
--- a/FirstClassErrors.UnitTests/ErrorCodeTests.cs
+++ b/FirstClassErrors.UnitTests/ErrorCodeTests.cs
@@ -1,5 +1,7 @@
 #region Usings declarations
 
+using FirstClassErrors.Testing;
+
 using JetBrains.Annotations;
 
 using NFluent;
@@ -72,7 +74,7 @@ public void ErrorCodesWithDifferentCodesAreNotEqual() {
     [Fact(DisplayName = "An error code compared to null is not equal.")]
     public void ErrorCodeComparedToNullIsNotEqual() {
         // Setup
-        ErrorCode? errorCode = ErrorCode.Create("NULL_TEST");
+        ErrorCode? errorCode = Any.ErrorCode();
 
         // Exercise
         bool result = errorCode.Equals(null);
diff --git a/FirstClassErrors.UnitTests/ErrorContextImmutabilityTests.cs b/FirstClassErrors.UnitTests/ErrorContextImmutabilityTests.cs
index 83cb620..e981da2 100644
--- a/FirstClassErrors.UnitTests/ErrorContextImmutabilityTests.cs
+++ b/FirstClassErrors.UnitTests/ErrorContextImmutabilityTests.cs
@@ -2,6 +2,8 @@
 
 using System.Diagnostics.CodeAnalysis;
 
+using FirstClassErrors.Testing;
+
 using JetBrains.Annotations;
 
 using NFluent;
@@ -31,8 +33,8 @@ public void Dispose() {
     public void TheContextValuesAreReadOnlyAndCannotBeMutated() {
         // Setup
         ErrorContextKey<string> key = ErrorContextKey.Create<string>("K");
-        ErrorContext context = DomainError.Create(ErrorCode.Unspecified, "m",
-                                                  ctx => ctx.Add(key, "value")).WithPublicMessage("m").Context;
+        ErrorContext context = DomainError.Create(Any.ErrorCode(), Any.DiagnosticMessage(),
+                                                  ctx => ctx.Add(key, Any.String())).WithPublicMessage(Any.ShortMessage()).Context;
 
         // Exercise & verify
         Check.ThatCode(() => ((IDictionary<ErrorContextKey, object?>)context.Values).Clear())
@@ -43,8 +45,8 @@ public void TheContextValuesAreReadOnlyAndCannotBeMutated() {
     public void AnEntryWhoseStoredValueIsNullIsPresentButReportedAsNotFound() {
         // Setup
         ErrorContextKey<string> key = ErrorContextKey.Create<string>("K");
-        ErrorContext context = DomainError.Create(ErrorCode.Unspecified, "m",
-                                                  ctx => ctx.Add(key, null)).WithPublicMessage("m").Context;
+        ErrorContext context = DomainError.Create(Any.ErrorCode(), Any.DiagnosticMessage(),
+                                                  ctx => ctx.Add(key, null)).WithPublicMessage(Any.ShortMessage()).Context;
 
         // Exercise
         bool found = context.TryGet(key, out _);
diff --git a/FirstClassErrors.UnitTests/ErrorDefensiveTests.cs b/FirstClassErrors.UnitTests/ErrorDefensiveTests.cs
index 51d7a3d..fe74bc8 100644
--- a/FirstClassErrors.UnitTests/ErrorDefensiveTests.cs
+++ b/FirstClassErrors.UnitTests/ErrorDefensiveTests.cs
@@ -2,6 +2,8 @@
 
 using System.Diagnostics.CodeAnalysis;
 
+using FirstClassErrors.Testing;
+
 using JetBrains.Annotations;
 
 using NFluent;
@@ -30,7 +32,7 @@ public void Dispose() {
     [Fact(DisplayName = "A null error code is replaced by the unspecified error code.")]
     public void ANullErrorCodeIsReplacedByTheUnspecifiedErrorCode() {
         // Exercise
-        DomainError error = DomainError.Create(null!, "diagnostic").WithPublicMessage("short");
+        DomainError error = DomainError.Create(null!, Any.DiagnosticMessage()).WithPublicMessage(Any.ShortMessage());
 
         // Verify
         Check.That(error.Code).IsSameReferenceAs(ErrorCode.Unspecified);
@@ -39,7 +41,7 @@ public void ANullErrorCodeIsReplacedByTheUnspecifiedErrorCode() {
     [Fact(DisplayName = "A null diagnostic message is replaced by a fallback sentinel.")]
     public void ANullDiagnosticMessageIsReplacedByAFallbackSentinel() {
         // Exercise
-        DomainError error = DomainError.Create(ErrorCode.Unspecified, null!).WithPublicMessage("short");
+        DomainError error = DomainError.Create(Any.ErrorCode(), null!).WithPublicMessage(Any.ShortMessage());
 
         // Verify
         Check.That(error.DiagnosticMessage).IsEqualTo(Error.MissingDiagnosticMessage);
@@ -51,7 +53,7 @@ public void ANullDiagnosticMessageIsReplacedByAFallbackSentinel() {
     [InlineData("      ")]
     public void AnEmptyOrWhitespaceDiagnosticMessageIsReplacedByAFallbackSentinel(string value) {
         // Exercise
-        DomainError error = DomainError.Create(ErrorCode.Unspecified, value).WithPublicMessage("short");
+        DomainError error = DomainError.Create(Any.ErrorCode(), value).WithPublicMessage(Any.ShortMessage());
 
         // Verify
         Check.That(error.DiagnosticMessage).IsEqualTo(Error.MissingDiagnosticMessage);
@@ -60,7 +62,7 @@ public void AnEmptyOrWhitespaceDiagnosticMessageIsReplacedByAFallbackSentinel(st
     [Fact(DisplayName = "The diagnostic message is trimmed.")]
     public void TheDiagnosticMessageIsTrimmed() {
         // Exercise
-        DomainError error = DomainError.Create(ErrorCode.Unspecified, "  hello  ").WithPublicMessage("short");
+        DomainError error = DomainError.Create(Any.ErrorCode(), "  hello  ").WithPublicMessage(Any.ShortMessage());
 
         // Verify
         Check.That(error.DiagnosticMessage).IsEqualTo("hello");
@@ -69,7 +71,7 @@ public void TheDiagnosticMessageIsTrimmed() {
     [Fact(DisplayName = "A null short message is replaced by a fallback sentinel.")]
     public void ANullShortMessageIsReplacedByAFallbackSentinel() {
         // Exercise
-        DomainError error = DomainError.Create(ErrorCode.Unspecified, "diagnostic").WithPublicMessage(null!);
+        DomainError error = DomainError.Create(Any.ErrorCode(), Any.DiagnosticMessage()).WithPublicMessage(null!);
 
         // Verify
         Check.That(error.ShortMessage).IsEqualTo(Error.MissingShortMessage);
@@ -81,7 +83,7 @@ public void ANullShortMessageIsReplacedByAFallbackSentinel() {
     [InlineData("      ")]
     public void AnEmptyOrWhitespaceShortMessageIsReplacedByAFallbackSentinel(string value) {
         // Exercise
-        DomainError error = DomainError.Create(ErrorCode.Unspecified, "diagnostic").WithPublicMessage(value);
+        DomainError error = DomainError.Create(Any.ErrorCode(), Any.DiagnosticMessage()).WithPublicMessage(value);
 
         // Verify
         Check.That(error.ShortMessage).IsEqualTo(Error.MissingShortMessage);
@@ -90,7 +92,7 @@ public void AnEmptyOrWhitespaceShortMessageIsReplacedByAFallbackSentinel(string
     [Fact(DisplayName = "A missing diagnostic message is recorded in the context under #MISSING_REQUIRED_MESSAGE.")]
     public void AMissingDiagnosticMessageIsRecordedInTheContext() {
         // Exercise
-        DomainError error = DomainError.Create(ErrorCode.Unspecified, null!).WithPublicMessage("short");
+        DomainError error = DomainError.Create(Any.ErrorCode(), null!).WithPublicMessage(Any.ShortMessage());
 
         // Verify
         Check.That(error.Context.Values.ContainsKey(ErrorContextKey.MissingRequiredMessages)).IsTrue();
@@ -102,7 +104,7 @@ public void AMissingDiagnosticMessageIsRecordedInTheContext() {
     [Fact(DisplayName = "Missing diagnostic and short messages are both recorded in the context.")]
     public void MissingDiagnosticAndShortMessagesAreBothRecordedInTheContext() {
         // Exercise
-        DomainError error = DomainError.Create(ErrorCode.Unspecified, null!).WithPublicMessage(null!);
+        DomainError error = DomainError.Create(Any.ErrorCode(), null!).WithPublicMessage(null!);
 
         // Verify
         IReadOnlyList<string> missing = (IReadOnlyList<string>)error.Context.Values[ErrorContextKey.MissingRequiredMessages]!;
@@ -112,7 +114,7 @@ public void MissingDiagnosticAndShortMessagesAreBothRecordedInTheContext() {
     [Fact(DisplayName = "Present mandatory messages leave no #MISSING_REQUIRED_MESSAGE entry in the context.")]
     public void PresentMandatoryMessagesLeaveNoMissingEntryInTheContext() {
         // Exercise
-        DomainError error = DomainError.Create(ErrorCode.Unspecified, "diagnostic").WithPublicMessage("short");
+        DomainError error = DomainError.Create(Any.ErrorCode(), Any.DiagnosticMessage()).WithPublicMessage(Any.ShortMessage());
 
         // Verify
         Check.That(error.Context.Values.ContainsKey(ErrorContextKey.MissingRequiredMessages)).IsFalse();
@@ -121,7 +123,7 @@ public void PresentMandatoryMessagesLeaveNoMissingEntryInTheContext() {
     [Fact(DisplayName = "The short message is trimmed.")]
     public void TheShortMessageIsTrimmed() {
         // Exercise
-        DomainError error = DomainError.Create(ErrorCode.Unspecified, "diagnostic").WithPublicMessage("  short  ");
+        DomainError error = DomainError.Create(Any.ErrorCode(), Any.DiagnosticMessage()).WithPublicMessage("  short  ");
 
         // Verify
         Check.That(error.ShortMessage).IsEqualTo("short");
@@ -130,7 +132,7 @@ public void TheShortMessageIsTrimmed() {
     [Fact(DisplayName = "A null detailed message leaves the detailed message null.")]
     public void ANullDetailedMessageLeavesTheDetailedMessageNull() {
         // Exercise
-        DomainError error = DomainError.Create(ErrorCode.Unspecified, "diagnostic").WithPublicMessage("short", null);
+        DomainError error = DomainError.Create(Any.ErrorCode(), Any.DiagnosticMessage()).WithPublicMessage(Any.ShortMessage(), null);
 
         // Verify
         Check.That(error.DetailedMessage).IsNull();
@@ -142,7 +144,7 @@ public void ANullDetailedMessageLeavesTheDetailedMessageNull() {
     [InlineData("      ")]
     public void AnEmptyOrWhitespaceDetailedMessageLeavesTheDetailedMessageNull(string value) {
         // Exercise
-        DomainError error = DomainError.Create(ErrorCode.Unspecified, "diagnostic").WithPublicMessage("short", value);
+        DomainError error = DomainError.Create(Any.ErrorCode(), Any.DiagnosticMessage()).WithPublicMessage(Any.ShortMessage(), value);
 
         // Verify
         Check.That(error.DetailedMessage).IsNull();
@@ -151,7 +153,7 @@ public void AnEmptyOrWhitespaceDetailedMessageLeavesTheDetailedMessageNull(strin
     [Fact(DisplayName = "A detailed message is trimmed when provided.")]
     public void ADetailedMessageIsTrimmedWhenProvided() {
         // Exercise
-        DomainError error = DomainError.Create(ErrorCode.Unspecified, "diagnostic").WithPublicMessage("short", "  detailed  ");
+        DomainError error = DomainError.Create(Any.ErrorCode(), Any.DiagnosticMessage()).WithPublicMessage(Any.ShortMessage(), "  detailed  ");
 
         // Verify
         Check.That(error.DetailedMessage).IsEqualTo("detailed");
@@ -160,8 +162,8 @@ public void ADetailedMessageIsTrimmedWhenProvided() {
     [Fact(DisplayName = "A configure-context delegate that throws is captured into the context.")]
     public void AConfigureContextDelegateThatThrowsIsCapturedIntoTheContext() {
         // Exercise
-        DomainError error = DomainError.Create(ErrorCode.Unspecified, "diagnostic", _ => throw new InvalidOperationException("boom"))
-                                       .WithPublicMessage("short");
+        DomainError error = DomainError.Create(Any.ErrorCode(), Any.DiagnosticMessage(), _ => throw new InvalidOperationException("boom"))
+                                       .WithPublicMessage(Any.ShortMessage());
 
         // Verify
         Check.That(error.Context.IsEmpty).IsFalse();
@@ -178,12 +180,12 @@ public void AConfigureContextDelegateThatThrowsPreservesTheEntriesAddedBeforeThe
         ErrorContextKey<string> beforeKey = ErrorContextKey.Create<string>("BeforeFailure");
 
         // Exercise
-        DomainError error = DomainError.Create(ErrorCode.Unspecified, "diagnostic", builder => {
+        DomainError error = DomainError.Create(Any.ErrorCode(), Any.DiagnosticMessage(), builder => {
                                            builder.Add(beforeKey, "kept");
 
                                            throw new InvalidOperationException("boom");
                                        })
-                                       .WithPublicMessage("short");
+                                       .WithPublicMessage(Any.ShortMessage());
 
         // Verify — the entry added before the failure survives alongside the captured exception.
         bool found = error.Context.TryGet(beforeKey, out string? kept);
@@ -198,7 +200,7 @@ public void InnerErrorsAreStoredAsADefensiveCopyOfTheProvidedCollection() {
         List<DomainError> innerErrors = new() {
             ErrorFactory.Domain(ErrorCode.Unspecified, "first")
         };
-        DomainError error = DomainError.Create(ErrorCode.Unspecified, "diagnostic", innerErrors).WithPublicMessage("short");
+        DomainError error = DomainError.Create(Any.ErrorCode(), Any.DiagnosticMessage(), innerErrors).WithPublicMessage(Any.ShortMessage());
 
         // Exercise
         innerErrors.Add(ErrorFactory.Domain(ErrorCode.Unspecified, "second"));
@@ -217,7 +219,7 @@ public void NullEntriesInTheProvidedInnerErrorsCollectionAreFilteredOut() {
         };
 
         // Exercise
-        DomainError error = DomainError.Create(ErrorCode.Unspecified, "diagnostic", innerErrors).WithPublicMessage("short");
+        DomainError error = DomainError.Create(Any.ErrorCode(), Any.DiagnosticMessage(), innerErrors).WithPublicMessage(Any.ShortMessage());
 
         // Verify
         Check.That(error.InnerErrors).CountIs(2);
@@ -230,7 +232,7 @@ public void ACollectionMadeOnlyOfNullInnerErrorsYieldsAnEmptyInnerErrorsList() {
         List<DomainError> innerErrors = new() { null!, null! };
 
         // Exercise
-        DomainError error = DomainError.Create(ErrorCode.Unspecified, "diagnostic", innerErrors).WithPublicMessage("short");
+        DomainError error = DomainError.Create(Any.ErrorCode(), Any.DiagnosticMessage(), innerErrors).WithPublicMessage(Any.ShortMessage());
 
         // Verify
         Check.That(error.InnerErrors).IsEmpty();
@@ -239,7 +241,7 @@ public void ACollectionMadeOnlyOfNullInnerErrorsYieldsAnEmptyInnerErrorsList() {
     [Fact(DisplayName = "The string representation combines the diagnostic message and the code.")]
     public void TheStringRepresentationCombinesTheDiagnosticMessageAndTheCode() {
         // Exercise
-        DomainError error = DomainError.Create(ErrorCode.Unspecified, "boom").WithPublicMessage("short");
+        DomainError error = DomainError.Create(ErrorCode.Unspecified, "boom").WithPublicMessage(Any.ShortMessage());
 
         // Verify
         Check.That(error.ToString()).IsEqualTo("boom (#UNSPECIFIED)");
diff --git a/FirstClassErrors.UnitTests/ErrorDescriptionTests.cs b/FirstClassErrors.UnitTests/ErrorDescriptionTests.cs
index c90a5d4..2b96b64 100644
--- a/FirstClassErrors.UnitTests/ErrorDescriptionTests.cs
+++ b/FirstClassErrors.UnitTests/ErrorDescriptionTests.cs
@@ -1,5 +1,7 @@
 #region Usings declarations
 
+using FirstClassErrors.Testing;
+
 using JetBrains.Annotations;
 
 using NFluent;
@@ -14,7 +16,7 @@ public sealed class ErrorDescriptionTests {
     [Fact(DisplayName = "An error description cannot be created with a null short message.")]
     public void AnErrorDescriptionCannotBeCreatedWithANullShortMessage() {
         // Exercise & verify
-        Check.ThatCode(() => new ErrorDescription(null!, "diagnostic"))
+        Check.ThatCode(() => new ErrorDescription(null!, Any.DiagnosticMessage()))
              .Throws<ArgumentNullException>();
     }
 
@@ -24,14 +26,14 @@ public void AnErrorDescriptionCannotBeCreatedWithANullShortMessage() {
     [InlineData("        ")]
     public void AnErrorDescriptionCannotBeCreatedWithAnEmptyOrWhitespaceShortMessage(string value) {
         // Exercise & verify
-        Check.ThatCode(() => new ErrorDescription(value, "diagnostic"))
+        Check.ThatCode(() => new ErrorDescription(value, Any.DiagnosticMessage()))
              .Throws<ArgumentException>();
     }
 
     [Fact(DisplayName = "An error description cannot be created with a null diagnostic message.")]
     public void AnErrorDescriptionCannotBeCreatedWithANullDiagnosticMessage() {
         // Exercise & verify
-        Check.ThatCode(() => new ErrorDescription("short", null!))
+        Check.ThatCode(() => new ErrorDescription(Any.ShortMessage(), null!))
              .Throws<ArgumentNullException>();
     }
 
@@ -41,14 +43,14 @@ public void AnErrorDescriptionCannotBeCreatedWithANullDiagnosticMessage() {
     [InlineData("        ")]
     public void AnErrorDescriptionCannotBeCreatedWithAnEmptyOrWhitespaceDiagnosticMessage(string value) {
         // Exercise & verify
-        Check.ThatCode(() => new ErrorDescription("short", value))
+        Check.ThatCode(() => new ErrorDescription(Any.ShortMessage(), value))
              .Throws<ArgumentException>();
     }
 
     [Fact(DisplayName = "An error description trims the short message.")]
     public void AnErrorDescriptionTrimsTheShortMessage() {
         // Exercise
-        ErrorDescription description = new("  Short message  ", "Diagnostic message");
+        ErrorDescription description = new("  Short message  ", Any.DiagnosticMessage());
 
         // Verify
         Check.That(description.ShortMessage).IsEqualTo("Short message");
@@ -57,7 +59,7 @@ public void AnErrorDescriptionTrimsTheShortMessage() {
     [Fact(DisplayName = "An error description trims the diagnostic message.")]
     public void AnErrorDescriptionTrimsTheDiagnosticMessage() {
         // Exercise
-        ErrorDescription description = new("Short message", "  Diagnostic message  ");
+        ErrorDescription description = new(Any.ShortMessage(), "  Diagnostic message  ");
 
         // Verify
         Check.That(description.DiagnosticMessage).IsEqualTo("Diagnostic message");
@@ -66,7 +68,7 @@ public void AnErrorDescriptionTrimsTheDiagnosticMessage() {
     [Fact(DisplayName = "An error description sets detailed message to null when not provided.")]
     public void AnErrorDescriptionSetsDetailedMessageToNullWhenNotProvided() {
         // Exercise
-        ErrorDescription description = new("Short message", "Diagnostic message");
+        ErrorDescription description = new(Any.ShortMessage(), Any.DiagnosticMessage());
 
         // Verify
         Check.That(description.DetailedMessage).IsNull();
@@ -78,7 +80,7 @@ public void AnErrorDescriptionSetsDetailedMessageToNullWhenNotProvided() {
     [InlineData("      ")]
     public void AnErrorDescriptionSetsDetailedMessageToNullWhenItIsEmptyOrWhitespace(string value) {
         // Exercise
-        ErrorDescription description = new("Short message", "Diagnostic message", value);
+        ErrorDescription description = new(Any.ShortMessage(), Any.DiagnosticMessage(), value);
 
         // Verify
         Check.That(description.DetailedMessage).IsNull();
@@ -87,7 +89,7 @@ public void AnErrorDescriptionSetsDetailedMessageToNullWhenItIsEmptyOrWhitespace
     [Fact(DisplayName = "An error description trims the detailed message when provided.")]
     public void AnErrorDescriptionTrimsTheDetailedMessageWhenProvided() {
         // Exercise
-        ErrorDescription description = new("Short message", "Diagnostic message", "  Detailed  ");
+        ErrorDescription description = new(Any.ShortMessage(), Any.DiagnosticMessage(), "  Detailed  ");
 
         // Verify
         Check.That(description.DetailedMessage).IsEqualTo("Detailed");
diff --git a/FirstClassErrors.UnitTests/ErrorDiagnosticTests.cs b/FirstClassErrors.UnitTests/ErrorDiagnosticTests.cs
index 887cb73..87d6afb 100644
--- a/FirstClassErrors.UnitTests/ErrorDiagnosticTests.cs
+++ b/FirstClassErrors.UnitTests/ErrorDiagnosticTests.cs
@@ -1,5 +1,7 @@
 #region Usings declarations
 
+using FirstClassErrors.Testing;
+
 using JetBrains.Annotations;
 
 using NFluent;
@@ -14,14 +16,14 @@ public sealed class ErrorDiagnosticTests {
     [Fact(DisplayName = "An error diagnostic cannot be created with a null cause.")]
     public void AnErrorDiagnosticCannotBeCreatedWithANullCause() {
         // Exercise & verify
-        Check.ThatCode(() => new ErrorDiagnostic(null!, ErrorOrigin.Internal, StringFactory.AnyAnalysisLead()))
+        Check.ThatCode(() => new ErrorDiagnostic(null!, Any.ErrorOrigin(), StringFactory.AnyAnalysisLead()))
              .Throws<ArgumentNullException>();
     }
 
     [Fact(DisplayName = "An error diagnostic cannot be created with a null analysis lead.")]
     public void AnErrorDiagnosticCannotBeCreatedWithANullAnalysisLead() {
         // Exercise & verify
-        Check.ThatCode(() => new ErrorDiagnostic(StringFactory.AnyCause(), ErrorOrigin.External, null!))
+        Check.ThatCode(() => new ErrorDiagnostic(StringFactory.AnyCause(), Any.ErrorOrigin(), null!))
              .Throws<ArgumentNullException>();
     }
 
@@ -31,7 +33,7 @@ public void AnErrorDiagnosticCannotBeCreatedWithANullAnalysisLead() {
     [InlineData("     ")]
     public void AnErrorDiagnosticCannotBeCreatedWithAnEmptyOrWhitespaceCause(string value) {
         // Exercise & verify
-        Check.ThatCode(() => new ErrorDiagnostic(value, ErrorOrigin.Internal, StringFactory.AnyAnalysisLead()))
+        Check.ThatCode(() => new ErrorDiagnostic(value, Any.ErrorOrigin(), StringFactory.AnyAnalysisLead()))
              .Throws<ArgumentException>();
     }
 
@@ -41,14 +43,14 @@ public void AnErrorDiagnosticCannotBeCreatedWithAnEmptyOrWhitespaceCause(string
     [InlineData("     ")]
     public void AnErrorDiagnosticCannotBeCreatedWithAnEmptyOrWhitespaceAnalysisLead(string value) {
         // Exercise & verify
-        Check.ThatCode(() => new ErrorDiagnostic(StringFactory.AnyCause(), ErrorOrigin.Internal, value))
+        Check.ThatCode(() => new ErrorDiagnostic(StringFactory.AnyCause(), Any.ErrorOrigin(), value))
              .Throws<ArgumentException>();
     }
 
     [Fact(DisplayName = "An error diagnostic normalizes the cause by removing surrounding whitespace.")]
     public void AnErrorDiagnosticTrimsTheCause() {
         // Exercise
-        ErrorDiagnostic diagnostic = new("  Invalid input.  ", ErrorOrigin.External, StringFactory.AnyAnalysisLead());
+        ErrorDiagnostic diagnostic = new("  Invalid input.  ", Any.ErrorOrigin(), StringFactory.AnyAnalysisLead());
 
         // Verify
         Check.That(diagnostic.PossibleCause).IsEqualTo("Invalid input.");
@@ -57,7 +59,7 @@ public void AnErrorDiagnosticTrimsTheCause() {
     [Fact(DisplayName = "An error diagnostic normalizes the analysis lead by removing surrounding whitespace.")]
     public void AnErrorDiagnosticTrimsTheAnalysisLead() {
         // Exercise
-        ErrorDiagnostic diagnostic = new(StringFactory.AnyCause(), ErrorOrigin.Internal, "  Inspect payload  ");
+        ErrorDiagnostic diagnostic = new(StringFactory.AnyCause(), Any.ErrorOrigin(), "  Inspect payload  ");
 
         // Verify
         Check.That(diagnostic.AnalysisHint).IsEqualTo("Inspect payload");
diff --git a/FirstClassErrors.UnitTests/ErrorDocumentationBuilderTests.cs b/FirstClassErrors.UnitTests/ErrorDocumentationBuilderTests.cs
index 606f213..0545aa8 100644
--- a/FirstClassErrors.UnitTests/ErrorDocumentationBuilderTests.cs
+++ b/FirstClassErrors.UnitTests/ErrorDocumentationBuilderTests.cs
@@ -2,6 +2,8 @@
 
 using System.Diagnostics.CodeAnalysis;
 
+using FirstClassErrors.Testing;
+
 using JetBrains.Annotations;
 
 using NFluent;
@@ -56,7 +58,7 @@ public void AnErrorDocumentationTitleCannotBeEmptyOrWhitespace(string title) {
     public void AnErrorDocumentationTitleIsTrimmed() {
         // Setup
         ErrorDocumentationBuilder builder             = new();
-        ErrorCode                 anyErrorCode        = ErrorCodeFactory.CreateAny();
+        ErrorCode                 anyErrorCode        = Any.ErrorCode();
         string                    anyErrorLongMessage = StringFactory.AnyErrorLongMessage();
 
         // Exercise
@@ -85,7 +87,7 @@ public void AnErrorDocumentationDescriptionCannotBeNull() {
     public void AnErrorDocumentationDescriptionIsTrimmed() {
         // Setup
         ErrorDocumentationBuilder builder             = new();
-        ErrorCode                 anyErrorCode        = ErrorCodeFactory.CreateAny();
+        ErrorCode                 anyErrorCode        = Any.ErrorCode();
         string                    anyTitle            = StringFactory.AnyTitle();
         string                    anyErrorLongMessage = StringFactory.AnyErrorLongMessage();
 
@@ -115,7 +117,7 @@ public void AnErrorDocumentationRuleCannotBeNull() {
     public void AnErrorDocumentationRuleIsTrimmed() {
         // Setup
         ErrorDocumentationBuilder builder             = new();
-        ErrorCode                 anyErrorCode        = ErrorCodeFactory.CreateAny();
+        ErrorCode                 anyErrorCode        = Any.ErrorCode();
         string                    anyTitle            = StringFactory.AnyTitle();
         string                    anyExplanation      = StringFactory.AnyExplanation();
         string                    anyErrorLongMessage = StringFactory.AnyErrorLongMessage();
@@ -136,7 +138,7 @@ public void AnErrorDocumentationRuleIsTrimmed() {
     public void AnErrorDocumentationCanBeBuiltWithoutARule() {
         // Setup
         ErrorDocumentationBuilder builder             = new();
-        ErrorCode                 anyErrorCode        = ErrorCodeFactory.CreateAny();
+        ErrorCode                 anyErrorCode        = Any.ErrorCode();
         string                    anyTitle            = StringFactory.AnyTitle();
         string                    anyExplanation      = StringFactory.AnyExplanation();
         string                    anyErrorLongMessage = StringFactory.AnyErrorLongMessage();
@@ -191,8 +193,8 @@ public void AnErrorDocumentationBuilderRejectsANullExampleFactoryAmongTheProvide
         // Setup
         ErrorDocumentationBuilder builder = new();
 
-        ErrorCode         code  = ErrorCode.Create("ANY_CODE");
-        Func<DomainError> valid = () => ErrorFactory.Domain(code, "boom");
+        ErrorCode         code  = Any.ErrorCode();
+        Func<DomainError> valid = () => ErrorFactory.Domain(code, Any.DiagnosticMessage());
 
         // Exercise & verify
         Check.ThatCode(() => builder.WithExamples(valid, null!))
@@ -232,8 +234,8 @@ public void AnErrorDocumentationBuilderRejectsInconsistentErrorCodesAcrossExampl
         ErrorCode codeA = ErrorCode.Create("CODE_A");
         ErrorCode codeB = ErrorCode.Create("CODE_B");
 
-        Func<DomainError> first  = () => ErrorFactory.Domain(codeA, "m1");
-        Func<DomainError> second = () => ErrorFactory.Domain(codeB, "m2");
+        Func<DomainError> first  = () => ErrorFactory.Domain(codeA, Any.DiagnosticMessage());
+        Func<DomainError> second = () => ErrorFactory.Domain(codeB, Any.DiagnosticMessage());
 
         // Exercise & verify
         Check.ThatCode(() => builder.WithExamples(first, second))
@@ -270,8 +272,8 @@ public void AnErrorDocumentationBuilderIncludesTheProvidedDiagnostics() {
         ErrorDiagnostic first  = new("cause-1", ErrorOrigin.External, "lead-1");
         ErrorDiagnostic second = new("cause-2", ErrorOrigin.Internal, "lead-2");
 
-        ErrorCode         code    = ErrorCode.Create("ANY_CODE");
-        Func<DomainError> example = () => ErrorFactory.Domain(code, "boom");
+        ErrorCode         code    = Any.ErrorCode();
+        Func<DomainError> example = () => ErrorFactory.Domain(code, Any.DiagnosticMessage());
 
         // Exercise
         ErrorDocumentation doc = builder
@@ -296,8 +298,8 @@ public void AnErrorDocumentationBuilderIncludesDiagnosticsAddedIncrementally() {
         // Setup
         ErrorDocumentationBuilder builder = new();
 
-        ErrorCode         code    = ErrorCode.Create("ANY_CODE");
-        Func<DomainError> example = () => ErrorFactory.Domain(code, "boom");
+        ErrorCode         code    = Any.ErrorCode();
+        Func<DomainError> example = () => ErrorFactory.Domain(code, Any.DiagnosticMessage());
 
         // Exercise
         ErrorDocumentation doc = builder
@@ -316,23 +318,23 @@ public void AnErrorDocumentationBuilderAggregatesContextEntriesByKeyName() {
         ErrorContextKey<string> userId        = ErrorContextKey.Create<string>("UserId", "User identifier.");
         ErrorContextKey<string> correlationId = ErrorContextKey.Create<string>("CorrelationId", "Correlation identifier.");
 
-        ErrorCode code = ErrorCode.Create("ANY_CODE");
+        ErrorCode code = Any.ErrorCode();
 
         Func<DomainError> ex1 = () => DomainError.Create(
             code,
-            "m1",
+            Any.DiagnosticMessage(),
             ctx => {
                 ctx.Add(userId, "u-1");
                 ctx.Add(correlationId, "c-1");
-            }).WithPublicMessage("m1");
+            }).WithPublicMessage(Any.ShortMessage());
 
         Func<DomainError> ex2 = () => DomainError.Create(
             code,
-            "m2",
+            Any.DiagnosticMessage(),
             ctx => {
                 ctx.Add(userId, "u-2");
                 ctx.Add(correlationId, "c-1");
-            }).WithPublicMessage("m2");
+            }).WithPublicMessage(Any.ShortMessage());
 
         // Exercise
         ErrorDocumentation doc = new ErrorDocumentationBuilder()
@@ -357,17 +359,17 @@ public void AnErrorDocumentationBuilderAggregatesContextEntriesByKeyName() {
     public void AnErrorDocumentationBuilderExcludesNullContextExampleValues() {
         // Setup
         ErrorContextKey<string> optionalInfo = ErrorContextKey.Create<string>("OptionalInfo", "Optional info.");
-        ErrorCode               code         = ErrorCode.Create("ANY_CODE");
+        ErrorCode               code         = Any.ErrorCode();
 
         Func<DomainError> ex1 = () => DomainError.Create(
             code,
-            "m1",
-            ctx => ctx.Add(optionalInfo, null)).WithPublicMessage("m1");
+            Any.DiagnosticMessage(),
+            ctx => ctx.Add(optionalInfo, null)).WithPublicMessage(Any.ShortMessage());
 
         Func<DomainError> ex2 = () => DomainError.Create(
             code,
-            "m2",
-            ctx => ctx.Add(optionalInfo, "x")).WithPublicMessage("m2");
+            Any.DiagnosticMessage(),
+            ctx => ctx.Add(optionalInfo, "x")).WithPublicMessage(Any.ShortMessage());
 
         // Exercise
         ErrorDocumentation doc = new ErrorDocumentationBuilder()
@@ -384,17 +386,17 @@ public void AnErrorDocumentationBuilderDeduplicatesContextExampleValuesByTheirRe
         // apply to the rendered string, not to object identity — otherwise reference-unequal values that look identical
         // in the documentation would appear twice.
         ErrorContextKey<Label> label = ErrorContextKey.Create<Label>("Label", "A label.");
-        ErrorCode              code  = ErrorCode.Create("ANY_CODE");
+        ErrorCode              code  = Any.ErrorCode();
 
         Func<DomainError> ex1 = () => DomainError.Create(
             code,
-            "m1",
-            ctx => ctx.Add(label, new Label("same"))).WithPublicMessage("m1");
+            Any.DiagnosticMessage(),
+            ctx => ctx.Add(label, new Label("same"))).WithPublicMessage(Any.ShortMessage());
 
         Func<DomainError> ex2 = () => DomainError.Create(
             code,
-            "m2",
-            ctx => ctx.Add(label, new Label("same"))).WithPublicMessage("m2");
+            Any.DiagnosticMessage(),
+            ctx => ctx.Add(label, new Label("same"))).WithPublicMessage(Any.ShortMessage());
 
         // Exercise
         ErrorDocumentation doc = new ErrorDocumentationBuilder()
@@ -432,9 +434,9 @@ public void DiagnosticsCanBeAddedThroughTheDiagnosticsStageInterface() {
         ErrorDocumentationBuilder builder = new();
         IErrorDiagnosticsStage    stage   = builder;
 
-        ErrorCode code = ErrorCode.Create("ANY_CODE");
+        ErrorCode code = Any.ErrorCode();
         Func<DomainError> example =
-            () => ErrorFactory.Domain(code, "boom");
+            () => ErrorFactory.Domain(code, Any.DiagnosticMessage());
 
         // Exercise
         ErrorDocumentation doc = stage
diff --git a/FirstClassErrors.UnitTests/ErrorTests.cs b/FirstClassErrors.UnitTests/ErrorTests.cs
index fcde096..70e60ee 100644
--- a/FirstClassErrors.UnitTests/ErrorTests.cs
+++ b/FirstClassErrors.UnitTests/ErrorTests.cs
@@ -34,8 +34,8 @@ public void Dispose() {
     [Fact(DisplayName = "An error has a unique instance identifier.")]
     public void ADiagnosableExceptionHasAUniqueInstanceIdentifier() {
         // Setup
-        ErrorCode anyErrorCode    = ErrorCodeFactory.CreateAny();
-        string    anyErrorMessage = ErrorMessageFactory.CreateAnyMessage();
+        ErrorCode anyErrorCode    = Any.ErrorCode();
+        string    anyErrorMessage = Any.DiagnosticMessage();
 
         // Exercise
         DomainError firstError  = DomainError.Create(anyErrorCode, anyErrorMessage).WithPublicMessage(anyErrorMessage);
@@ -50,8 +50,8 @@ public void ADiagnosableExceptionHasAUniqueInstanceIdentifier() {
     [Fact(DisplayName = "An error captures its occurrence time in UTC.")]
     public void ADiagnosableExceptionCapturesItsOccurrenceTimeInUtc() {
         // Setup
-        ErrorCode      anyErrorCode    = ErrorCodeFactory.CreateAny();
-        string         anyErrorMessage = ErrorMessageFactory.CreateAnyMessage();
+        ErrorCode      anyErrorCode    = Any.ErrorCode();
+        string         anyErrorMessage = Any.DiagnosticMessage();
         DateTimeOffset before          = DateTimeOffset.UtcNow;
 
         // Exercise
@@ -72,8 +72,8 @@ public void ADiagnosableExceptionCapturesItsOccurrenceTimeInUtc() {
     [Fact(DisplayName = "An error captures its occurrence time from the ambient clock.")]
     public void AnErrorCapturesItsOccurrenceTimeFromTheAmbientClock() {
         // Setup
-        ErrorCode      anyErrorCode    = ErrorCodeFactory.CreateAny();
-        string         anyErrorMessage = ErrorMessageFactory.CreateAnyMessage();
+        ErrorCode      anyErrorCode    = Any.ErrorCode();
+        string         anyErrorMessage = Any.DiagnosticMessage();
         DateTimeOffset instant         = new(2026, 7, 8, 10, 30, 0, TimeSpan.Zero);
         IClock         clock           = Substitute.For<IClock>();
         clock.UtcNow.Returns(instant);
@@ -94,8 +94,8 @@ public void AnErrorCapturesItsOccurrenceTimeFromTheAmbientClock() {
     [Fact(DisplayName = "An error captures its instance id from the ambient source.")]
     public void AnErrorCapturesItsInstanceIdFromTheAmbientSource() {
         // Setup
-        ErrorCode anyErrorCode    = ErrorCodeFactory.CreateAny();
-        string    anyErrorMessage = ErrorMessageFactory.CreateAnyMessage();
+        ErrorCode anyErrorCode    = Any.ErrorCode();
+        string    anyErrorMessage = Any.DiagnosticMessage();
         Guid      fixedId         = new("11111111-1111-1111-1111-111111111111");
 
         // Exercise
@@ -114,8 +114,8 @@ public void AnErrorCapturesItsInstanceIdFromTheAmbientSource() {
     [Fact(DisplayName = "A custom id source assigns distinct identifiers within the scope.")]
     public void ACustomIdSourceAssignsDistinctIdentifiersWithinTheScope() {
         // Setup
-        ErrorCode anyErrorCode    = ErrorCodeFactory.CreateAny();
-        string    anyErrorMessage = ErrorMessageFactory.CreateAnyMessage();
+        ErrorCode anyErrorCode    = Any.ErrorCode();
+        string    anyErrorMessage = Any.DiagnosticMessage();
         int       counter         = 0;
 
         // Exercise: callers who want a sequence roll their own through Use(Func<Guid>).
@@ -132,8 +132,8 @@ public void ACustomIdSourceAssignsDistinctIdentifiersWithinTheScope() {
     [Fact(DisplayName = "UseSequential assigns readable, monotonically increasing identifiers within the scope.")]
     public void UseSequentialAssignsMonotonicIdentifiersWithinTheScope() {
         // Setup
-        ErrorCode anyErrorCode    = ErrorCodeFactory.CreateAny();
-        string    anyErrorMessage = ErrorMessageFactory.CreateAnyMessage();
+        ErrorCode anyErrorCode    = Any.ErrorCode();
+        string    anyErrorMessage = Any.DiagnosticMessage();
 
         // Exercise
         using (InstanceIds.UseSequential()) {
@@ -149,7 +149,7 @@ public void UseSequentialAssignsMonotonicIdentifiersWithinTheScope() {
     [Fact(DisplayName = "An error preserves the provided error code.")]
     public void ADiagnosableExceptionPreservesTheProvidedErrorCode() {
         // Setup
-        string    anyErrorMessage              = ErrorMessageFactory.CreateAnyMessage();
+        string    anyErrorMessage              = Any.DiagnosticMessage();
         ErrorCode temperatureBelowAbsoluteZero = ErrorCode.Create("TEMPERATURE_BELOW_ABSOLUTE_ZERO");
 
         // Exercise
@@ -162,9 +162,9 @@ public void ADiagnosableExceptionPreservesTheProvidedErrorCode() {
     [Fact(DisplayName = "An error preserves the provided short message.")]
     public void ADiagnosableExceptionPreservesTheProvidedShortMessage() {
         // Exercise
-        string              anyErrorMessage = ErrorMessageFactory.CreateAnyMessage();
-        ErrorCode           anyErrorCode    = ErrorCodeFactory.CreateAny();
-        InfrastructureError error           = InfrastructureError.Create(anyErrorCode, anyErrorMessage, InteractionDirection.Incoming, Transience.NonTransient)
+        string              anyErrorMessage = Any.DiagnosticMessage();
+        ErrorCode           anyErrorCode    = Any.ErrorCode();
+        InfrastructureError error           = InfrastructureError.Create(anyErrorCode, anyErrorMessage, Any.InteractionDirection(), Any.Transience())
                                                                   .WithPublicMessage("short");
 
         // Verify
@@ -174,7 +174,7 @@ public void ADiagnosableExceptionPreservesTheProvidedShortMessage() {
     [Fact(DisplayName = "An error preserves the provided diagnostic message.")]
     public void ADiagnosableExceptionPreservesTheProvidedDiagnosticMessage() {
         // Exercise
-        ErrorCode   anyErrorCode = ErrorCodeFactory.CreateAny();
+        ErrorCode   anyErrorCode = Any.ErrorCode();
         DomainError error        = DomainError.Create(anyErrorCode, "diagnostic").WithPublicMessage("short", "detailed");
 
         // Verify
@@ -186,9 +186,9 @@ public void ADiagnosableExceptionPreservesTheProvidedDiagnosticMessage() {
     [Fact(DisplayName = "An error has an empty context when no context is provided.")]
     public void ADiagnosableExceptionHasAnEmptyContextWhenNoContextIsProvided() {
         // Exercise
-        string              anyErrorMessage = ErrorMessageFactory.CreateAnyMessage();
-        ErrorCode           anyErrorCode    = ErrorCodeFactory.CreateAny();
-        InfrastructureError error           = InfrastructureError.Create(anyErrorCode, anyErrorMessage, InteractionDirection.Outgoing, Transience.Transient)
+        string              anyErrorMessage = Any.DiagnosticMessage();
+        ErrorCode           anyErrorCode    = Any.ErrorCode();
+        InfrastructureError error           = InfrastructureError.Create(anyErrorCode, anyErrorMessage, Any.InteractionDirection(), Any.Transience())
                                                                   .WithPublicMessage(anyErrorMessage);
 
         // Verify
@@ -200,8 +200,8 @@ public void ADiagnosableExceptionHasAnEmptyContextWhenNoContextIsProvided() {
     [Fact(DisplayName = "An error includes the provided context entries.")]
     public void ADiagnosableExceptionIncludesTheProvidedContextEntries() {
         // Setup
-        string                  anyErrorMessage = ErrorMessageFactory.CreateAnyMessage();
-        ErrorCode               anyErrorCode    = ErrorCodeFactory.CreateAny();
+        string                  anyErrorMessage = Any.DiagnosticMessage();
+        ErrorCode               anyErrorCode    = Any.ErrorCode();
         ErrorContextKey<string> userIdKey       = ErrorContextKey.Create<string>("UserId");
 
         // Exercise
@@ -220,9 +220,9 @@ public void ADiagnosableExceptionIncludesTheProvidedContextEntries() {
     [Fact(DisplayName = "An error has no inner errors by default.")]
     public void ADiagnosableExceptionHasNoInnerExceptionsByDefault() {
         // Exercise
-        string              anyErrorMessage = ErrorMessageFactory.CreateAnyMessage();
-        ErrorCode           anyErrorCode    = ErrorCodeFactory.CreateAny();
-        InfrastructureError error           = InfrastructureError.Create(anyErrorCode, anyErrorMessage, InteractionDirection.Outgoing, Transience.Unknown)
+        string              anyErrorMessage = Any.DiagnosticMessage();
+        ErrorCode           anyErrorCode    = Any.ErrorCode();
+        InfrastructureError error           = InfrastructureError.Create(anyErrorCode, anyErrorMessage, Any.InteractionDirection(), Transience.Unknown)
                                                                   .WithPublicMessage(anyErrorMessage);
 
         // Verify
@@ -233,9 +233,9 @@ public void ADiagnosableExceptionHasNoInnerExceptionsByDefault() {
     [Fact(DisplayName = "An error preserves a single inner error.")]
     public void ADiagnosableExceptionPreservesASingleInnerException() {
         // Setup
-        string      anyErrorMessage = ErrorMessageFactory.CreateAnyMessage();
-        ErrorCode   anyErrorCode    = ErrorCodeFactory.CreateAny();
-        DomainError innerError      = DomainError.Create(anyErrorCode, "inner").WithPublicMessage("inner");
+        string      anyErrorMessage = Any.DiagnosticMessage();
+        ErrorCode   anyErrorCode    = Any.ErrorCode();
+        DomainError innerError      = DomainError.Create(anyErrorCode, Any.DiagnosticMessage()).WithPublicMessage(Any.ShortMessage());
 
         // Exercise
         DomainError rootError = DomainError.Create(anyErrorCode, anyErrorMessage, innerError).WithPublicMessage(anyErrorMessage);
@@ -248,12 +248,12 @@ public void ADiagnosableExceptionPreservesASingleInnerException() {
     [Fact(DisplayName = "An infrastructure error preserves a single inner error.")]
     public void AnInfrastructureErrorPreservesASingleInnerError() {
         // Setup
-        string      anyErrorMessage = ErrorMessageFactory.CreateAnyMessage();
-        ErrorCode   anyErrorCode    = ErrorCodeFactory.CreateAny();
-        DomainError innerError      = DomainError.Create(anyErrorCode, "inner").WithPublicMessage("inner");
+        string      anyErrorMessage = Any.DiagnosticMessage();
+        ErrorCode   anyErrorCode    = Any.ErrorCode();
+        DomainError innerError      = DomainError.Create(anyErrorCode, Any.DiagnosticMessage()).WithPublicMessage(Any.ShortMessage());
 
         // Exercise
-        InfrastructureError rootError = InfrastructureError.Create(anyErrorCode, anyErrorMessage, InteractionDirection.Incoming, Transience.NonTransient, innerError)
+        InfrastructureError rootError = InfrastructureError.Create(anyErrorCode, anyErrorMessage, Any.InteractionDirection(), Any.Transience(), innerError)
                                                            .WithPublicMessage(anyErrorMessage);
 
         // Verify
@@ -264,8 +264,8 @@ public void AnInfrastructureErrorPreservesASingleInnerError() {
     [Fact(DisplayName = "An error preserves multiple inner errors.")]
     public void ADiagnosableExceptionPreservesMultipleInnerExceptions() {
         // Setup
-        string           anyErrorMessage  = ErrorMessageFactory.CreateAnyMessage();
-        ErrorCode        anyErrorCode     = ErrorCodeFactory.CreateAny();
+        string           anyErrorMessage  = Any.DiagnosticMessage();
+        ErrorCode        anyErrorCode     = Any.ErrorCode();
         DomainError      firstInnerError  = DomainError.Create(ErrorCode.Create("first"), "first").WithPublicMessage("first");
         PrimaryPortError secondInnerError = PrimaryPortError.Create(ErrorCode.Create("second"), "second", Transience.Unknown).WithPublicMessage("second");
         PrimaryPortInnerErrors innerErrors = new PrimaryPortInnerErrors()
@@ -284,8 +284,8 @@ public void ADiagnosableExceptionPreservesMultipleInnerExceptions() {
     [Fact(DisplayName = "An error can be created without inner errors even when a null collection is provided.")]
     public void ADiagnosableExceptionCanBeCreatedWithoutInnerExceptionsEvenWhenANullCollectionIsProvided() {
         // Exercise
-        ErrorCode   anyErrorCode    = ErrorCodeFactory.CreateAny();
-        string      anyErrorMessage = ErrorMessageFactory.CreateAnyMessage();
+        ErrorCode   anyErrorCode    = Any.ErrorCode();
+        string      anyErrorMessage = Any.DiagnosticMessage();
         DomainError error           = DomainError.Create(anyErrorCode, anyErrorMessage, innerErrors: null!).WithPublicMessage(anyErrorMessage);
 
         // Verify
@@ -295,28 +295,12 @@ public void ADiagnosableExceptionCanBeCreatedWithoutInnerExceptionsEvenWhenANull
     [Fact(DisplayName = "An error created with a null inner error has no inner errors.")]
     public void ADiagnosableExceptionCreatedWithANullInnerExceptionHasNoInnerExceptions() {
         // Exercise
-        ErrorCode   anyErrorCode    = ErrorCodeFactory.CreateAny();
-        string      anyErrorMessage = ErrorMessageFactory.CreateAnyMessage();
+        ErrorCode   anyErrorCode    = Any.ErrorCode();
+        string      anyErrorMessage = Any.DiagnosticMessage();
         DomainError exception       = DomainError.Create(anyErrorCode, anyErrorMessage, innerError: null!).WithPublicMessage(anyErrorMessage);
 
         // Verify
         Check.That(exception.InnerErrors).CountIs(0);
     }
 
-    #region Nested types declarations
-
-    private static class ErrorMessageFactory {
-
-        #region Statics members declarations
-
-        public static string CreateAnyMessage() {
-            return "boom";
-        }
-
-        #endregion
-
-    }
-
-    #endregion
-
 }
diff --git a/FirstClassErrors.UnitTests/OutcomeAssertionsTests.cs b/FirstClassErrors.UnitTests/OutcomeAssertionsTests.cs
index 80d11ed..c1600f5 100644
--- a/FirstClassErrors.UnitTests/OutcomeAssertionsTests.cs
+++ b/FirstClassErrors.UnitTests/OutcomeAssertionsTests.cs
@@ -68,7 +68,7 @@ public void ShouldFailWithMismatchingCodeThrows() {
 
     [Fact(DisplayName = "ShouldFail on a successful outcome throws.")]
     public void ShouldFailOnSuccessThrows() {
-        Outcome<int> outcome = Outcome<int>.Success(1);
+        Outcome<int> outcome = Outcome<int>.Success(Any.Int());
 
         Assert.Throws<OutcomeAssertionException>(() => outcome.ShouldFail());
     }
@@ -85,8 +85,8 @@ public void NonGenericOutcomeAssertions() {
     [Fact(DisplayName = "WithContextEntry checks the presence and value of a context entry.")]
     public void WithContextEntryChecksPresenceAndValue() {
         ErrorContextKey<string> cardNetwork = ErrorContextKey.Create<string>("CardNetwork", "The card network.");
-        DomainError error = DomainError.Create(ErrorCode.Create("PAYMENT_DECLINED"), "diagnostic", context => context.Add(cardNetwork, "VISA"))
-                                       .WithPublicMessage("short");
+        DomainError error = DomainError.Create(Any.ErrorCode(), Any.DiagnosticMessage(), context => context.Add(cardNetwork, "VISA"))
+                                       .WithPublicMessage(Any.ShortMessage());
         Outcome<int> outcome = Outcome<int>.Failure(error);
 
         // Passes for the present key and matching value.
diff --git a/FirstClassErrors.UnitTests/OutcomeAsyncInstanceCoverageTests.cs b/FirstClassErrors.UnitTests/OutcomeAsyncInstanceCoverageTests.cs
index cd683c1..dfcc8e8 100644
--- a/FirstClassErrors.UnitTests/OutcomeAsyncInstanceCoverageTests.cs
+++ b/FirstClassErrors.UnitTests/OutcomeAsyncInstanceCoverageTests.cs
@@ -1,5 +1,7 @@
 #region Usings declarations
 
+using FirstClassErrors.Testing;
+
 using JetBrains.Annotations;
 
 using NFluent;
@@ -41,7 +43,7 @@ public void ThenToATypedOutcomeGuardsAgainstANullNextFunction() {
     public async Task TheAsyncThenToATypedOutcomeChainsOnSuccessAndPropagatesOnFailure() {
         // Setup
         CancellationToken token = TestContext.Current.CancellationToken;
-        DomainError       error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         Outcome<int> onSuccess = await Outcome.Success.Then((_) => Task.FromResult(Outcome<int>.Success(9)), token);
@@ -82,7 +84,7 @@ public void TheAsyncThenGuardsAgainstANullNextFunction() {
     public async Task TheAsyncRecoverPassesASuccessThroughAndRecoversAFailure() {
         // Setup
         CancellationToken token = TestContext.Current.CancellationToken;
-        DomainError       error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         Outcome passed    = await Outcome.Success.Recover((_, _) => Task.FromResult(Outcome.Failure(error)), token);
@@ -110,7 +112,7 @@ public void TheAsyncRecoverGuardsAgainstANullFallbackFunction() {
     public async Task TheAsyncFinallyWithAValueResolvesTheBranchMatchingTheOutcome() {
         // Setup
         CancellationToken token = TestContext.Current.CancellationToken;
-        DomainError       error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         string onSuccess = await Outcome.Success.Finally((_) => Task.FromResult("ok"), (_, _) => Task.FromResult("ko"), token);
@@ -142,7 +144,7 @@ public void TheAsyncFinallyWithAValueGuardsAgainstNullHandlers() {
     public async Task TheAsyncFinallyWithActionsRunsTheBranchMatchingTheOutcome() {
         // Setup
         CancellationToken token          = TestContext.Current.CancellationToken;
-        DomainError       error          = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error          = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         bool              successOnOk    = false;
         Error?            capturedOnFail = null;
 
@@ -231,7 +233,7 @@ public void TheAsyncThenThrowsWhenNextReturnsANullTask() {
     public void TheAsyncRecoverThrowsWhenFallbackReturnsANullTask() {
         // Setup
         CancellationToken token   = TestContext.Current.CancellationToken;
-        DomainError       error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error   = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Outcome           outcome = Outcome.Failure(error);
 
         // Exercise & verify
@@ -258,7 +260,7 @@ public void TheAsyncFinallyWithAValueThrowsWhenOnSuccessReturnsANullTask() {
     public void TheAsyncFinallyWithActionsThrowsWhenOnFailureReturnsANullTask() {
         // Setup
         CancellationToken token   = TestContext.Current.CancellationToken;
-        DomainError       error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error   = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Outcome           outcome = Outcome.Failure(error);
 
         // Exercise & verify
@@ -291,7 +293,7 @@ public void ThenToATypedOutcomeGuardsAgainstANullNextFunction() {
     public async Task TheAsyncThenToATypedOutcomeChainsOnSuccessAndPropagatesOnFailure() {
         // Setup
         CancellationToken token = TestContext.Current.CancellationToken;
-        DomainError       error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         Outcome<int> onSuccess = await Outcome<int>.Success(4).Then((value, _) => Task.FromResult(Outcome<int>.Success(value + 1)), token);
@@ -319,7 +321,7 @@ public void TheAsyncThenToATypedOutcomeGuardsAgainstANullNextFunction() {
     public async Task TheAsyncThenDiscardingTheValueChainsOnSuccessAndPropagatesOnFailure() {
         // Setup
         CancellationToken token = TestContext.Current.CancellationToken;
-        DomainError       error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         Outcome onSuccess = await Outcome<int>.Success(4).Then((_, _) => Task.FromResult(Outcome.Success), token);
@@ -347,7 +349,7 @@ public void TheAsyncThenDiscardingTheValueGuardsAgainstANullNextFunction() {
     public async Task TheAsyncToPropagatesTheErrorOnFailure() {
         // Setup
         CancellationToken token   = TestContext.Current.CancellationToken;
-        DomainError       error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error   = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Outcome<int>      outcome = Outcome<int>.Failure(error);
 
         // Exercise
@@ -377,7 +379,7 @@ public void TheAsyncToGuardsAgainstANullConverter() {
     [Fact(DisplayName = "Recover with an outcome fallback passes a success through and recovers a failure.")]
     public void RecoverWithAnOutcomeFallbackPassesASuccessThroughAndRecoversAFailure() {
         // Setup
-        DomainError  error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError  error   = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Outcome<int> success = Outcome<int>.Success(1);
         Outcome<int> failure = Outcome<int>.Failure(error);
 
@@ -393,7 +395,7 @@ public void RecoverWithAnOutcomeFallbackPassesASuccessThroughAndRecoversAFailure
     [Fact(DisplayName = "Recover with a value fallback passes a success through and recovers a failure.")]
     public void RecoverWithAValueFallbackPassesASuccessThroughAndRecoversAFailure() {
         // Setup
-        DomainError  error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError  error   = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Outcome<int> success = Outcome<int>.Success(1);
         Outcome<int> failure = Outcome<int>.Failure(error);
 
@@ -420,7 +422,7 @@ public void RecoverWithAValueFallbackGuardsAgainstANullFallbackFunction() {
     public async Task TheAsyncRecoverWithAnOutcomeFallbackPassesASuccessThroughAndRecoversAFailure() {
         // Setup
         CancellationToken token   = TestContext.Current.CancellationToken;
-        DomainError       error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error   = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Outcome<int>      success = Outcome<int>.Success(1);
 
         // Exercise
@@ -474,7 +476,7 @@ public void TheAsyncRecoverWithAValueFallbackGuardsAgainstANullFallbackFunction(
     [Fact(DisplayName = "Finally with actions runs the branch matching the outcome.")]
     public void FinallyWithActionsRunsTheBranchMatchingTheOutcome() {
         // Setup
-        DomainError error          = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError error          = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         int         capturedValue  = 0;
         Error?      capturedOnFail = null;
 
@@ -502,7 +504,7 @@ public void FinallyWithActionsGuardsAgainstNullHandlers() {
     [Fact(DisplayName = "Finally with a value resolves the failure branch.")]
     public void FinallyWithAValueResolvesTheFailureBranch() {
         // Setup
-        DomainError  error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError  error   = ErrorFactory.Domain(Any.ErrorCode(), "boom");
         Outcome<int> outcome = Outcome<int>.Failure(error);
 
         // Exercise
@@ -526,7 +528,7 @@ public void FinallyWithAValueGuardsAgainstANullOnFailureFunction() {
     public async Task TheAsyncFinallyWithAValueResolvesTheBranchMatchingTheOutcome() {
         // Setup
         CancellationToken token = TestContext.Current.CancellationToken;
-        DomainError       error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         string onSuccess = await Outcome<int>.Success(5).Finally((value, _) => Task.FromResult($"ok:{value}"), (_, _) => Task.FromResult("ko"), token);
@@ -558,7 +560,7 @@ public void TheAsyncFinallyWithAValueGuardsAgainstNullHandlers() {
     public async Task TheAsyncFinallyWithActionsRunsTheBranchMatchingTheOutcome() {
         // Setup
         CancellationToken token          = TestContext.Current.CancellationToken;
-        DomainError       error          = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error          = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         int               capturedValue  = 0;
         Error?            capturedOnFail = null;
 
@@ -623,7 +625,7 @@ public void TheAsyncThenDiscardingTheValueThrowsWhenNextReturnsANullTask() {
     public void TheAsyncRecoverWithAnOutcomeFallbackThrowsWhenFallbackReturnsANullTask() {
         // Setup
         CancellationToken token   = TestContext.Current.CancellationToken;
-        DomainError       error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error   = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Outcome<int>      outcome = Outcome<int>.Failure(error);
 
         // Exercise & verify
@@ -650,7 +652,7 @@ public void TheAsyncFinallyWithAValueThrowsWhenOnSuccessReturnsANullTask() {
     public void TheAsyncFinallyWithActionsThrowsWhenOnFailureReturnsANullTask() {
         // Setup
         CancellationToken token   = TestContext.Current.CancellationToken;
-        DomainError       error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error   = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Outcome<int>      outcome = Outcome<int>.Failure(error);
 
         // Exercise & verify
diff --git a/FirstClassErrors.UnitTests/OutcomeGenericAdditionalTests.cs b/FirstClassErrors.UnitTests/OutcomeGenericAdditionalTests.cs
index 6ddeb2d..c59edb2 100644
--- a/FirstClassErrors.UnitTests/OutcomeGenericAdditionalTests.cs
+++ b/FirstClassErrors.UnitTests/OutcomeGenericAdditionalTests.cs
@@ -1,5 +1,7 @@
 #region Usings declarations
 
+using FirstClassErrors.Testing;
+
 using JetBrains.Annotations;
 
 using NFluent;
@@ -14,7 +16,7 @@ public sealed class OutcomeGenericAdditionalTests {
     [Fact(DisplayName = "Then discarding the value chains to a non-generic Outcome on success.")]
     public void ThenDiscardingTheValueChainsToANonGenericOutcomeOnSuccess() {
         // Setup
-        Outcome<int> outcome = Outcome<int>.Success(3);
+        Outcome<int> outcome = Outcome<int>.Success(Any.Int());
 
         // Exercise
         Outcome result = outcome.Then(_ => Outcome.Success);
@@ -80,7 +82,7 @@ public async Task AwaitingTheAsyncInstanceRecoverValueOverloadRecoversAFailure()
     [Fact(DisplayName = "Then throws an ArgumentNullException when the continuation is null.")]
     public void ThenThrowsAnArgumentNullExceptionWhenTheContinuationIsNull() {
         // Setup
-        Outcome<int> outcome = Outcome<int>.Success(1);
+        Outcome<int> outcome = Outcome<int>.Success(Any.Int());
 
         // Exercise & verify
         Check.ThatCode(() => outcome.Then((Func<int, Outcome>)null!))
@@ -90,7 +92,7 @@ public void ThenThrowsAnArgumentNullExceptionWhenTheContinuationIsNull() {
     [Fact(DisplayName = "Then (value mapping) throws an ArgumentNullException when the converter is null.")]
     public void ToThrowsAnArgumentNullExceptionWhenTheConverterIsNull() {
         // Setup
-        Outcome<int> outcome = Outcome<int>.Success(1);
+        Outcome<int> outcome = Outcome<int>.Success(Any.Int());
 
         // Exercise & verify
         Check.ThatCode(() => outcome.Then((Func<int, string>)null!))
@@ -100,7 +102,7 @@ public void ToThrowsAnArgumentNullExceptionWhenTheConverterIsNull() {
     [Fact(DisplayName = "Recover throws an ArgumentNullException when the fallback is null.")]
     public void RecoverThrowsAnArgumentNullExceptionWhenTheFallbackIsNull() {
         // Setup
-        Outcome<int> outcome = Outcome<int>.Success(1);
+        Outcome<int> outcome = Outcome<int>.Success(Any.Int());
 
         // Exercise & verify
         Check.ThatCode(() => outcome.Recover((Func<Error, Outcome<int>>)null!))
@@ -110,7 +112,7 @@ public void RecoverThrowsAnArgumentNullExceptionWhenTheFallbackIsNull() {
     [Fact(DisplayName = "Finally throws an ArgumentNullException when the success handler is null.")]
     public void FinallyThrowsAnArgumentNullExceptionWhenTheSuccessHandlerIsNull() {
         // Setup
-        Outcome<int> outcome = Outcome<int>.Success(1);
+        Outcome<int> outcome = Outcome<int>.Success(Any.Int());
 
         // Exercise & verify
         Check.ThatCode(() => outcome.Finally((Func<int, string>)null!, _ => "ko"))
diff --git a/FirstClassErrors.UnitTests/OutcomeNonGenericTests.cs b/FirstClassErrors.UnitTests/OutcomeNonGenericTests.cs
index 49c6dbb..0fb48fe 100644
--- a/FirstClassErrors.UnitTests/OutcomeNonGenericTests.cs
+++ b/FirstClassErrors.UnitTests/OutcomeNonGenericTests.cs
@@ -1,5 +1,7 @@
 #region Usings declarations
 
+using FirstClassErrors.Testing;
+
 using JetBrains.Annotations;
 
 using NFluent;
@@ -25,7 +27,7 @@ public void OutcomeSuccessIsASuccessfulOutcome() {
     [Fact(DisplayName = "Outcome.Failure is a failed outcome exposing its error.")]
     public void OutcomeFailureIsAFailedOutcomeExposingItsError() {
         // Setup
-        DomainError error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         Outcome outcome = Outcome.Failure(error);
@@ -55,7 +57,7 @@ public void ThrowIfFailureDoesNothingWhenTheOutcomeIsASuccess() {
     [Fact(DisplayName = "ThrowIfFailure throws the associated exception when the outcome is a failure.")]
     public void ThrowIfFailureThrowsTheAssociatedExceptionWhenTheOutcomeIsAFailure() {
         // Setup
-        DomainError error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError error   = ErrorFactory.Domain(Any.ErrorCode(), "boom");
         Outcome     outcome = Outcome.Failure(error);
 
         // Exercise & verify
@@ -79,7 +81,7 @@ public void ThenRunsTheNextStepWhenTheOutcomeIsASuccess() {
     [Fact(DisplayName = "Then short-circuits and propagates the error when the outcome is a failure.")]
     public void ThenShortCircuitsAndPropagatesTheErrorWhenTheOutcomeIsAFailure() {
         // Setup
-        DomainError error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError error   = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Outcome     outcome = Outcome.Failure(error);
         bool        called  = false;
 
@@ -99,7 +101,7 @@ public void ThenShortCircuitsAndPropagatesTheErrorWhenTheOutcomeIsAFailure() {
     [Fact(DisplayName = "Then to a typed outcome propagates the error on a failure.")]
     public void ThenToATypedOutcomePropagatesTheErrorOnAFailure() {
         // Setup
-        DomainError error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError error   = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Outcome     outcome = Outcome.Failure(error);
 
         // Exercise
@@ -116,7 +118,7 @@ public void RecoverLeavesASuccessfulOutcomeUnchanged() {
         Outcome outcome = Outcome.Success;
 
         // Exercise
-        Outcome result = outcome.Recover(_ => Outcome.Failure(ErrorFactory.Domain(ErrorCode.Unspecified, "fallback")));
+        Outcome result = outcome.Recover(_ => Outcome.Failure(ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage())));
 
         // Verify
         Check.That(result).IsSameReferenceAs(outcome);
@@ -126,7 +128,7 @@ public void RecoverLeavesASuccessfulOutcomeUnchanged() {
     [Fact(DisplayName = "Recover replaces a failure with the fallback result.")]
     public void RecoverReplacesAFailureWithTheFallbackResult() {
         // Setup
-        DomainError error    = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError error    = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Outcome     outcome  = Outcome.Failure(error);
         Outcome     fallback = Outcome.Success;
 
@@ -153,7 +155,7 @@ public void FinallyResolvesTheSuccessBranchWhenTheOutcomeIsASuccess() {
     [Fact(DisplayName = "Finally resolves the failure branch when the outcome is a failure.")]
     public void FinallyResolvesTheFailureBranchWhenTheOutcomeIsAFailure() {
         // Setup
-        DomainError error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError error   = ErrorFactory.Domain(Any.ErrorCode(), "boom");
         Outcome     outcome = Outcome.Failure(error);
 
         // Exercise
@@ -181,7 +183,7 @@ public void FinallyWithActionsExecutesTheSuccessBranchWhenTheOutcomeIsASuccess()
     [Fact(DisplayName = "Finally with actions executes the failure branch when the outcome is a failure.")]
     public void FinallyWithActionsExecutesTheFailureBranchWhenTheOutcomeIsAFailure() {
         // Setup
-        DomainError error           = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError error           = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Outcome     outcome         = Outcome.Failure(error);
         bool        successExecuted = false;
         Error?      capturedError   = null;
@@ -239,7 +241,7 @@ public async Task AwaitingTheAsynchronousThenChainsTheNextStepWhenTheOutcomeIsAS
     [Fact(DisplayName = "Awaiting the asynchronous Then short-circuits and propagates the error on a failure.")]
     public async Task AwaitingTheAsynchronousThenShortCircuitsAndPropagatesTheErrorOnAFailure() {
         // Setup
-        DomainError error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError error   = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Outcome     outcome = Outcome.Failure(error);
         bool        called  = false;
 
diff --git a/FirstClassErrors.UnitTests/OutcomeTaskExtensionsCoverageTests.cs b/FirstClassErrors.UnitTests/OutcomeTaskExtensionsCoverageTests.cs
index 0fc0b96..9cd1931 100644
--- a/FirstClassErrors.UnitTests/OutcomeTaskExtensionsCoverageTests.cs
+++ b/FirstClassErrors.UnitTests/OutcomeTaskExtensionsCoverageTests.cs
@@ -1,5 +1,7 @@
 #region Usings declarations
 
+using FirstClassErrors.Testing;
+
 using JetBrains.Annotations;
 
 using NFluent;
@@ -35,7 +37,7 @@ public async Task ThenOverASuccessfulTaskOutcomeToATypedOutcomeRunsTheContinuati
     [Fact(DisplayName = "Then over a failed Task<Outcome> to a typed outcome propagates the error.")]
     public async Task ThenOverAFailedTaskOutcomeToATypedOutcomePropagatesTheError() {
         // Setup
-        DomainError   error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError   error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Task<Outcome> task  = Task.FromResult(Outcome.Failure(error));
 
         // Exercise
@@ -56,7 +58,7 @@ public void ThenOverANullTaskOutcomeToATypedOutcomeThrows() {
     [Fact(DisplayName = "Then over a failed Task<Outcome> propagates the error unchanged.")]
     public async Task ThenOverAFailedTaskOutcomePropagatesTheErrorUnchanged() {
         // Setup
-        DomainError   error  = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError   error  = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Task<Outcome> task   = Task.FromResult(Outcome.Failure(error));
         bool          called = false;
 
@@ -89,7 +91,7 @@ public async Task TheAsyncThenOverATaskOutcomeToATypedOutcomeRunsTheContinuation
     public async Task TheAsyncThenOverAFailedTaskOutcomeToATypedOutcomePropagatesTheError() {
         // Setup
         CancellationToken token = TestContext.Current.CancellationToken;
-        DomainError       error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Task<Outcome>     task  = Task.FromResult(Outcome.Failure(error));
 
         // Exercise
@@ -125,7 +127,7 @@ public async Task TheAsyncThenOverASuccessfulTaskOutcomeRunsTheNonGenericContinu
     public async Task TheAsyncThenOverAFailedTaskOutcomePropagatesTheErrorUnchanged() {
         // Setup
         CancellationToken token = TestContext.Current.CancellationToken;
-        DomainError       error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Task<Outcome>     task  = Task.FromResult(Outcome.Failure(error));
 
         // Exercise
@@ -151,7 +153,7 @@ public void TheAsyncThenOverANullNonGenericTaskOutcomeThrows() {
     [Fact(DisplayName = "Recover over a failed Task<Outcome> replaces the failure with the fallback.")]
     public async Task RecoverOverAFailedTaskOutcomeReplacesTheFailureWithTheFallback() {
         // Setup
-        DomainError   error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError   error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Task<Outcome> task  = Task.FromResult(Outcome.Failure(error));
 
         // Exercise
@@ -167,7 +169,7 @@ public async Task RecoverOverASuccessfulTaskOutcomeLeavesTheOutcomeUnchanged() {
         Task<Outcome> task = Task.FromResult(Outcome.Success);
 
         // Exercise
-        Outcome result = await task.Recover(_ => Outcome.Failure(ErrorFactory.Domain(ErrorCode.Unspecified, "fallback")));
+        Outcome result = await task.Recover(_ => Outcome.Failure(ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage())));
 
         // Verify
         Check.That(result.IsSuccess).IsTrue();
@@ -184,7 +186,7 @@ public void RecoverOverANullTaskOutcomeThrows() {
     public async Task TheAsyncRecoverOverAFailedTaskOutcomeReplacesTheFailureWithTheFallback() {
         // Setup
         CancellationToken token = TestContext.Current.CancellationToken;
-        DomainError       error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Task<Outcome>     task  = Task.FromResult(Outcome.Failure(error));
 
         // Exercise
@@ -222,7 +224,7 @@ public async Task FinallyOverATaskOutcomeResolvesTheSuccessBranchToAValue() {
     [Fact(DisplayName = "Finally over a Task<Outcome> resolves the failure branch to a value.")]
     public async Task FinallyOverATaskOutcomeResolvesTheFailureBranchToAValue() {
         // Setup
-        DomainError   error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError   error = ErrorFactory.Domain(Any.ErrorCode(), "boom");
         Task<Outcome> task  = Task.FromResult(Outcome.Failure(error));
 
         // Exercise
@@ -242,7 +244,7 @@ public void FinallyWithAValueOverANullTaskOutcomeThrows() {
     [Fact(DisplayName = "Finally with actions over a Task<Outcome> runs the branch matching the outcome.")]
     public async Task FinallyWithActionsOverATaskOutcomeRunsTheBranchMatchingTheOutcome() {
         // Setup
-        DomainError   error          = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError   error          = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         bool          successOnOk    = false;
         Error?        capturedOnFail = null;
 
@@ -266,7 +268,7 @@ public void FinallyWithActionsOverANullTaskOutcomeThrows() {
     public async Task TheAsyncFinallyOverATaskOutcomeResolvesBothBranchesToAValue() {
         // Setup
         CancellationToken token = TestContext.Current.CancellationToken;
-        DomainError       error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         string onSuccess = await Task.FromResult(Outcome.Success)
@@ -293,7 +295,7 @@ public void TheAsyncFinallyWithAValueOverANullTaskOutcomeThrows() {
     public async Task TheAsyncFinallyWithActionsOverATaskOutcomeRunsTheBranchMatchingTheOutcome() {
         // Setup
         CancellationToken token          = TestContext.Current.CancellationToken;
-        DomainError       error          = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error          = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         bool              successOnOk    = false;
         Error?            capturedOnFail = null;
 
@@ -337,7 +339,7 @@ public async Task ThenDiscardingTheValueOverATaskOutcomeChainsToANonGenericOutco
     [Fact(DisplayName = "Then discarding the value over a failed Task<Outcome<T>> propagates the error.")]
     public async Task ThenDiscardingTheValueOverAFailedTaskOutcomePropagatesTheError() {
         // Setup
-        DomainError        error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError        error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Task<Outcome<int>> task  = Task.FromResult(Outcome<int>.Failure(error));
 
         // Exercise
@@ -358,7 +360,7 @@ public void ThenDiscardingTheValueOverANullTaskOutcomeThrows() {
     public async Task TheAsyncThenOverAFailedTaskOutcomeToATypedOutcomePropagatesTheErrorGeneric() {
         // Setup
         CancellationToken  token = TestContext.Current.CancellationToken;
-        DomainError        error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError        error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Task<Outcome<int>> task  = Task.FromResult(Outcome<int>.Failure(error));
 
         // Exercise
@@ -372,7 +374,7 @@ public async Task TheAsyncThenOverAFailedTaskOutcomeToATypedOutcomePropagatesThe
     public async Task TheAsyncThenDiscardingTheValueOverATaskOutcomeChainsOnSuccessAndPropagatesOnFailure() {
         // Setup
         CancellationToken token = TestContext.Current.CancellationToken;
-        DomainError       error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         Outcome onSuccess = await Task.FromResult(Outcome<int>.Success(3))
@@ -402,7 +404,7 @@ public void TheAsyncThenDiscardingTheValueOverANullTaskOutcomeThrows() {
     [Fact(DisplayName = "Then (value mapping) over a failed Task<Outcome<T>> propagates the error.")]
     public async Task ToOverAFailedTaskOutcomePropagatesTheError() {
         // Setup
-        DomainError        error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError        error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Task<Outcome<int>> task  = Task.FromResult(Outcome<int>.Failure(error));
 
         // Exercise
@@ -416,7 +418,7 @@ public async Task ToOverAFailedTaskOutcomePropagatesTheError() {
     public async Task TheAsyncToOverATaskOutcomeMapsOnSuccessAndPropagatesOnFailure() {
         // Setup
         CancellationToken token = TestContext.Current.CancellationToken;
-        DomainError       error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         Outcome<string> onSuccess = await Task.FromResult(Outcome<int>.Success(6))
@@ -446,7 +448,7 @@ public void TheAsyncToOverANullTaskOutcomeThrows() {
     [Fact(DisplayName = "Recover with an outcome fallback over a failed Task<Outcome<T>> replaces the failure.")]
     public async Task RecoverWithAnOutcomeFallbackOverAFailedTaskOutcomeReplacesTheFailure() {
         // Setup
-        DomainError        error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError        error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Task<Outcome<int>> task  = Task.FromResult(Outcome<int>.Failure(error));
 
         // Exercise
@@ -498,7 +500,7 @@ public void RecoverWithAValueFallbackOverANullTaskOutcomeThrows() {
     public async Task TheAsyncRecoverWithAnOutcomeFallbackOverATaskOutcomeRecoversAndPassesThrough() {
         // Setup
         CancellationToken token = TestContext.Current.CancellationToken;
-        DomainError       error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         Outcome<int> recovered = await Task.FromResult(Outcome<int>.Failure(error))
@@ -525,7 +527,7 @@ public void TheAsyncRecoverWithAnOutcomeFallbackOverANullTaskOutcomeThrows() {
     public async Task TheAsyncRecoverWithAValueFallbackOverATaskOutcomeRecoversAndPassesThrough() {
         // Setup
         CancellationToken token = TestContext.Current.CancellationToken;
-        DomainError       error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         Outcome<int> recovered = await Task.FromResult(Outcome<int>.Failure(error))
@@ -555,7 +557,7 @@ public void TheAsyncRecoverWithAValueFallbackOverANullTaskOutcomeThrows() {
     [Fact(DisplayName = "Finally over a failed Task<Outcome<T>> resolves the failure branch to a value.")]
     public async Task FinallyOverAFailedTaskOutcomeResolvesTheFailureBranchToAValue() {
         // Setup
-        DomainError        error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError        error = ErrorFactory.Domain(Any.ErrorCode(), "boom");
         Task<Outcome<int>> task  = Task.FromResult(Outcome<int>.Failure(error));
 
         // Exercise
@@ -575,7 +577,7 @@ public void FinallyWithAValueOverANullGenericTaskOutcomeThrows() {
     [Fact(DisplayName = "Finally with actions over a Task<Outcome<T>> runs the branch matching the outcome.")]
     public async Task FinallyWithActionsOverATaskGenericOutcomeRunsTheBranchMatchingTheOutcome() {
         // Setup
-        DomainError error          = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError error          = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         int         capturedValue  = 0;
         Error?      capturedOnFail = null;
 
@@ -599,7 +601,7 @@ public void FinallyWithActionsOverANullGenericTaskOutcomeThrows() {
     public async Task TheAsyncFinallyOverATaskGenericOutcomeResolvesBothBranchesToAValue() {
         // Setup
         CancellationToken token = TestContext.Current.CancellationToken;
-        DomainError       error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         string onSuccess = await Task.FromResult(Outcome<int>.Success(5))
@@ -626,7 +628,7 @@ public void TheAsyncFinallyWithAValueOverANullGenericTaskOutcomeThrows() {
     public async Task TheAsyncFinallyWithActionsOverATaskGenericOutcomeRunsTheBranchMatchingTheOutcome() {
         // Setup
         CancellationToken token          = TestContext.Current.CancellationToken;
-        DomainError       error          = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError       error          = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         int               capturedValue  = 0;
         Error?            capturedOnFail = null;
 
diff --git a/FirstClassErrors.UnitTests/OutcomeTaskExtensionsEagerValidationTests.cs b/FirstClassErrors.UnitTests/OutcomeTaskExtensionsEagerValidationTests.cs
index 7eaa13b..6a85c18 100644
--- a/FirstClassErrors.UnitTests/OutcomeTaskExtensionsEagerValidationTests.cs
+++ b/FirstClassErrors.UnitTests/OutcomeTaskExtensionsEagerValidationTests.cs
@@ -1,5 +1,7 @@
 #region Usings declarations
 
+using FirstClassErrors.Testing;
+
 using JetBrains.Annotations;
 
 using NFluent;
@@ -68,7 +70,7 @@ public void ToOverANullGenericTaskOutcomeThrowsSynchronously() {
     [Fact(DisplayName = "Recover over a null Task<Outcome<T>> throws synchronously, before the task is awaited.")]
     public void RecoverOverANullGenericTaskOutcomeThrowsSynchronously() {
         // Exercise & verify
-        Check.ThatCode(() => { _ = ((Task<Outcome<int>>)null!).Recover(_ => Outcome<int>.Success(1)); })
+        Check.ThatCode(() => { _ = ((Task<Outcome<int>>)null!).Recover(_ => Outcome<int>.Success(Any.Int())); })
              .Throws<ArgumentNullException>();
     }
 
@@ -137,7 +139,7 @@ public void FinallyWithANullFailureBranchThrowsSynchronously() {
     [Fact(DisplayName = "Then (value mapping) over a Task<Outcome<T>> with a null conversion throws synchronously.")]
     public void ToWithANullConversionThrowsSynchronously() {
         // Setup
-        Task<Outcome<int>> task = Task.FromResult(Outcome<int>.Success(1));
+        Task<Outcome<int>> task = Task.FromResult(Outcome<int>.Success(Any.Int()));
 
         // Exercise & verify
         Check.ThatCode(() => { _ = task.Then((Func<int, string>)null!); })
@@ -147,7 +149,7 @@ public void ToWithANullConversionThrowsSynchronously() {
     [Fact(DisplayName = "Recover over a Task<Outcome<T>> with a null fallback throws synchronously.")]
     public void GenericRecoverWithANullFallbackThrowsSynchronously() {
         // Setup
-        Task<Outcome<int>> task = Task.FromResult(Outcome<int>.Success(1));
+        Task<Outcome<int>> task = Task.FromResult(Outcome<int>.Success(Any.Int()));
 
         // Exercise & verify
         Check.ThatCode(() => { _ = task.Recover((Func<Error, Outcome<int>>)null!); })
@@ -157,7 +159,7 @@ public void GenericRecoverWithANullFallbackThrowsSynchronously() {
     [Fact(DisplayName = "Finally over a Task<Outcome<T>> with a null failure branch throws synchronously.")]
     public void GenericFinallyWithANullFailureBranchThrowsSynchronously() {
         // Setup
-        Task<Outcome<int>> task = Task.FromResult(Outcome<int>.Success(1));
+        Task<Outcome<int>> task = Task.FromResult(Outcome<int>.Success(Any.Int()));
 
         // Exercise & verify
         Check.ThatCode(() => { _ = task.Finally(value => $"ok:{value}", (Func<Error, string>)null!); })
diff --git a/FirstClassErrors.UnitTests/OutcomeTaskExtensionsTests.cs b/FirstClassErrors.UnitTests/OutcomeTaskExtensionsTests.cs
index 948f6c6..6cd8f40 100644
--- a/FirstClassErrors.UnitTests/OutcomeTaskExtensionsTests.cs
+++ b/FirstClassErrors.UnitTests/OutcomeTaskExtensionsTests.cs
@@ -1,5 +1,7 @@
 #region Usings declarations
 
+using FirstClassErrors.Testing;
+
 using JetBrains.Annotations;
 
 using NFluent;
@@ -27,7 +29,7 @@ public async Task AwaitingThenOverATaskOutcomeChainsTheNextStepOnSuccess() {
     [Fact(DisplayName = "Awaiting Then over a Task<Outcome<T>> propagates the error on failure.")]
     public async Task AwaitingThenOverATaskOutcomePropagatesTheErrorOnFailure() {
         // Setup
-        DomainError                               error  = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError                               error  = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         System.Threading.Tasks.Task<Outcome<int>> task   = System.Threading.Tasks.Task.FromResult(Outcome<int>.Failure(error));
         bool                                      called = false;
 
@@ -59,7 +61,7 @@ public async Task AwaitingToOverATaskOutcomeMapsTheValueOnSuccess() {
     [Fact(DisplayName = "Awaiting Recover over a Task<Outcome<T>> recovers a failure into a success.")]
     public async Task AwaitingRecoverOverATaskOutcomeRecoversAFailureIntoASuccess() {
         // Setup
-        DomainError                               error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError                               error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         System.Threading.Tasks.Task<Outcome<int>> task  = System.Threading.Tasks.Task.FromResult(Outcome<int>.Failure(error));
 
         // Exercise
@@ -85,7 +87,7 @@ public async Task AwaitingFinallyOverATaskOutcomeResolvesTheSuccessBranch() {
     [Fact(DisplayName = "Awaiting Finally over a Task<Outcome<T>> resolves the failure branch.")]
     public async Task AwaitingFinallyOverATaskOutcomeResolvesTheFailureBranch() {
         // Setup
-        DomainError                               error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError                               error = ErrorFactory.Domain(Any.ErrorCode(), "boom");
         System.Threading.Tasks.Task<Outcome<int>> task  = System.Threading.Tasks.Task.FromResult(Outcome<int>.Failure(error));
 
         // Exercise
diff --git a/FirstClassErrors.UnitTests/OutcomeTests.cs b/FirstClassErrors.UnitTests/OutcomeTests.cs
index f0313ea..ccc76ec 100644
--- a/FirstClassErrors.UnitTests/OutcomeTests.cs
+++ b/FirstClassErrors.UnitTests/OutcomeTests.cs
@@ -1,5 +1,7 @@
 #region Usings declarations
 
+using FirstClassErrors.Testing;
+
 using JetBrains.Annotations;
 
 using NFluent;
@@ -14,7 +16,7 @@ public sealed class OutcomeTests {
     [Fact(DisplayName = "A successful outcome is marked as success.")]
     public void SuccessfulOutcomeIsMarkedAsSuccess() {
         // Exercise
-        Outcome<string> outcome = Outcome<string>.Success("ok");
+        Outcome<string> outcome = Outcome<string>.Success(Any.String());
 
         // Verify
         Check.That(outcome.IsSuccess).IsTrue();
@@ -50,7 +52,7 @@ public void SuccessfulOutcomeCannotBeCreatedFromANullValue() {
     [Fact(DisplayName = "A failed outcome is marked as failure.")]
     public void FailedOutcomeIsMarkedAsFailure() {
         // Setup
-        DomainError error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         Outcome<string> outcome = Outcome<string>.Failure(error);
@@ -63,7 +65,7 @@ public void FailedOutcomeIsMarkedAsFailure() {
     [Fact(DisplayName = "A failed outcome exposes its error.")]
     public void AFailedOutcomeExposesItsError() {
         // Setup
-        DomainError error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         Outcome<string> outcome = Outcome<string>.Failure(error);
@@ -82,7 +84,7 @@ public void AFailedOutcomeCannotBeCreatedFromANullError() {
     [Fact(DisplayName = "Accessing the value of a failed outcome throws the associated exception.")]
     public void AccessingTheValueOfAFailedOutcomeThrowsTheAssociatedException() {
         // Setup
-        DomainError     error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError     error   = ErrorFactory.Domain(Any.ErrorCode(), "boom");
         Outcome<string> outcome = Outcome<string>.Failure(error);
 
         // Exercise & verify
@@ -94,7 +96,7 @@ public void AccessingTheValueOfAFailedOutcomeThrowsTheAssociatedException() {
     [Fact(DisplayName = "Escalating a failed outcome throws the associated exception.")]
     public void EscalatingAFailedOutcomeThrowsTheAssociatedException() {
         // Setup
-        DomainError     error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError     error   = ErrorFactory.Domain(Any.ErrorCode(), "boom");
         Outcome<string> outcome = Outcome<string>.Failure(error);
 
         // Exercise & verify
@@ -106,7 +108,7 @@ public void EscalatingAFailedOutcomeThrowsTheAssociatedException() {
     [Fact(DisplayName = "A failed outcome preserves the original error instance.")]
     public void FailedOutcomePreservesTheOriginalErrorInstance() {
         // Setup
-        DomainError     error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError     error   = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Outcome<string> outcome = Outcome<string>.Failure(error);
 
         // Exercise & verify
@@ -117,7 +119,7 @@ public void FailedOutcomePreservesTheOriginalErrorInstance() {
     [Fact(DisplayName = "ThrowIfFailure throws the associated exception when the outcome is a failure.")]
     public void ThrowIfFailureThrowsTheAssociatedExceptionWhenTheOutcomeIsAFailure() {
         // Setup
-        DomainError     error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError     error   = ErrorFactory.Domain(Any.ErrorCode(), "boom");
         Outcome<string> outcome = Outcome<string>.Failure(error);
 
         // Exercise & verify
@@ -129,7 +131,7 @@ public void ThrowIfFailureThrowsTheAssociatedExceptionWhenTheOutcomeIsAFailure()
     [Fact(DisplayName = "ThrowIfFailure does nothing when the outcome is a success.")]
     public void ThrowIfFailureDoesNothingWhenTheOutcomeIsASuccess() {
         // Setup
-        Outcome<string> outcome = Outcome<string>.Success("ok");
+        Outcome<string> outcome = Outcome<string>.Success(Any.String());
 
         // Exercise & verify
         Check.ThatCode(() => outcome.ThrowIfFailure()).DoesNotThrow();
@@ -151,7 +153,7 @@ public void ThenChainsTheNextStepWhenTheOutcomeIsASuccess() {
     [Fact(DisplayName = "Then short-circuits and propagates the error when the outcome is a failure.")]
     public void ThenShortCircuitsAndPropagatesTheErrorWhenTheOutcomeIsAFailure() {
         // Setup
-        DomainError  error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError  error   = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Outcome<int> outcome = Outcome<int>.Failure(error);
         bool         called  = false;
 
@@ -183,7 +185,7 @@ public void ToMapsTheValueWhenTheOutcomeIsASuccess() {
     [Fact(DisplayName = "Then (value mapping) propagates the error without invoking the converter on a failure.")]
     public void ToPropagatesTheErrorWithoutInvokingTheConverterOnAFailure() {
         // Setup
-        DomainError  error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError  error   = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Outcome<int> outcome = Outcome<int>.Failure(error);
 
         // Exercise
@@ -197,7 +199,7 @@ public void ToPropagatesTheErrorWithoutInvokingTheConverterOnAFailure() {
     [Fact(DisplayName = "Recover replaces a failure with a guaranteed fallback value.")]
     public void RecoverReplacesAFailureWithAGuaranteedFallbackValue() {
         // Setup
-        DomainError  error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError  error   = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
         Outcome<int> outcome = Outcome<int>.Failure(error);
 
         // Exercise
@@ -235,7 +237,7 @@ public void FinallyResolvesTheSuccessBranchWhenTheOutcomeIsASuccess() {
     [Fact(DisplayName = "Finally resolves the failure branch when the outcome is a failure.")]
     public void FinallyResolvesTheFailureBranchWhenTheOutcomeIsAFailure() {
         // Setup
-        DomainError  error   = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError  error   = ErrorFactory.Domain(Any.ErrorCode(), "boom");
         Outcome<int> outcome = Outcome<int>.Failure(error);
 
         // Exercise
@@ -248,7 +250,7 @@ public void FinallyResolvesTheFailureBranchWhenTheOutcomeIsAFailure() {
     [Fact(DisplayName = "The non-generic Outcome.Then chains when successful and propagates on failure.")]
     public void NonGenericOutcomeThenChainsWhenSuccessfulAndPropagatesOnFailure() {
         // Setup
-        DomainError error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         Outcome chainedFromSuccess = Outcome.Success.Then(() => Outcome.Success);
diff --git a/FirstClassErrors.UnitTests/PortInnerErrorsTests.cs b/FirstClassErrors.UnitTests/PortInnerErrorsTests.cs
index 02ace11..9724f29 100644
--- a/FirstClassErrors.UnitTests/PortInnerErrorsTests.cs
+++ b/FirstClassErrors.UnitTests/PortInnerErrorsTests.cs
@@ -1,5 +1,7 @@
 #region Usings declarations
 
+using FirstClassErrors.Testing;
+
 using JetBrains.Annotations;
 
 using NFluent;
@@ -27,8 +29,8 @@ public void ComputeTransienceOfAnEmptyCollectionIsUnknown() {
     public void ComputeTransienceIsNonTransientWhenAnyEntryIsNonTransient() {
         // Setup
         PrimaryPortInnerErrors innerErrors = new PrimaryPortInnerErrors()
-                                            .Add(ErrorFactory.Primary(ErrorCode.Unspecified, "transient", Transience.Transient))
-                                            .Add(ErrorFactory.Primary(ErrorCode.Unspecified, "non-transient", Transience.NonTransient));
+                                            .Add(ErrorFactory.Primary(Any.ErrorCode(), Any.DiagnosticMessage(), Transience.Transient))
+                                            .Add(ErrorFactory.Primary(Any.ErrorCode(), Any.DiagnosticMessage(), Transience.NonTransient));
 
         // Exercise
         Transience transience = innerErrors.ComputeTransience();
@@ -41,8 +43,8 @@ public void ComputeTransienceIsNonTransientWhenAnyEntryIsNonTransient() {
     public void ComputeTransienceIsTransientWhenAtLeastOneEntryIsTransientAndNoneIsNonTransient() {
         // Setup
         PrimaryPortInnerErrors innerErrors = new PrimaryPortInnerErrors()
-                                            .Add(ErrorFactory.Primary(ErrorCode.Unspecified, "unknown", Transience.Unknown))
-                                            .Add(ErrorFactory.Primary(ErrorCode.Unspecified, "transient", Transience.Transient));
+                                            .Add(ErrorFactory.Primary(Any.ErrorCode(), Any.DiagnosticMessage(), Transience.Unknown))
+                                            .Add(ErrorFactory.Primary(Any.ErrorCode(), Any.DiagnosticMessage(), Transience.Transient));
 
         // Exercise
         Transience transience = innerErrors.ComputeTransience();
@@ -55,8 +57,8 @@ public void ComputeTransienceIsTransientWhenAtLeastOneEntryIsTransientAndNoneIsN
     public void ComputeTransienceIsUnknownWhenTheCollectionContainsOnlyDomainErrors() {
         // Setup
         PrimaryPortInnerErrors innerErrors = new PrimaryPortInnerErrors()
-                                            .Add(ErrorFactory.Domain(ErrorCode.Unspecified, "first"))
-                                            .Add(ErrorFactory.Domain(ErrorCode.Unspecified, "second"));
+                                            .Add(ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage()))
+                                            .Add(ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage()));
 
         // Exercise
         Transience transience = innerErrors.ComputeTransience();
@@ -68,8 +70,8 @@ public void ComputeTransienceIsUnknownWhenTheCollectionContainsOnlyDomainErrors(
     [Fact(DisplayName = "Add ignores null domain and primary port errors.")]
     public void AddIgnoresNullDomainAndPrimaryPortErrors() {
         // Setup
-        DomainError      domainError      = ErrorFactory.Domain(ErrorCode.Unspecified, "domain");
-        PrimaryPortError primaryPortError = ErrorFactory.Primary(ErrorCode.Unspecified, "primary", Transience.NonTransient);
+        DomainError      domainError      = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
+        PrimaryPortError primaryPortError = ErrorFactory.Primary(Any.ErrorCode(), Any.DiagnosticMessage(), Any.Transience());
 
         PrimaryPortInnerErrors innerErrors = new PrimaryPortInnerErrors()
                                             .Add((DomainError)null!)
@@ -78,7 +80,7 @@ public void AddIgnoresNullDomainAndPrimaryPortErrors() {
                                             .Add(primaryPortError);
 
         // Exercise
-        PrimaryPortError root = ErrorFactory.Primary(ErrorCode.Unspecified, "root", innerErrors);
+        PrimaryPortError root = ErrorFactory.Primary(Any.ErrorCode(), Any.DiagnosticMessage(), innerErrors);
 
         // Verify
         Check.That(root.InnerErrors).CountIs(2);
@@ -88,8 +90,8 @@ public void AddIgnoresNullDomainAndPrimaryPortErrors() {
     public void AddReturnsTheSameInstanceToAllowFluentChaining() {
         // Setup
         PrimaryPortInnerErrors innerErrors = new();
-        DomainError            domainError = ErrorFactory.Domain(ErrorCode.Unspecified, "domain");
-        PrimaryPortError       portError   = ErrorFactory.Primary(ErrorCode.Unspecified, "primary", Transience.Transient);
+        DomainError            domainError = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
+        PrimaryPortError       portError   = ErrorFactory.Primary(Any.ErrorCode(), Any.DiagnosticMessage(), Any.Transience());
 
         // Exercise & verify
         Check.That(innerErrors.Add(domainError)).IsSameReferenceAs(innerErrors);
@@ -99,15 +101,15 @@ public void AddReturnsTheSameInstanceToAllowFluentChaining() {
     [Fact(DisplayName = "A primary port error built from inner errors exposes the aggregated transience and the inner errors.")]
     public void APrimaryPortErrorBuiltFromInnerErrorsExposesTheAggregatedTransienceAndTheInnerErrors() {
         // Setup
-        DomainError      firstInnerError  = ErrorFactory.Domain(ErrorCode.Unspecified, "first");
-        PrimaryPortError secondInnerError = ErrorFactory.Primary(ErrorCode.Unspecified, "second", Transience.Transient);
+        DomainError      firstInnerError  = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
+        PrimaryPortError secondInnerError = ErrorFactory.Primary(Any.ErrorCode(), Any.DiagnosticMessage(), Transience.Transient);
 
         PrimaryPortInnerErrors innerErrors = new PrimaryPortInnerErrors()
                                             .Add(firstInnerError)
                                             .Add(secondInnerError);
 
         // Exercise
-        PrimaryPortError root = ErrorFactory.Primary(ErrorCode.Unspecified, "root", innerErrors);
+        PrimaryPortError root = ErrorFactory.Primary(Any.ErrorCode(), Any.DiagnosticMessage(), innerErrors);
 
         // Verify
         Check.That(root.Transience).IsEqualTo(innerErrors.ComputeTransience());
@@ -121,8 +123,8 @@ public void APrimaryPortErrorBuiltFromInnerErrorsExposesTheAggregatedTransienceA
     public void ToStringRendersThePluralizedCountOfAggregatedErrors() {
         // Setup
         PrimaryPortInnerErrors innerErrors = new PrimaryPortInnerErrors()
-                                            .Add(ErrorFactory.Domain(ErrorCode.Unspecified, "first"))
-                                            .Add(ErrorFactory.Primary(ErrorCode.Unspecified, "second", Transience.Transient));
+                                            .Add(ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage()))
+                                            .Add(ErrorFactory.Primary(Any.ErrorCode(), Any.DiagnosticMessage(), Any.Transience()));
 
         // Exercise & verify
         Check.That(innerErrors.ToString()).IsEqualTo("2 inner errors");
@@ -132,7 +134,7 @@ public void ToStringRendersThePluralizedCountOfAggregatedErrors() {
     public void ToStringRendersTheSingularFormForASingleAggregatedError() {
         // Setup
         PrimaryPortInnerErrors innerErrors = new PrimaryPortInnerErrors()
-            .Add(ErrorFactory.Domain(ErrorCode.Unspecified, "only"));
+            .Add(ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage()));
 
         // Exercise & verify
         Check.That(innerErrors.ToString()).IsEqualTo("1 inner error");
@@ -156,8 +158,8 @@ public sealed class SecondaryPortInnerErrorsTests {
     public void ComputeTransienceIsNonTransientWhenAnyEntryIsNonTransient() {
         // Setup
         SecondaryPortInnerErrors innerErrors = new SecondaryPortInnerErrors()
-                                              .Add(ErrorFactory.Secondary(ErrorCode.Unspecified, "transient", Transience.Transient))
-                                              .Add(ErrorFactory.Secondary(ErrorCode.Unspecified, "non-transient", Transience.NonTransient));
+                                              .Add(ErrorFactory.Secondary(Any.ErrorCode(), Any.DiagnosticMessage(), Transience.Transient))
+                                              .Add(ErrorFactory.Secondary(Any.ErrorCode(), Any.DiagnosticMessage(), Transience.NonTransient));
 
         // Exercise
         Transience transience = innerErrors.ComputeTransience();
@@ -170,8 +172,8 @@ public void ComputeTransienceIsNonTransientWhenAnyEntryIsNonTransient() {
     public void ComputeTransienceIsTransientWhenAtLeastOneEntryIsTransientAndNoneIsNonTransient() {
         // Setup
         SecondaryPortInnerErrors innerErrors = new SecondaryPortInnerErrors()
-                                              .Add(ErrorFactory.Secondary(ErrorCode.Unspecified, "unknown", Transience.Unknown))
-                                              .Add(ErrorFactory.Secondary(ErrorCode.Unspecified, "transient", Transience.Transient));
+                                              .Add(ErrorFactory.Secondary(Any.ErrorCode(), Any.DiagnosticMessage(), Transience.Unknown))
+                                              .Add(ErrorFactory.Secondary(Any.ErrorCode(), Any.DiagnosticMessage(), Transience.Transient));
 
         // Exercise
         Transience transience = innerErrors.ComputeTransience();
@@ -184,8 +186,8 @@ public void ComputeTransienceIsTransientWhenAtLeastOneEntryIsTransientAndNoneIsN
     public void ComputeTransienceIsUnknownWhenTheCollectionContainsOnlyDomainErrors() {
         // Setup
         SecondaryPortInnerErrors innerErrors = new SecondaryPortInnerErrors()
-                                              .Add(ErrorFactory.Domain(ErrorCode.Unspecified, "first"))
-                                              .Add(ErrorFactory.Domain(ErrorCode.Unspecified, "second"));
+                                              .Add(ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage()))
+                                              .Add(ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage()));
 
         // Exercise
         Transience transience = innerErrors.ComputeTransience();
@@ -197,8 +199,8 @@ public void ComputeTransienceIsUnknownWhenTheCollectionContainsOnlyDomainErrors(
     [Fact(DisplayName = "Add ignores null domain and secondary port errors.")]
     public void AddIgnoresNullDomainAndSecondaryPortErrors() {
         // Setup
-        DomainError        domainError        = ErrorFactory.Domain(ErrorCode.Unspecified, "domain");
-        SecondaryPortError secondaryPortError = ErrorFactory.Secondary(ErrorCode.Unspecified, "secondary", Transience.NonTransient);
+        DomainError        domainError        = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
+        SecondaryPortError secondaryPortError = ErrorFactory.Secondary(Any.ErrorCode(), Any.DiagnosticMessage(), Any.Transience());
 
         SecondaryPortInnerErrors innerErrors = new SecondaryPortInnerErrors()
                                               .Add((DomainError)null!)
@@ -207,7 +209,7 @@ public void AddIgnoresNullDomainAndSecondaryPortErrors() {
                                               .Add(secondaryPortError);
 
         // Exercise
-        SecondaryPortError root = ErrorFactory.Secondary(ErrorCode.Unspecified, "root", innerErrors);
+        SecondaryPortError root = ErrorFactory.Secondary(Any.ErrorCode(), Any.DiagnosticMessage(), innerErrors);
 
         // Verify
         Check.That(root.InnerErrors).CountIs(2);
@@ -217,8 +219,8 @@ public void AddIgnoresNullDomainAndSecondaryPortErrors() {
     public void AddReturnsTheSameInstanceToAllowFluentChaining() {
         // Setup
         SecondaryPortInnerErrors innerErrors = new();
-        DomainError              domainError = ErrorFactory.Domain(ErrorCode.Unspecified, "domain");
-        SecondaryPortError       portError   = ErrorFactory.Secondary(ErrorCode.Unspecified, "secondary", Transience.Transient);
+        DomainError              domainError = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
+        SecondaryPortError       portError   = ErrorFactory.Secondary(Any.ErrorCode(), Any.DiagnosticMessage(), Any.Transience());
 
         // Exercise & verify
         Check.That(innerErrors.Add(domainError)).IsSameReferenceAs(innerErrors);
@@ -229,8 +231,8 @@ public void AddReturnsTheSameInstanceToAllowFluentChaining() {
     public void ToStringRendersThePluralizedCountOfAggregatedErrors() {
         // Setup
         SecondaryPortInnerErrors innerErrors = new SecondaryPortInnerErrors()
-                                              .Add(ErrorFactory.Domain(ErrorCode.Unspecified, "first"))
-                                              .Add(ErrorFactory.Secondary(ErrorCode.Unspecified, "second", Transience.Transient));
+                                              .Add(ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage()))
+                                              .Add(ErrorFactory.Secondary(Any.ErrorCode(), Any.DiagnosticMessage(), Any.Transience()));
 
         // Exercise & verify
         Check.That(innerErrors.ToString()).IsEqualTo("2 inner errors");
@@ -240,7 +242,7 @@ public void ToStringRendersThePluralizedCountOfAggregatedErrors() {
     public void ToStringRendersTheSingularFormForASingleAggregatedError() {
         // Setup
         SecondaryPortInnerErrors innerErrors = new SecondaryPortInnerErrors()
-            .Add(ErrorFactory.Domain(ErrorCode.Unspecified, "only"));
+            .Add(ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage()));
 
         // Exercise & verify
         Check.That(innerErrors.ToString()).IsEqualTo("1 inner error");
@@ -270,15 +272,15 @@ public void ComputeTransienceOfAnEmptyCollectionIsUnknown() {
     [Fact(DisplayName = "A secondary port error built from inner errors exposes the aggregated transience and the inner errors.")]
     public void ASecondaryPortErrorBuiltFromInnerErrorsExposesTheAggregatedTransienceAndTheInnerErrors() {
         // Setup
-        DomainError        firstInnerError  = ErrorFactory.Domain(ErrorCode.Unspecified, "first");
-        SecondaryPortError secondInnerError = ErrorFactory.Secondary(ErrorCode.Unspecified, "second", Transience.NonTransient);
+        DomainError        firstInnerError  = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
+        SecondaryPortError secondInnerError = ErrorFactory.Secondary(Any.ErrorCode(), Any.DiagnosticMessage(), Transience.NonTransient);
 
         SecondaryPortInnerErrors innerErrors = new SecondaryPortInnerErrors()
                                               .Add(firstInnerError)
                                               .Add(secondInnerError);
 
         // Exercise
-        SecondaryPortError root = ErrorFactory.Secondary(ErrorCode.Unspecified, "root", innerErrors);
+        SecondaryPortError root = ErrorFactory.Secondary(Any.ErrorCode(), Any.DiagnosticMessage(), innerErrors);
 
         // Verify
         Check.That(root.Transience).IsEqualTo(innerErrors.ComputeTransience());
diff --git a/FirstClassErrors.UnitTests/ToExceptionTests.cs b/FirstClassErrors.UnitTests/ToExceptionTests.cs
index 58c3523..c809f5a 100644
--- a/FirstClassErrors.UnitTests/ToExceptionTests.cs
+++ b/FirstClassErrors.UnitTests/ToExceptionTests.cs
@@ -1,5 +1,7 @@
 #region Usings declarations
 
+using FirstClassErrors.Testing;
+
 using JetBrains.Annotations;
 
 using NFluent;
@@ -14,7 +16,7 @@ public sealed class ToExceptionTests {
     [Fact(DisplayName = "Converting a domain error produces a domain exception.")]
     public void ConvertingADomainErrorProducesADomainException() {
         // Setup
-        DomainError error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         DiagnosableException exception = error.ToException();
@@ -26,7 +28,7 @@ public void ConvertingADomainErrorProducesADomainException() {
     [Fact(DisplayName = "Converting an infrastructure error produces an infrastructure exception.")]
     public void ConvertingAnInfrastructureErrorProducesAnInfrastructureException() {
         // Setup
-        InfrastructureError error = ErrorFactory.Infrastructure(ErrorCode.Unspecified, "boom", InteractionDirection.Incoming, Transience.NonTransient);
+        InfrastructureError error = ErrorFactory.Infrastructure(Any.ErrorCode(), Any.DiagnosticMessage(), Any.InteractionDirection(), Any.Transience());
 
         // Exercise
         DiagnosableException exception = error.ToException();
@@ -38,7 +40,7 @@ public void ConvertingAnInfrastructureErrorProducesAnInfrastructureException() {
     [Fact(DisplayName = "Converting a primary port error produces a primary port exception.")]
     public void ConvertingAPrimaryPortErrorProducesAPrimaryPortException() {
         // Setup
-        PrimaryPortError error = ErrorFactory.Primary(ErrorCode.Unspecified, "boom", Transience.NonTransient);
+        PrimaryPortError error = ErrorFactory.Primary(Any.ErrorCode(), Any.DiagnosticMessage(), Any.Transience());
 
         // Exercise
         DiagnosableException exception = error.ToException();
@@ -50,7 +52,7 @@ public void ConvertingAPrimaryPortErrorProducesAPrimaryPortException() {
     [Fact(DisplayName = "Converting a secondary port error produces a secondary port exception.")]
     public void ConvertingASecondaryPortErrorProducesASecondaryPortException() {
         // Setup
-        SecondaryPortError error = ErrorFactory.Secondary(ErrorCode.Unspecified, "boom", Transience.NonTransient);
+        SecondaryPortError error = ErrorFactory.Secondary(Any.ErrorCode(), Any.DiagnosticMessage(), Any.Transience());
 
         // Exercise
         DiagnosableException exception = error.ToException();
@@ -62,7 +64,7 @@ public void ConvertingASecondaryPortErrorProducesASecondaryPortException() {
     [Fact(DisplayName = "The converted exception carries the same error reference.")]
     public void TheConvertedExceptionCarriesTheSameErrorReference() {
         // Setup
-        DomainError error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         DiagnosableException exception = error.ToException();
@@ -74,7 +76,7 @@ public void TheConvertedExceptionCarriesTheSameErrorReference() {
     [Fact(DisplayName = "The converted exception message equals the error diagnostic message.")]
     public void TheConvertedExceptionMessageEqualsTheErrorDiagnosticMessage() {
         // Setup
-        DomainError error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         DiagnosableException exception = error.ToException();
@@ -86,7 +88,7 @@ public void TheConvertedExceptionMessageEqualsTheErrorDiagnosticMessage() {
     [Fact(DisplayName = "The converted exception has no inner exception even when the error has inner errors.")]
     public void TheConvertedExceptionHasNoInnerExceptionEvenWhenTheErrorHasInnerErrors() {
         // Setup
-        DomainError error = ErrorFactory.Domain(ErrorCode.Unspecified, "root", ErrorFactory.Domain(ErrorCode.Unspecified, "inner"));
+        DomainError error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage(), ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage()));
 
         // Exercise
         DiagnosableException exception = error.ToException();
@@ -99,7 +101,7 @@ public void TheConvertedExceptionHasNoInnerExceptionEvenWhenTheErrorHasInnerErro
     [Fact(DisplayName = "Throwing and catching a converted error preserves the error reference.")]
     public void ThrowingAndCatchingAConvertedErrorPreservesTheErrorReference() {
         // Setup
-        DomainError error = ErrorFactory.Domain(ErrorCode.Unspecified, "boom");
+        DomainError error = ErrorFactory.Domain(Any.ErrorCode(), Any.DiagnosticMessage());
 
         // Exercise
         Error? caughtError = null;