diff --git a/.golangci.yml b/.golangci.yml
index b61e853582c8..435cc2735528 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -62,7 +62,7 @@ linters-settings:
     local-prefixes: "sigs.k8s.io/cluster-api"
   ginkgolinter:
     # Suppress the wrong length assertion warning.
-    suppress-len-assertion: true
+    suppress-len-assertion: false
     # Suppress the wrong nil assertion warning.
     suppress-nil-assertion: false
     # Suppress the wrong error assertion warning.
diff --git a/bootstrap/kubeadm/internal/controllers/kubeadmconfig_controller_test.go b/bootstrap/kubeadm/internal/controllers/kubeadmconfig_controller_test.go
index 22cf8913adbd..4038c3a16f88 100644
--- a/bootstrap/kubeadm/internal/controllers/kubeadmconfig_controller_test.go
+++ b/bootstrap/kubeadm/internal/controllers/kubeadmconfig_controller_test.go
@@ -524,7 +524,7 @@ func TestKubeadmConfigReconciler_Reconcile_GenerateCloudConfigData(t *testing.T)
 
 	// Expect the Secret to exist, and for it to contain some data under the "value" key.
 	g.Expect(myclient.Get(ctx, client.ObjectKey{Namespace: metav1.NamespaceDefault, Name: configName}, s)).To(Succeed())
-	g.Expect(len(s.Data["value"])).To(BeNumerically(">", 0))
+	g.Expect(s.Data["value"]).ToNot(BeEmpty())
 	// Ensure that we don't fail trying to refresh any bootstrap tokens
 	_, err = k.Reconcile(ctx, request)
 	g.Expect(err).NotTo(HaveOccurred())
@@ -703,7 +703,7 @@ func TestReconcileIfJoinCertificatesAvailableConditioninNodesAndControlPlaneIsRe
 			l := &corev1.SecretList{}
 			err = myclient.List(ctx, l, client.ListOption(client.InNamespace(metav1.NamespaceSystem)))
 			g.Expect(err).NotTo(HaveOccurred())
-			g.Expect(len(l.Items)).To(Equal(1))
+			g.Expect(l.Items).To(HaveLen(1))
 		})
 	}
 }
@@ -779,7 +779,7 @@ func TestReconcileIfJoinNodePoolsAndControlPlaneIsReady(t *testing.T) {
 			l := &corev1.SecretList{}
 			err = myclient.List(ctx, l, client.ListOption(client.InNamespace(metav1.NamespaceSystem)))
 			g.Expect(err).NotTo(HaveOccurred())
-			g.Expect(len(l.Items)).To(Equal(1))
+			g.Expect(l.Items).To(HaveLen(1))
 		})
 	}
 }
