diff --git a/genvalidity-hspec-cereal.cabal b/genvalidity-hspec-cereal.cabal
--- a/genvalidity-hspec-cereal.cabal
+++ b/genvalidity-hspec-cereal.cabal
@@ -1,5 +1,5 @@
 name: genvalidity-hspec-cereal
-version: 0.0.0.1
+version: 0.1.0.0
 cabal-version: >=1.10
 build-type: Simple
 license: MIT
@@ -22,11 +22,11 @@
         Test.Validity.Cereal
     build-depends:
         base >=4.9 && <=5,
-        genvalidity-hspec >=0.3 && <0.5,
-        genvalidity >=0.3 && <0.4,
-        hspec,
+        genvalidity-hspec >=0.5 && <0.6,
+        genvalidity >=0.4 && <0.5,
+        hspec -any,
         cereal >=0.5 && <0.6,
-        QuickCheck,
+        QuickCheck -any,
         deepseq >=1.4 && <1.5
     default-language: Haskell2010
     hs-source-dirs: src/
@@ -47,9 +47,9 @@
     main-is: Spec.hs
     build-depends:
         base -any,
-        genvalidity >=0.3 && <0.4,
+        genvalidity -any,
         genvalidity-hspec-cereal -any,
-        hspec
+        hspec -any
     default-language: Haskell2010
     hs-source-dirs: test/
     other-modules:
diff --git a/src/Test/Validity/Cereal.hs b/src/Test/Validity/Cereal.hs
--- a/src/Test/Validity/Cereal.hs
+++ b/src/Test/Validity/Cereal.hs
@@ -30,44 +30,43 @@
 -- Example usage:
 --
 -- > serializeSpecOnValid @Double
-serializeSpecOnValid
-    :: forall a.
-       (Show a, Eq a, Typeable a, GenValid a, Serialize a)
+serializeSpecOnValid ::
+       forall a. (Show a, Eq a, Typeable a, GenValid a, Serialize a)
     => Spec
-serializeSpecOnValid = serializeSpecOnGen (genValid @a) "valid"
+serializeSpecOnValid = serializeSpecOnGen (genValid @a) "valid" shrinkValid
 
 -- | Standard test spec for properties of 'Serialize'-related functions for unchecked values
 --
 -- Example usage:
 --
 -- > serializeSpec @Int
-serializeSpec
-    :: forall a.
-       (Show a, Eq a, Typeable a, GenUnchecked a, Serialize a)
+serializeSpec ::
+       forall a. (Show a, Eq a, Typeable a, GenUnchecked a, Serialize a)
     => Spec
-serializeSpec = serializeSpecOnGen (genUnchecked @a) "unchecked"
+serializeSpec = serializeSpecOnGen (genUnchecked @a) "unchecked" shrinkUnchecked
 
 -- | Standard test spec for properties of 'Serialize'-related functions for arbitrary values
 --
 -- Example usage:
 --
 -- > serializeSpecOnArbitrary @Int
-serializeSpecOnArbitrary
-    :: forall a.
-       (Show a, Eq a, Typeable a, Arbitrary a, Serialize a)
+serializeSpecOnArbitrary ::
+       forall a. (Show a, Eq a, Typeable a, Arbitrary a, Serialize a)
     => Spec
-serializeSpecOnArbitrary = serializeSpecOnGen (arbitrary @a) "arbitrary"
+serializeSpecOnArbitrary = serializeSpecOnGen (arbitrary @a) "arbitrary" shrink
 
 -- | Standard test spec for properties of 'Serialize'-related functions for a given generator (and a name for that generator).
 --
 -- Example usage:
 --
 -- > serializeSpecOnGen (genListOf $ pure 'a') "sequence of 'a's"
-serializeSpecOnGen
-    :: forall a.
-       (Show a, Eq a, Typeable a, Serialize a)
-    => Gen a -> String -> Spec
-serializeSpecOnGen gen genname =
+serializeSpecOnGen ::
+       forall a. (Show a, Eq a, Typeable a, Serialize a)
+    => Gen a
+    -> String
+    -> (a -> [a])
+    -> Spec
+serializeSpecOnGen gen genname s =
     parallel $ do
         let name = nameOf @a
         describe ("Serialize " ++ name ++ " (" ++ genname ++ ")") $ do
@@ -78,7 +77,7 @@
                          , "\"" ++ genname
                          , name ++ "\""
                          ]) $
-                neverFailsToEncodeOnGen gen
+                neverFailsToEncodeOnGen gen s
             describe ("decode :: " ++ name ++ " -> Data.ByteString.ByteString") $
                 it
                     (unwords
@@ -86,34 +85,32 @@
                          , "\"" ++ genname
                          , name ++ "\"" ++ "'s"
                          ]) $
-                encodeAndDecodeAreInversesOnGen gen
+                encodeAndDecodeAreInversesOnGen gen s
 
 -- |
 --
--- prop> neverFailsToEncodeOnGen @Bool arbitrary
--- prop> neverFailsToEncodeOnGen @Bool genUnchecked
--- prop> neverFailsToEncodeOnGen @Bool genValid
--- prop> neverFailsToEncodeOnGen @Int arbitrary
--- prop> neverFailsToEncodeOnGen @Int genUnchecked
--- prop> neverFailsToEncodeOnGen @Int genValid
-neverFailsToEncodeOnGen
-    :: (Show a, Serialize a)
-    => Gen a -> Property
-neverFailsToEncodeOnGen gen =
-    forAll gen $ \(a :: a) ->
+-- prop> neverFailsToEncodeOnGen @Bool arbitrary shrink
+-- prop> neverFailsToEncodeOnGen @Bool genUnchecked shrinkUnchecked
+-- prop> neverFailsToEncodeOnGen @Bool genValid shrinkValid
+-- prop> neverFailsToEncodeOnGen @Int arbitrary shrink
+-- prop> neverFailsToEncodeOnGen @Int genUnchecked shrinkUnchecked
+-- prop> neverFailsToEncodeOnGen @Int genValid shrinkValid
+neverFailsToEncodeOnGen ::
+       (Show a, Serialize a) => Gen a -> (a -> [a]) -> Property
+neverFailsToEncodeOnGen gen s =
+    forAllShrink gen s $ \(a :: a) ->
         evaluate (deepseq (Serialize.encode a) ()) `shouldReturn` ()
 
 -- |
 --
--- prop> encodeAndDecodeAreInversesOnGen @Bool arbitrary
--- prop> encodeAndDecodeAreInversesOnGen @Bool genUnchecked
--- prop> encodeAndDecodeAreInversesOnGen @Bool genValid
--- prop> encodeAndDecodeAreInversesOnGen @Int arbitrary
--- prop> encodeAndDecodeAreInversesOnGen @Int genUnchecked
--- prop> encodeAndDecodeAreInversesOnGen @Int genValid
-encodeAndDecodeAreInversesOnGen
-    :: (Show a, Eq a, Serialize a)
-    => Gen a -> Property
-encodeAndDecodeAreInversesOnGen gen =
-    forAll gen $ \(a :: a) ->
+-- prop> encodeAndDecodeAreInversesOnGen @Bool arbitrary shrink
+-- prop> encodeAndDecodeAreInversesOnGen @Bool genUnchecked shrinkUnchecked
+-- prop> encodeAndDecodeAreInversesOnGen @Bool genValid shrinkValid
+-- prop> encodeAndDecodeAreInversesOnGen @Int arbitrary shrink
+-- prop> encodeAndDecodeAreInversesOnGen @Int genUnchecked shrinkUnchecked
+-- prop> encodeAndDecodeAreInversesOnGen @Int genValid shrinkValid
+encodeAndDecodeAreInversesOnGen ::
+       (Show a, Eq a, Serialize a) => Gen a -> (a -> [a]) -> Property
+encodeAndDecodeAreInversesOnGen gen s =
+    forAllShrink gen s $ \(a :: a) ->
         Serialize.decode (Serialize.encode a) `shouldBe` Right a
diff --git a/test/Test/Validity/CerealSpec.hs b/test/Test/Validity/CerealSpec.hs
--- a/test/Test/Validity/CerealSpec.hs
+++ b/test/Test/Validity/CerealSpec.hs
@@ -9,7 +9,7 @@
 
 spec :: Spec
 spec = do
-    serializeSpecOnGen (genListOf $ pure 'a') "sequence of 'a's"
+    serializeSpecOnGen (genListOf $ pure 'a') "sequence of 'a's" (const [])
     serializeSpecOnValid @Double
     serializeSpec @Int
     serializeSpecOnArbitrary @Int