@@ -1053,7 +1053,7 @@ func TestBootstrapTokenTTLExtension(t *testing.T) {
 	l := &corev1.SecretList{}
 	err = myclient.List(ctx, l, client.ListOption(client.InNamespace(metav1.NamespaceSystem)))
 	g.Expect(err).NotTo(HaveOccurred())
-	g.Expect(len(l.Items)).To(Equal(2))
+	g.Expect(l.Items).To(HaveLen(2))
 
 	// ensure that the token is refreshed...
 	tokenExpires := make([][]byte, len(l.Items))
@@ -1086,7 +1086,7 @@ func TestBootstrapTokenTTLExtension(t *testing.T) {
 	l = &corev1.SecretList{}
 	err = myclient.List(ctx, l, client.ListOption(client.InNamespace(metav1.NamespaceSystem)))
 	g.Expect(err).NotTo(HaveOccurred())
-	g.Expect(len(l.Items)).To(Equal(2))
+	g.Expect(l.Items).To(HaveLen(2))
 
 	for i, item := range l.Items {
 		g.Expect(bytes.Equal(tokenExpires[i], item.Data[bootstrapapi.BootstrapTokenExpirationKey])).To(BeFalse())
@@ -1128,7 +1128,7 @@ func TestBootstrapTokenTTLExtension(t *testing.T) {
 	l = &corev1.SecretList{}
 	err = myclient.List(ctx, l, client.ListOption(client.InNamespace(metav1.NamespaceSystem)))
 	g.Expect(err).NotTo(HaveOccurred())
-	g.Expect(len(l.Items)).To(Equal(2))
+	g.Expect(l.Items).To(HaveLen(2))
 
 	for i, item := range l.Items {
 		g.Expect(bytes.Equal(tokenExpires[i], item.Data[bootstrapapi.BootstrapTokenExpirationKey])).To(BeFalse())
@@ -1179,7 +1179,7 @@ func TestBootstrapTokenTTLExtension(t *testing.T) {
 	l = &corev1.SecretList{}
 	err = myclient.List(ctx, l, client.ListOption(client.InNamespace(metav1.NamespaceSystem)))
 	g.Expect(err).NotTo(HaveOccurred())
-	g.Expect(len(l.Items)).To(Equal(2))
+	g.Expect(l.Items).To(HaveLen(2))
 
 	for i, item := range l.Items {
 		g.Expect(bytes.Equal(tokenExpires[i], item.Data[bootstrapapi.BootstrapTokenExpirationKey])).To(BeTrue())
@@ -1237,7 +1237,7 @@ func TestBootstrapTokenRotationMachinePool(t *testing.T) {
 	l := &corev1.SecretList{}
 	err = myclient.List(ctx, l, client.ListOption(client.InNamespace(metav1.NamespaceSystem)))
 	g.Expect(err).NotTo(HaveOccurred())
-	g.Expect(len(l.Items)).To(Equal(1))
+	g.Expect(l.Items).To(HaveLen(1))
 
 	// ensure that the token is refreshed...
 	tokenExpires := make([][]byte, len(l.Items))
@@ -1264,7 +1264,7 @@ func TestBootstrapTokenRotationMachinePool(t *testing.T) {
 	l = &corev1.SecretList{}
 	err = myclient.List(ctx, l, client.ListOption(client.InNamespace(metav1.NamespaceSystem)))
 	g.Expect(err).NotTo(HaveOccurred())
-	g.Expect(len(l.Items)).To(Equal(1))
+	g.Expect(l.Items).To(HaveLen(1))
 
 	for i, item := range l.Items {
 		g.Expect(bytes.Equal(tokenExpires[i], item.Data[bootstrapapi.BootstrapTokenExpirationKey])).To(BeFalse())
@@ -1292,7 +1292,7 @@ func TestBootstrapTokenRotationMachinePool(t *testing.T) {
 	l = &corev1.SecretList{}
 	err = myclient.List(ctx, l, client.ListOption(client.InNamespace(metav1.NamespaceSystem)))
 	g.Expect(err).NotTo(HaveOccurred())
-	g.Expect(len(l.Items)).To(Equal(1))
+	g.Expect(l.Items).To(HaveLen(1))
 
 	for i, item := range l.Items {
 		g.Expect(bytes.Equal(tokenExpires[i], item.Data[bootstrapapi.BootstrapTokenExpirationKey])).To(BeFalse())
@@ -1324,7 +1324,7 @@ func TestBootstrapTokenRotationMachinePool(t *testing.T) {
 	l = &corev1.SecretList{}
 	err = myclient.List(ctx, l, client.ListOption(client.InNamespace(metav1.NamespaceSystem)))
 	g.Expect(err).NotTo(HaveOccurred())
-	g.Expect(len(l.Items)).To(Equal(1))
+	g.Expect(l.Items).To(HaveLen(1))
 
 	for i, item := range l.Items {
 		g.Expect(bytes.Equal(tokenExpires[i], item.Data[bootstrapapi.BootstrapTokenExpirationKey])).To(BeTrue())
@@ -1349,7 +1349,7 @@ func TestBootstrapTokenRotationMachinePool(t *testing.T) {
 	l = &corev1.SecretList{}
 	err = myclient.List(ctx, l, client.ListOption(client.InNamespace(metav1.NamespaceSystem)))
 	g.Expect(err).NotTo(HaveOccurred())
-	g.Expect(len(l.Items)).To(Equal(2))
+	g.Expect(l.Items).To(HaveLen(2))
 	foundOld := false
 	foundNew := true
 	for _, item := range l.Items {
diff --git a/cmd/clusterctl/client/cluster/components_test.go b/cmd/clusterctl/client/cluster/components_test.go
index 66707707217c..a3fa9dd7529b 100644
--- a/cmd/clusterctl/client/cluster/components_test.go
+++ b/cmd/clusterctl/client/cluster/components_test.go
@@ -326,7 +326,7 @@ func Test_providerComponents_DeleteCoreProviderWebhookNamespace(t *testing.T) {
 
 		// assert length before deleting
 		_ = proxyClient.List(ctx, &nsList)
-		g.Expect(len(nsList.Items)).Should(Equal(1))
+		g.Expect(nsList.Items).Should(HaveLen(1))
 
 		c := newComponentsClient(proxy)
 		err := c.DeleteWebhookNamespace()
@@ -334,7 +334,7 @@ func Test_providerComponents_DeleteCoreProviderWebhookNamespace(t *testing.T) {
 
 		// assert length after deleting
 		_ = proxyClient.List(ctx, &nsList)
-		g.Expect(len(nsList.Items)).Should(Equal(0))
+		g.Expect(nsList.Items).Should(BeEmpty())
 	})
 }
 
diff --git a/cmd/clusterctl/client/cluster/objectgraph_test.go b/cmd/clusterctl/client/cluster/objectgraph_test.go
index b06e2ac33beb..4f9ee1d1f89e 100644
--- a/cmd/clusterctl/client/cluster/objectgraph_test.go
+++ b/cmd/clusterctl/client/cluster/objectgraph_test.go
@@ -252,7 +252,7 @@ func assertGraph(t *testing.T, got *objectGraph, want wantGraph) {
 
 	g := NewWithT(t)
 
-	g.Expect(len(got.uidToNode)).To(Equal(len(want.nodes)), "the number of nodes in the objectGraph doesn't match the number of expected nodes")
+	g.Expect(got.uidToNode).To(HaveLen(len(want.nodes)), "the number of nodes in the objectGraph doesn't match the number of expected nodes")
 
 	for uid, wantNode := range want.nodes {
 		gotNode, ok := got.uidToNode[types.UID(uid)]
diff --git a/cmd/clusterctl/client/cluster/topology_test.go b/cmd/clusterctl/client/cluster/topology_test.go
index c7ef04161f05..7509a2bbbaa7 100644
--- a/cmd/clusterctl/client/cluster/topology_test.go
+++ b/cmd/clusterctl/client/cluster/topology_test.go
@@ -284,13 +284,13 @@ func Test_topologyClient_Plan(t *testing.T) {
 			g.Expect(err).NotTo(HaveOccurred())
 
 			// Check affected ClusterClasses.
-			g.Expect(len(res.ClusterClasses)).To(Equal(len(tt.want.affectedClusterClasses)))
+			g.Expect(res.ClusterClasses).To(HaveLen(len(tt.want.affectedClusterClasses)))
 			for _, cc := range tt.want.affectedClusterClasses {
 				g.Expect(res.ClusterClasses).To(ContainElement(cc))
 			}
 
 			// Check affected Clusters.
-			g.Expect(len(res.Clusters)).To(Equal(len(tt.want.affectedClusters)))
+			g.Expect(res.Clusters).To(HaveLen(len(tt.want.affectedClusters)))
 			for _, cluster := range tt.want.affectedClusters {
 				g.Expect(res.Clusters).To(ContainElement(cluster))
 			}
diff --git a/cmd/clusterctl/client/config_test.go b/cmd/clusterctl/client/config_test.go
index ede509b616f6..690ab55af094 100644
--- a/cmd/clusterctl/client/config_test.go
+++ b/cmd/clusterctl/client/config_test.go
@@ -262,7 +262,7 @@ func Test_getComponentsByName_withEmptyVariables(t *testing.T) {
 	}
 	components, err := client.GetProviderComponents(repository1Config.Name(), repository1Config.Type(), options)
 	g.Expect(err).NotTo(HaveOccurred())
-	g.Expect(len(components.Variables())).To(Equal(1))
+	g.Expect(components.Variables()).To(HaveLen(1))
 	g.Expect(components.Name()).To(Equal("p1"))
 }
 
diff --git a/cmd/clusterctl/client/repository/template_test.go b/cmd/clusterctl/client/repository/template_test.go
index 46685a658c29..e44793411e08 100644
--- a/cmd/clusterctl/client/repository/template_test.go
+++ b/cmd/clusterctl/client/repository/template_test.go
@@ -154,8 +154,8 @@ metadata:
 
 	merged, err := MergeTemplates(template1, template2)
 	g.Expect(err).NotTo(HaveOccurred())
-	g.Expect(len(merged.Objs())).To(Equal(2))
-	g.Expect(len(merged.VariableMap())).To(Equal(3))
+	g.Expect(merged.Objs()).To(HaveLen(2))
+	g.Expect(merged.VariableMap()).To(HaveLen(3))
 
 	// Make sure that the SAME_VARIABLE default value comes from the first template
 	// that defines it
diff --git a/cmd/clusterctl/internal/util/obj_refs_test.go b/cmd/clusterctl/internal/util/obj_refs_test.go
index bd32b0dbaa94..860cd6b5ce0b 100644
--- a/cmd/clusterctl/internal/util/obj_refs_test.go
+++ b/cmd/clusterctl/internal/util/obj_refs_test.go
@@ -86,7 +86,7 @@ func TestGetObjectReferences(t *testing.T) {
 				return
 			}
 			g.Expect(err).NotTo(HaveOccurred())
-			g.Expect(len(got)).To(Equal(len(tt.want)))
+			g.Expect(got).To(HaveLen(len(tt.want)))
 			for i := range got {
 				g.Expect(got[i].Kind).To(Equal(tt.want[i].Kind))
 				g.Expect(got[i].Name).To(Equal(tt.want[i].Name))
diff --git a/controllers/remote/keyedmutex_test.go b/controllers/remote/keyedmutex_test.go
index c982bf093f9b..031fe786fc48 100644
--- a/controllers/remote/keyedmutex_test.go
+++ b/controllers/remote/keyedmutex_test.go
@@ -44,7 +44,7 @@ func TestKeyedMutex(t *testing.T) {
 		km.Unlock(cluster1)
 
 		// Ensure that the lock was cleaned up from the internal map.
-		g.Expect(km.locks).To(HaveLen(0))
+		g.Expect(km.locks).To(BeEmpty())
 	})
 
 	t.Run("Can lock different Clusters in parallel but each one only once", func(t *testing.T) {
@@ -77,6 +77,6 @@ func TestKeyedMutex(t *testing.T) {
 		}
 
 		// Ensure that the lock was cleaned up from the internal map.
-		g.Expect(km.locks).To(HaveLen(0))
+		g.Expect(km.locks).To(BeEmpty())
 	})
 }
diff --git a/controlplane/kubeadm/api/v1beta1/kubeadm_control_plane_webhook_test.go b/controlplane/kubeadm/api/v1beta1/kubeadm_control_plane_webhook_test.go
index ee20890ed807..30ea67922c1c 100644
--- a/controlplane/kubeadm/api/v1beta1/kubeadm_control_plane_webhook_test.go
+++ b/controlplane/kubeadm/api/v1beta1/kubeadm_control_plane_webhook_test.go
@@ -1167,9 +1167,9 @@ func TestValidateVersion(t *testing.T) {
 
 			allErrs := kcp.validateVersion(tt.oldVersion)
 			if tt.expectErr {
-				g.Expect(allErrs).ToNot(HaveLen(0))
+				g.Expect(allErrs).ToNot(BeEmpty())
 			} else {
-				g.Expect(allErrs).To(HaveLen(0))
+				g.Expect(allErrs).To(BeEmpty())
 			}
 		})
 	}
diff --git a/controlplane/kubeadm/internal/controllers/scale_test.go b/controlplane/kubeadm/internal/controllers/scale_test.go
index 0af849fd1fc1..873153bffdf5 100644
--- a/controlplane/kubeadm/internal/controllers/scale_test.go
+++ b/controlplane/kubeadm/internal/controllers/scale_test.go
@@ -210,7 +210,7 @@ func TestKubeadmControlPlaneReconciler_scaleDownControlPlane_NoError(t *testing.
 
 		controlPlaneMachines := clusterv1.MachineList{}
 		g.Expect(fakeClient.List(context.Background(), &controlPlaneMachines)).To(Succeed())
-		g.Expect(controlPlaneMachines.Items).To(HaveLen(0))
+		g.Expect(controlPlaneMachines.Items).To(BeEmpty())
 	})
 	t.Run("deletes the oldest control plane Machine even if preflight checks fails", func(t *testing.T) {
 		g := NewWithT(t)
diff --git a/controlplane/kubeadm/internal/etcd/etcd_test.go b/controlplane/kubeadm/internal/etcd/etcd_test.go
index 80ac5254199a..d5699d64f82f 100644
--- a/controlplane/kubeadm/internal/etcd/etcd_test.go
+++ b/controlplane/kubeadm/internal/etcd/etcd_test.go
@@ -54,7 +54,7 @@ func TestEtcdMembers_WithErrors(t *testing.T) {
 
 	members, err := client.Members(ctx)
 	g.Expect(err).To(HaveOccurred())
-	g.Expect(len(members)).To(Equal(0))
+	g.Expect(members).To(BeEmpty())
 
 	err = client.MoveLeader(ctx, 1)
 	g.Expect(err).To(HaveOccurred())
@@ -91,7 +91,7 @@ func TestEtcdMembers_WithSuccess(t *testing.T) {
 
 	members, err := client.Members(ctx)
 	g.Expect(err).NotTo(HaveOccurred())
-	g.Expect(len(members)).To(Equal(1))
+	g.Expect(members).To(HaveLen(1))
 
 	err = client.MoveLeader(ctx, 1)
 	g.Expect(err).NotTo(HaveOccurred())
@@ -101,6 +101,6 @@ func TestEtcdMembers_WithSuccess(t *testing.T) {
 
 	updatedMembers, err := client.UpdateMemberPeerURLs(ctx, 1234, []string{"https://4.5.6.7:2000"})
 	g.Expect(err).NotTo(HaveOccurred())
-	g.Expect(len(updatedMembers[0].PeerURLs)).To(Equal(2))
+	g.Expect(updatedMembers[0].PeerURLs).To(HaveLen(2))
 	g.Expect(updatedMembers[0].PeerURLs).To(Equal([]string{"https://1.2.3.4:2000", "https://4.5.6.7:2000"}))
 }
diff --git a/exp/addons/internal/controllers/clusterresourceset_helpers_test.go b/exp/addons/internal/controllers/clusterresourceset_helpers_test.go
index 28dc6071eb98..5cb3668bd898 100644
--- a/exp/addons/internal/controllers/clusterresourceset_helpers_test.go
+++ b/exp/addons/internal/controllers/clusterresourceset_helpers_test.go
@@ -107,7 +107,7 @@ func TestGetorCreateClusterResourceSetBinding(t *testing.T) {
 			clusterResourceSetBinding, err := r.getOrCreateClusterResourceSetBinding(context.TODO(), tt.cluster, &addonsv1.ClusterResourceSet{})
 			gs.Expect(err).NotTo(HaveOccurred())
 
-			gs.Expect(len(clusterResourceSetBinding.Spec.Bindings)).To(Equal(tt.numOfClusterResourceSets))
+			gs.Expect(clusterResourceSetBinding.Spec.Bindings).To(HaveLen(tt.numOfClusterResourceSets))
 		})
 	}
 }
diff --git a/exp/internal/controllers/machinepool_controller_noderef_test.go b/exp/internal/controllers/machinepool_controller_noderef_test.go
index c0f414c2e83c..b82b8c1fe7a8 100644
--- a/exp/internal/controllers/machinepool_controller_noderef_test.go
+++ b/exp/internal/controllers/machinepool_controller_noderef_test.go
@@ -190,7 +190,7 @@ func TestMachinePoolGetNodeReference(t *testing.T) {
 				return
 			}
 
-			g.Expect(len(result.references)).To(Equal(len(test.expected.references)), "Expected NodeRef count to be %v, got %v", len(result.references), len(test.expected.references))
+			g.Expect(result.references).To(HaveLen(len(test.expected.references)), "Expected NodeRef count to be %v, got %v", len(result.references), len(test.expected.references))
 
 			for n := range test.expected.references {
 				g.Expect(result.references[n].Name).To(Equal(test.expected.references[n].Name), "Expected NodeRef's name to be %v, got %v", result.references[n].Name, test.expected.references[n].Name)
diff --git a/exp/internal/controllers/machinepool_controller_test.go b/exp/internal/controllers/machinepool_controller_test.go
index b20a3108bf47..a771d25c3bcd 100644
--- a/exp/internal/controllers/machinepool_controller_test.go
+++ b/exp/internal/controllers/machinepool_controller_test.go
@@ -723,7 +723,7 @@ func TestMachinePoolConditions(t *testing.T) {
 				t.Helper()
 				g := NewWithT(t)
 
-				g.Expect(getter.GetConditions()).NotTo(HaveLen(0))
+				g.Expect(getter.GetConditions()).NotTo(BeEmpty())
 				for _, c := range getter.GetConditions() {
 					g.Expect(c.Status).To(Equal(corev1.ConditionTrue))
 				}
diff --git a/exp/runtime/internal/controllers/extensionconfig_controller_test.go b/exp/runtime/internal/controllers/extensionconfig_controller_test.go
index b3212c49e491..7a42e0f8578e 100644
--- a/exp/runtime/internal/controllers/extensionconfig_controller_test.go
+++ b/exp/runtime/internal/controllers/extensionconfig_controller_test.go
@@ -115,13 +115,13 @@ func TestExtensionReconciler_Reconcile(t *testing.T) {
 
 		// Expect three handlers for the extension and expect the name to be the handler name plus the extension name.
 		handlers := config.Status.Handlers
-		g.Expect(len(handlers)).To(Equal(3))
+		g.Expect(handlers).To(HaveLen(3))
 		g.Expect(handlers[0].Name).To(Equal("first.ext1"))
 		g.Expect(handlers[1].Name).To(Equal("second.ext1"))
 		g.Expect(handlers[2].Name).To(Equal("third.ext1"))
 
 		conditions := config.GetConditions()
-		g.Expect(len(conditions)).To(Equal(1))
+		g.Expect(conditions).To(HaveLen(1))
 		g.Expect(conditions[0].Status).To(Equal(corev1.ConditionTrue))
 		g.Expect(conditions[0].Type).To(Equal(runtimev1.RuntimeExtensionDiscoveredCondition))
 		_, err = registry.Get("first.ext1")
@@ -168,11 +168,11 @@ func TestExtensionReconciler_Reconcile(t *testing.T) {
 
 		// Expect two handlers for the extension and expect the name to be the handler name plus the extension name.
 		handlers := config.Status.Handlers
-		g.Expect(len(handlers)).To(Equal(2))
+		g.Expect(handlers).To(HaveLen(2))
 		g.Expect(handlers[0].Name).To(Equal("first.ext1"))
 		g.Expect(handlers[1].Name).To(Equal("third.ext1"))
 		conditions := config.GetConditions()
-		g.Expect(len(conditions)).To(Equal(1))
+		g.Expect(conditions).To(HaveLen(1))
 		g.Expect(conditions[0].Status).To(Equal(corev1.ConditionTrue))
 		g.Expect(conditions[0].Type).To(Equal(runtimev1.RuntimeExtensionDiscoveredCondition))
 
@@ -227,13 +227,13 @@ func TestExtensionReconciler_discoverExtensionConfig(t *testing.T) {
 
 		// Expect exactly one handler and expect the name to be the handler name plus the extension name.
 		handlers := discoveredExtensionConfig.Status.Handlers
-		g.Expect(len(handlers)).To(Equal(1))
+		g.Expect(handlers).To(HaveLen(1))
 		g.Expect(handlers[0].Name).To(Equal("first.ext1"))
 
 		// Expect exactly one condition and expect the condition to have type RuntimeExtensionDiscoveredCondition and
 		// Status true.
 		conditions := discoveredExtensionConfig.GetConditions()
-		g.Expect(len(conditions)).To(Equal(1))
+		g.Expect(conditions).To(HaveLen(1))
 		g.Expect(conditions[0].Status).To(Equal(corev1.ConditionTrue))
 		g.Expect(conditions[0].Type).To(Equal(runtimev1.RuntimeExtensionDiscoveredCondition))
 	})
@@ -261,12 +261,12 @@ func TestExtensionReconciler_discoverExtensionConfig(t *testing.T) {
 
 		// Expect exactly one handler and expect the name to be the handler name plus the extension name.
 		handlers := discoveredExtensionConfig.Status.Handlers
-		g.Expect(len(handlers)).To(Equal(0))
+		g.Expect(handlers).To(BeEmpty())
 
 		// Expect exactly one condition and expect the condition to have type RuntimeExtensionDiscoveredCondition and
 		// Status false.
 		conditions := discoveredExtensionConfig.GetConditions()
-		g.Expect(len(conditions)).To(Equal(1))
+		g.Expect(conditions).To(HaveLen(1))
 		g.Expect(conditions[0].Status).To(Equal(corev1.ConditionFalse))
 		g.Expect(conditions[0].Type).To(Equal(runtimev1.RuntimeExtensionDiscoveredCondition))
 	})
diff --git a/exp/runtime/internal/controllers/warmup_test.go b/exp/runtime/internal/controllers/warmup_test.go
index c832f098a98e..be8cf95a4638 100644
--- a/exp/runtime/internal/controllers/warmup_test.go
+++ b/exp/runtime/internal/controllers/warmup_test.go
@@ -86,17 +86,17 @@ func Test_warmupRunnable_Start(t *testing.T) {
 		}
 		list := &runtimev1.ExtensionConfigList{}
 		g.Expect(env.GetAPIReader().List(ctx, list)).To(Succeed())
-		g.Expect(len(list.Items)).To(Equal(3))
+		g.Expect(list.Items).To(HaveLen(3))
 		for i, config := range list.Items {
 			// Expect three handlers for each extension and expect the name to be the handler name plus the extension name.
 			handlers := config.Status.Handlers
-			g.Expect(len(handlers)).To(Equal(3))
+			g.Expect(handlers).To(HaveLen(3))
 			g.Expect(handlers[0].Name).To(Equal(fmt.Sprintf("first.ext%d", i+1)))
 			g.Expect(handlers[1].Name).To(Equal(fmt.Sprintf("second.ext%d", i+1)))
 			g.Expect(handlers[2].Name).To(Equal(fmt.Sprintf("third.ext%d", i+1)))
 
 			conditions := config.GetConditions()
-			g.Expect(len(conditions)).To(Equal(1))
+			g.Expect(conditions).To(HaveLen(1))
 			g.Expect(conditions[0].Status).To(Equal(corev1.ConditionTrue))
 			g.Expect(conditions[0].Type).To(Equal(runtimev1.RuntimeExtensionDiscoveredCondition))
 		}
@@ -153,7 +153,7 @@ func Test_warmupRunnable_Start(t *testing.T) {
 		}
 		list := &runtimev1.ExtensionConfigList{}
 		g.Expect(env.GetAPIReader().List(ctx, list)).To(Succeed())
-		g.Expect(len(list.Items)).To(Equal(3))
+		g.Expect(list.Items).To(HaveLen(3))
 
 		for i, config := range list.Items {
 			handlers := config.Status.Handlers
@@ -161,21 +161,21 @@ func Test_warmupRunnable_Start(t *testing.T) {
 
 			// Expect no handlers and a failed condition for the broken extension.
 			if config.Name == brokenExtension {
-				g.Expect(len(conditions)).To(Equal(1))
+				g.Expect(conditions).To(HaveLen(1))
 				g.Expect(conditions[0].Status).To(Equal(corev1.ConditionFalse))
 				g.Expect(conditions[0].Type).To(Equal(runtimev1.RuntimeExtensionDiscoveredCondition))
-				g.Expect(len(handlers)).To(Equal(0))
+				g.Expect(handlers).To(BeEmpty())
 
 				continue
 			}
 
 			// For other extensions expect handler name plus the extension name, and expect the condition to be True.
-			g.Expect(len(handlers)).To(Equal(3))
+			g.Expect(handlers).To(HaveLen(3))
 			g.Expect(handlers[0].Name).To(Equal(fmt.Sprintf("first.ext%d", i+1)))
 			g.Expect(handlers[1].Name).To(Equal(fmt.Sprintf("second.ext%d", i+1)))
 			g.Expect(handlers[2].Name).To(Equal(fmt.Sprintf("third.ext%d", i+1)))
 
-			g.Expect(len(conditions)).To(Equal(1))
+			g.Expect(conditions).To(HaveLen(1))
 			g.Expect(conditions[0].Status).To(Equal(corev1.ConditionTrue))
 			g.Expect(conditions[0].Type).To(Equal(runtimev1.RuntimeExtensionDiscoveredCondition))
 		}
diff --git a/internal/controllers/machine/machine_controller_phases_test.go b/internal/controllers/machine/machine_controller_phases_test.go
index 100aa2c47519..248baa2ff065 100644
--- a/internal/controllers/machine/machine_controller_phases_test.go
+++ b/internal/controllers/machine/machine_controller_phases_test.go
@@ -366,7 +366,7 @@ func TestReconcileMachinePhases(t *testing.T) {
 		res, err := r.reconcile(ctx, defaultCluster, machine)
 		g.Expect(err).NotTo(HaveOccurred())
 		g.Expect(res.Requeue).To(BeFalse())
-		g.Expect(machine.Status.Addresses).To(HaveLen(0))
+		g.Expect(machine.Status.Addresses).To(BeEmpty())
 
 		r.reconcilePhase(ctx, machine)
 		g.Expect(machine.Status.GetTypedPhase()).To(Equal(clusterv1.MachinePhaseRunning))
diff --git a/internal/controllers/machinehealthcheck/machinehealthcheck_controller_test.go b/internal/controllers/machinehealthcheck/machinehealthcheck_controller_test.go
index 067d571951aa..7c507f2897c4 100644
--- a/internal/controllers/machinehealthcheck/machinehealthcheck_controller_test.go
+++ b/internal/controllers/machinehealthcheck/machinehealthcheck_controller_test.go
@@ -2621,10 +2621,10 @@ func TestPatchTargets(t *testing.T) {
 	}
 
 	// Target with wrong patch helper will fail but the other one will be patched.
-	g.Expect(len(r.patchUnhealthyTargets(context.TODO(), logr.New(log.NullLogSink{}), []healthCheckTarget{target1, target3}, defaultCluster, mhc))).To(BeNumerically(">", 0))
+	g.Expect(r.patchUnhealthyTargets(context.TODO(), logr.New(log.NullLogSink{}), []healthCheckTarget{target1, target3}, defaultCluster, mhc)).ToNot(BeEmpty())
 	g.Expect(cl.Get(ctx, client.ObjectKey{Name: machine2.Name, Namespace: machine2.Namespace}, machine2)).NotTo(HaveOccurred())
 	g.Expect(conditions.Get(machine2, clusterv1.MachineOwnerRemediatedCondition).Status).To(Equal(corev1.ConditionFalse))
 
 	// Target with wrong patch helper will fail but the other one will be patched.
-	g.Expect(len(r.patchHealthyTargets(context.TODO(), logr.New(log.NullLogSink{}), []healthCheckTarget{target1, target3}, mhc))).To(BeNumerically(">", 0))
+	g.Expect(r.patchHealthyTargets(context.TODO(), logr.New(log.NullLogSink{}), []healthCheckTarget{target1, target3}, mhc)).ToNot(BeEmpty())
 }
diff --git a/internal/controllers/machinehealthcheck/machinehealthcheck_targets_test.go b/internal/controllers/machinehealthcheck/machinehealthcheck_targets_test.go
index e9da82ad77ff..da94b56d157e 100644
--- a/internal/controllers/machinehealthcheck/machinehealthcheck_targets_test.go
+++ b/internal/controllers/machinehealthcheck/machinehealthcheck_targets_test.go
@@ -173,7 +173,7 @@ func TestGetTargetsFromMHC(t *testing.T) {
 			targets, err := reconciler.getTargetsFromMHC(ctx, ctrl.LoggerFrom(ctx), k8sClient, cluster, testMHC)
 			gs.Expect(err).ToNot(HaveOccurred())
 
-			gs.Expect(len(targets)).To(Equal(len(tc.expectedTargets)))
+			gs.Expect(targets).To(HaveLen(len(tc.expectedTargets)))
 			for i, target := range targets {
 				expectedTarget := tc.expectedTargets[i]
 				gs.Expect(target.Machine).To(Equal(expectedTarget.Machine))
diff --git a/internal/controllers/topology/cluster/desired_state_test.go b/internal/controllers/topology/cluster/desired_state_test.go
index 8ff7bf21c836..8b24f61f92e0 100644
--- a/internal/controllers/topology/cluster/desired_state_test.go
+++ b/internal/controllers/topology/cluster/desired_state_test.go
@@ -103,7 +103,7 @@ func TestComputeInfrastructureCluster(t *testing.T) {
 		})
 
 		// Ensure no ownership is added to generated InfrastructureCluster.
-		g.Expect(obj.GetOwnerReferences()).To(HaveLen(0))
+		g.Expect(obj.GetOwnerReferences()).To(BeEmpty())
 	})
 	t.Run("If there is already a reference to the infrastructureCluster, it preserves the reference name", func(t *testing.T) {
 		g := NewWithT(t)
@@ -329,7 +329,7 @@ func TestComputeControlPlane(t *testing.T) {
 		assertNestedFieldUnset(g, obj, contract.ControlPlane().MachineTemplate().InfrastructureRef().Path()...)
 
 		// Ensure no ownership is added to generated ControlPlane.
-		g.Expect(obj.GetOwnerReferences()).To(HaveLen(0))
+		g.Expect(obj.GetOwnerReferences()).To(BeEmpty())
 	})
 	t.Run("Generates the ControlPlane from the template using ClusterClass defaults", func(t *testing.T) {
 		g := NewWithT(t)
diff --git a/internal/controllers/topology/cluster/reconcile_state_test.go b/internal/controllers/topology/cluster/reconcile_state_test.go
index 8036e46abe59..3278ad4c8884 100644
--- a/internal/controllers/topology/cluster/reconcile_state_test.go
+++ b/internal/controllers/topology/cluster/reconcile_state_test.go
@@ -2568,7 +2568,7 @@ func TestReconcileMachineDeploymentMachineHealthCheck(t *testing.T) {
 			g.Expect(env.GetAPIReader().List(ctx, &gotMachineHealthCheckList, &client.ListOptions{Namespace: namespace.GetName()})).To(Succeed())
 			g.Expect(gotMachineHealthCheckList.Items).To(HaveLen(len(tt.want)))
 
-			g.Expect(len(tt.want)).To(Equal(len(gotMachineHealthCheckList.Items)))
+			g.Expect(tt.want).To(HaveLen(len(gotMachineHealthCheckList.Items)))
 
 			for _, wantMHC := range tt.want {
 				for _, gotMHC := range gotMachineHealthCheckList.Items {
diff --git a/internal/controllers/topology/machineset/util_test.go b/internal/controllers/topology/machineset/util_test.go
index 73d71b1b9312..4a923026c8c4 100644
--- a/internal/controllers/topology/machineset/util_test.go
+++ b/internal/controllers/topology/machineset/util_test.go
@@ -88,7 +88,7 @@ func TestCalculateTemplatesInUse(t *testing.T) {
 
 		actual, err := CalculateTemplatesInUse(mdInDeleting, []*clusterv1.MachineSet{msInDeleting})
 		g.Expect(err).ToNot(HaveOccurred())
-		g.Expect(actual).To(HaveLen(0))
+		g.Expect(actual).To(BeEmpty())
 
 		g.Expect(actual).ToNot(HaveKey(mustTemplateRefID(&mdInDeleting.Spec.Template.Spec.InfrastructureRef)))
 
diff --git a/internal/runtime/registry/registry_test.go b/internal/runtime/registry/registry_test.go
index 2e679c83b561..c756957610fe 100644
--- a/internal/runtime/registry/registry_test.go
+++ b/internal/runtime/registry/registry_test.go
@@ -191,7 +191,7 @@ func TestRegistry(t *testing.T) {
 
 	registrations, err = e.List(runtimecatalog.GroupHook{Group: "hook.runtime.cluster.x-k8s.io", Hook: "BeforeClusterUpgrade"})
 	g.Expect(err).ToNot(HaveOccurred())
-	g.Expect(registrations).To(HaveLen(0))
+	g.Expect(registrations).To(BeEmpty())
 
 	registrations, err = e.List(runtimecatalog.GroupHook{Group: "hook.runtime.cluster.x-k8s.io", Hook: "AfterClusterUpgrade"})
 	g.Expect(err).ToNot(HaveOccurred())
diff --git a/test/e2e/clusterclass_changes.go b/test/e2e/clusterclass_changes.go
index 662376b2a899..1c29a60176e1 100644
--- a/test/e2e/clusterclass_changes.go
+++ b/test/e2e/clusterclass_changes.go
@@ -484,7 +484,7 @@ func deleteMachineDeploymentTopologyAndWait(ctx context.Context, input deleteMac
 	Expect(ctx).NotTo(BeNil(), "ctx is required for deleteMachineDeploymentTopologyAndWait")
 	Expect(input.ClusterProxy).ToNot(BeNil(), "Invalid argument. input.ClusterProxy can't be nil when calling deleteMachineDeploymentTopologyAndWait")
 	Expect(input.Cluster).ToNot(BeNil(), "Invalid argument. input.Cluster can't be nil when calling deleteMachineDeploymentTopologyAndWait")
-	Expect(len(input.Cluster.Spec.Topology.Workers.MachineDeployments)).To(BeNumerically(">", 0),
+	Expect(input.Cluster.Spec.Topology.Workers.MachineDeployments).ToNot(BeEmpty(),
 		"Invalid Cluster. deleteMachineDeploymentTopologyAndWait requires at least one MachineDeploymentTopology to be defined in the Cluster topology")
 
 	log.Logf("Removing MachineDeploymentTopology from the Cluster Topology.")
diff --git a/test/infrastructure/docker/internal/provisioning/cloudinit/unknown_test.go b/test/infrastructure/docker/internal/provisioning/cloudinit/unknown_test.go
index 503f7b1ff7ae..bafc255a3fbb 100644
--- a/test/infrastructure/docker/internal/provisioning/cloudinit/unknown_test.go
+++ b/test/infrastructure/docker/internal/provisioning/cloudinit/unknown_test.go
@@ -30,7 +30,7 @@ func TestUnknown_Run(t *testing.T) {
 	}
 	lines, err := u.Commands()
 	g.Expect(err).NotTo(HaveOccurred())
-	g.Expect(lines).To(HaveLen(0))
+	g.Expect(lines).To(BeEmpty())
 }
 
 func TestUnknown_Unmarshal(t *testing.T) {
diff --git a/util/conversion/conversion_test.go b/util/conversion/conversion_test.go
index b6bcdcfe3e2d..daa472967506 100644
--- a/util/conversion/conversion_test.go
+++ b/util/conversion/conversion_test.go
@@ -85,7 +85,7 @@ func TestMarshalData(t *testing.T) {
 		})
 
 		g.Expect(MarshalData(src, dst)).To(Succeed())
-		g.Expect(len(dst.GetAnnotations())).To(Equal(2))
+		g.Expect(dst.GetAnnotations()).To(HaveLen(2))
 	})
 }
 
@@ -125,7 +125,7 @@ func TestUnmarshalData(t *testing.T) {
 		g.Expect(err).To(BeNil())
 		g.Expect(ok).To(BeTrue())
 
-		g.Expect(len(dst.GetLabels())).To(Equal(1))
+		g.Expect(dst.GetLabels()).To(HaveLen(1))
 		g.Expect(dst.GetName()).To(Equal("test-1"))
 		g.Expect(dst.GetLabels()).To(HaveKeyWithValue("label1", ""))
 		g.Expect(dst.GetAnnotations()).To(BeEmpty())
@@ -151,6 +151,6 @@ func TestUnmarshalData(t *testing.T) {
 		g.Expect(ok).To(BeTrue())
 
 		g.Expect(src.GetAnnotations()).ToNot(HaveKey(DataAnnotation))
-		g.Expect(len(src.GetAnnotations())).To(Equal(1))
+		g.Expect(src.GetAnnotations()).To(HaveLen(1))
 	})
 }
diff --git a/util/resource/resource_test.go b/util/resource/resource_test.go
index 5afb3b6ec9e1..bf392035a36d 100644
--- a/util/resource/resource_test.go
+++ b/util/resource/resource_test.go
@@ -37,7 +37,7 @@ func TestSortForCreate(t *testing.T) {
 
 	resources := []unstructured.Unstructured{ep, cm, ns}
 	sorted := SortForCreate(resources)
-	g.Expect(len(sorted)).To(Equal(3))
+	g.Expect(sorted).To(HaveLen(3))
 	g.Expect(sorted[0].GetKind()).To(BeIdenticalTo("Namespace"))
 	g.Expect(sorted[1].GetKind()).To(BeIdenticalTo("ConfigMap"))
 }
diff --git a/util/yaml/yaml_test.go b/util/yaml/yaml_test.go
index 5436c5130b1f..7c110ba1dee4 100644
--- a/util/yaml/yaml_test.go
+++ b/util/yaml/yaml_test.go
@@ -223,7 +223,7 @@ func TestParseClusterYaml(t *testing.T) {
 			}
 
 			g.Expect(err).NotTo(HaveOccurred())
-			g.Expect(c.Clusters).NotTo(HaveLen(0))
+			g.Expect(c.Clusters).NotTo(BeEmpty())
 			g.Expect(c.Clusters[0].Name).To(Equal(testcase.expectedName))
 		})
 	}