diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 4e92603..bba4b14 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -317,7 +317,7 @@ assert.ErrorContains(t, err, "user") ❌
 ```
 
 **Autofix**: false. <br>
-**Enabled by default**: Probable false, depends on implementation performance. <br>
+**Enabled by default**: Probably false, depends on implementation performance. <br>
 **Reason**: Code simplification, elimination of possible bugs.
 
 ---
diff --git a/analyzer/testdata/src/checkers-default/nil-compare/nil_compare_test.go b/analyzer/testdata/src/checkers-default/nil-compare/nil_compare_test.go
index 7a8b86d..57cbf6c 100644
--- a/analyzer/testdata/src/checkers-default/nil-compare/nil_compare_test.go
+++ b/analyzer/testdata/src/checkers-default/nil-compare/nil_compare_test.go
@@ -6,7 +6,6 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func TestNilCompareChecker(t *testing.T) {
@@ -15,201 +14,107 @@ func TestNilCompareChecker(t *testing.T) {
 
 	// Invalid.
 	{
-		assert.Equal(t, value, nil)                                                  // want "nil-compare: use assert\\.Nil"
-		assert.Equalf(t, value, nil, "msg with args %d %s", 42, "42")                // want "nil-compare: use assert\\.Nilf"
-		require.Equal(t, value, nil)                                                 // want "nil-compare: use require\\.Nil"
-		require.Equalf(t, value, nil, "msg with args %d %s", 42, "42")               // want "nil-compare: use require\\.Nilf"
-		assert.Equal(t, nil, value)                                                  // want "nil-compare: use assert\\.Nil"
-		assert.Equalf(t, nil, value, "msg with args %d %s", 42, "42")                // want "nil-compare: use assert\\.Nilf"
-		require.Equal(t, nil, value)                                                 // want "nil-compare: use require\\.Nil"
-		require.Equalf(t, nil, value, "msg with args %d %s", 42, "42")               // want "nil-compare: use require\\.Nilf"
-		assert.Equal(t, Row["col"], nil)                                             // want "nil-compare: use assert\\.Nil"
-		assert.Equalf(t, Row["col"], nil, "msg with args %d %s", 42, "42")           // want "nil-compare: use assert\\.Nilf"
-		require.Equal(t, Row["col"], nil)                                            // want "nil-compare: use require\\.Nil"
-		require.Equalf(t, Row["col"], nil, "msg with args %d %s", 42, "42")          // want "nil-compare: use require\\.Nilf"
-		assert.Equal(t, nil, Row["col"])                                             // want "nil-compare: use assert\\.Nil"
-		assert.Equalf(t, nil, Row["col"], "msg with args %d %s", 42, "42")           // want "nil-compare: use assert\\.Nilf"
-		require.Equal(t, nil, Row["col"])                                            // want "nil-compare: use require\\.Nil"
-		require.Equalf(t, nil, Row["col"], "msg with args %d %s", 42, "42")          // want "nil-compare: use require\\.Nilf"
-		assert.EqualValues(t, value, nil)                                            // want "nil-compare: use assert\\.Nil"
-		assert.EqualValuesf(t, value, nil, "msg with args %d %s", 42, "42")          // want "nil-compare: use assert\\.Nilf"
-		require.EqualValues(t, value, nil)                                           // want "nil-compare: use require\\.Nil"
-		require.EqualValuesf(t, value, nil, "msg with args %d %s", 42, "42")         // want "nil-compare: use require\\.Nilf"
-		assert.EqualValues(t, nil, value)                                            // want "nil-compare: use assert\\.Nil"
-		assert.EqualValuesf(t, nil, value, "msg with args %d %s", 42, "42")          // want "nil-compare: use assert\\.Nilf"
-		require.EqualValues(t, nil, value)                                           // want "nil-compare: use require\\.Nil"
-		require.EqualValuesf(t, nil, value, "msg with args %d %s", 42, "42")         // want "nil-compare: use require\\.Nilf"
-		assert.EqualValues(t, Row["col"], nil)                                       // want "nil-compare: use assert\\.Nil"
-		assert.EqualValuesf(t, Row["col"], nil, "msg with args %d %s", 42, "42")     // want "nil-compare: use assert\\.Nilf"
-		require.EqualValues(t, Row["col"], nil)                                      // want "nil-compare: use require\\.Nil"
-		require.EqualValuesf(t, Row["col"], nil, "msg with args %d %s", 42, "42")    // want "nil-compare: use require\\.Nilf"
-		assert.EqualValues(t, nil, Row["col"])                                       // want "nil-compare: use assert\\.Nil"
-		assert.EqualValuesf(t, nil, Row["col"], "msg with args %d %s", 42, "42")     // want "nil-compare: use assert\\.Nilf"
-		require.EqualValues(t, nil, Row["col"])                                      // want "nil-compare: use require\\.Nil"
-		require.EqualValuesf(t, nil, Row["col"], "msg with args %d %s", 42, "42")    // want "nil-compare: use require\\.Nilf"
-		assert.Exactly(t, value, nil)                                                // want "nil-compare: use assert\\.Nil"
-		assert.Exactlyf(t, value, nil, "msg with args %d %s", 42, "42")              // want "nil-compare: use assert\\.Nilf"
-		require.Exactly(t, value, nil)                                               // want "nil-compare: use require\\.Nil"
-		require.Exactlyf(t, value, nil, "msg with args %d %s", 42, "42")             // want "nil-compare: use require\\.Nilf"
-		assert.Exactly(t, nil, value)                                                // want "nil-compare: use assert\\.Nil"
-		assert.Exactlyf(t, nil, value, "msg with args %d %s", 42, "42")              // want "nil-compare: use assert\\.Nilf"
-		require.Exactly(t, nil, value)                                               // want "nil-compare: use require\\.Nil"
-		require.Exactlyf(t, nil, value, "msg with args %d %s", 42, "42")             // want "nil-compare: use require\\.Nilf"
-		assert.Exactly(t, Row["col"], nil)                                           // want "nil-compare: use assert\\.Nil"
-		assert.Exactlyf(t, Row["col"], nil, "msg with args %d %s", 42, "42")         // want "nil-compare: use assert\\.Nilf"
-		require.Exactly(t, Row["col"], nil)                                          // want "nil-compare: use require\\.Nil"
-		require.Exactlyf(t, Row["col"], nil, "msg with args %d %s", 42, "42")        // want "nil-compare: use require\\.Nilf"
-		assert.Exactly(t, nil, Row["col"])                                           // want "nil-compare: use assert\\.Nil"
-		assert.Exactlyf(t, nil, Row["col"], "msg with args %d %s", 42, "42")         // want "nil-compare: use assert\\.Nilf"
-		require.Exactly(t, nil, Row["col"])                                          // want "nil-compare: use require\\.Nil"
-		require.Exactlyf(t, nil, Row["col"], "msg with args %d %s", 42, "42")        // want "nil-compare: use require\\.Nilf"
-		assert.NotEqual(t, value, nil)                                               // want "nil-compare: use assert\\.NotNil"
-		assert.NotEqualf(t, value, nil, "msg with args %d %s", 42, "42")             // want "nil-compare: use assert\\.NotNilf"
-		require.NotEqual(t, value, nil)                                              // want "nil-compare: use require\\.NotNil"
-		require.NotEqualf(t, value, nil, "msg with args %d %s", 42, "42")            // want "nil-compare: use require\\.NotNilf"
-		assert.NotEqual(t, nil, value)                                               // want "nil-compare: use assert\\.NotNil"
-		assert.NotEqualf(t, nil, value, "msg with args %d %s", 42, "42")             // want "nil-compare: use assert\\.NotNilf"
-		require.NotEqual(t, nil, value)                                              // want "nil-compare: use require\\.NotNil"
-		require.NotEqualf(t, nil, value, "msg with args %d %s", 42, "42")            // want "nil-compare: use require\\.NotNilf"
-		assert.NotEqual(t, Row["col"], nil)                                          // want "nil-compare: use assert\\.NotNil"
-		assert.NotEqualf(t, Row["col"], nil, "msg with args %d %s", 42, "42")        // want "nil-compare: use assert\\.NotNilf"
-		require.NotEqual(t, Row["col"], nil)                                         // want "nil-compare: use require\\.NotNil"
-		require.NotEqualf(t, Row["col"], nil, "msg with args %d %s", 42, "42")       // want "nil-compare: use require\\.NotNilf"
-		assert.NotEqual(t, nil, Row["col"])                                          // want "nil-compare: use assert\\.NotNil"
-		assert.NotEqualf(t, nil, Row["col"], "msg with args %d %s", 42, "42")        // want "nil-compare: use assert\\.NotNilf"
-		require.NotEqual(t, nil, Row["col"])                                         // want "nil-compare: use require\\.NotNil"
-		require.NotEqualf(t, nil, Row["col"], "msg with args %d %s", 42, "42")       // want "nil-compare: use require\\.NotNilf"
-		assert.NotEqualValues(t, value, nil)                                         // want "nil-compare: use assert\\.NotNil"
-		assert.NotEqualValuesf(t, value, nil, "msg with args %d %s", 42, "42")       // want "nil-compare: use assert\\.NotNilf"
-		require.NotEqualValues(t, value, nil)                                        // want "nil-compare: use require\\.NotNil"
-		require.NotEqualValuesf(t, value, nil, "msg with args %d %s", 42, "42")      // want "nil-compare: use require\\.NotNilf"
-		assert.NotEqualValues(t, nil, value)                                         // want "nil-compare: use assert\\.NotNil"
-		assert.NotEqualValuesf(t, nil, value, "msg with args %d %s", 42, "42")       // want "nil-compare: use assert\\.NotNilf"
-		require.NotEqualValues(t, nil, value)                                        // want "nil-compare: use require\\.NotNil"
-		require.NotEqualValuesf(t, nil, value, "msg with args %d %s", 42, "42")      // want "nil-compare: use require\\.NotNilf"
-		assert.NotEqualValues(t, Row["col"], nil)                                    // want "nil-compare: use assert\\.NotNil"
-		assert.NotEqualValuesf(t, Row["col"], nil, "msg with args %d %s", 42, "42")  // want "nil-compare: use assert\\.NotNilf"
-		require.NotEqualValues(t, Row["col"], nil)                                   // want "nil-compare: use require\\.NotNil"
-		require.NotEqualValuesf(t, Row["col"], nil, "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.NotNilf"
-		assert.NotEqualValues(t, nil, Row["col"])                                    // want "nil-compare: use assert\\.NotNil"
-		assert.NotEqualValuesf(t, nil, Row["col"], "msg with args %d %s", 42, "42")  // want "nil-compare: use assert\\.NotNilf"
-		require.NotEqualValues(t, nil, Row["col"])                                   // want "nil-compare: use require\\.NotNil"
-		require.NotEqualValuesf(t, nil, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.NotNilf"
+		assert.Equal(t, value, nil)                                                 // want "nil-compare: use assert\\.Nil"
+		assert.Equalf(t, value, nil, "msg with args %d %s", 42, "42")               // want "nil-compare: use assert\\.Nilf"
+		assert.Equal(t, nil, value)                                                 // want "nil-compare: use assert\\.Nil"
+		assert.Equalf(t, nil, value, "msg with args %d %s", 42, "42")               // want "nil-compare: use assert\\.Nilf"
+		assert.Equal(t, Row["col"], nil)                                            // want "nil-compare: use assert\\.Nil"
+		assert.Equalf(t, Row["col"], nil, "msg with args %d %s", 42, "42")          // want "nil-compare: use assert\\.Nilf"
+		assert.Equal(t, nil, Row["col"])                                            // want "nil-compare: use assert\\.Nil"
+		assert.Equalf(t, nil, Row["col"], "msg with args %d %s", 42, "42")          // want "nil-compare: use assert\\.Nilf"
+		assert.EqualValues(t, value, nil)                                           // want "nil-compare: use assert\\.Nil"
+		assert.EqualValuesf(t, value, nil, "msg with args %d %s", 42, "42")         // want "nil-compare: use assert\\.Nilf"
+		assert.EqualValues(t, nil, value)                                           // want "nil-compare: use assert\\.Nil"
+		assert.EqualValuesf(t, nil, value, "msg with args %d %s", 42, "42")         // want "nil-compare: use assert\\.Nilf"
+		assert.EqualValues(t, Row["col"], nil)                                      // want "nil-compare: use assert\\.Nil"
+		assert.EqualValuesf(t, Row["col"], nil, "msg with args %d %s", 42, "42")    // want "nil-compare: use assert\\.Nilf"
+		assert.EqualValues(t, nil, Row["col"])                                      // want "nil-compare: use assert\\.Nil"
+		assert.EqualValuesf(t, nil, Row["col"], "msg with args %d %s", 42, "42")    // want "nil-compare: use assert\\.Nilf"
+		assert.Exactly(t, value, nil)                                               // want "nil-compare: use assert\\.Nil"
+		assert.Exactlyf(t, value, nil, "msg with args %d %s", 42, "42")             // want "nil-compare: use assert\\.Nilf"
+		assert.Exactly(t, nil, value)                                               // want "nil-compare: use assert\\.Nil"
+		assert.Exactlyf(t, nil, value, "msg with args %d %s", 42, "42")             // want "nil-compare: use assert\\.Nilf"
+		assert.Exactly(t, Row["col"], nil)                                          // want "nil-compare: use assert\\.Nil"
+		assert.Exactlyf(t, Row["col"], nil, "msg with args %d %s", 42, "42")        // want "nil-compare: use assert\\.Nilf"
+		assert.Exactly(t, nil, Row["col"])                                          // want "nil-compare: use assert\\.Nil"
+		assert.Exactlyf(t, nil, Row["col"], "msg with args %d %s", 42, "42")        // want "nil-compare: use assert\\.Nilf"
+		assert.NotEqual(t, value, nil)                                              // want "nil-compare: use assert\\.NotNil"
+		assert.NotEqualf(t, value, nil, "msg with args %d %s", 42, "42")            // want "nil-compare: use assert\\.NotNilf"
+		assert.NotEqual(t, nil, value)                                              // want "nil-compare: use assert\\.NotNil"
+		assert.NotEqualf(t, nil, value, "msg with args %d %s", 42, "42")            // want "nil-compare: use assert\\.NotNilf"
+		assert.NotEqual(t, Row["col"], nil)                                         // want "nil-compare: use assert\\.NotNil"
+		assert.NotEqualf(t, Row["col"], nil, "msg with args %d %s", 42, "42")       // want "nil-compare: use assert\\.NotNilf"
+		assert.NotEqual(t, nil, Row["col"])                                         // want "nil-compare: use assert\\.NotNil"
+		assert.NotEqualf(t, nil, Row["col"], "msg with args %d %s", 42, "42")       // want "nil-compare: use assert\\.NotNilf"
+		assert.NotEqualValues(t, value, nil)                                        // want "nil-compare: use assert\\.NotNil"
+		assert.NotEqualValuesf(t, value, nil, "msg with args %d %s", 42, "42")      // want "nil-compare: use assert\\.NotNilf"
+		assert.NotEqualValues(t, nil, value)                                        // want "nil-compare: use assert\\.NotNil"
+		assert.NotEqualValuesf(t, nil, value, "msg with args %d %s", 42, "42")      // want "nil-compare: use assert\\.NotNilf"
+		assert.NotEqualValues(t, Row["col"], nil)                                   // want "nil-compare: use assert\\.NotNil"
+		assert.NotEqualValuesf(t, Row["col"], nil, "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
+		assert.NotEqualValues(t, nil, Row["col"])                                   // want "nil-compare: use assert\\.NotNil"
+		assert.NotEqualValuesf(t, nil, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
 	}
 
 	// Valid.
 	{
 		assert.Nil(t, value)
 		assert.Nilf(t, value, "msg with args %d %s", 42, "42")
-		require.Nil(t, value)
-		require.Nilf(t, value, "msg with args %d %s", 42, "42")
 		assert.NotNil(t, value)
 		assert.NotNilf(t, value, "msg with args %d %s", 42, "42")
-		require.NotNil(t, value)
-		require.NotNilf(t, value, "msg with args %d %s", 42, "42")
 	}
 
 	// Ignored.
 	{
 		assert.Equal(t, value, value)
 		assert.Equalf(t, value, value, "msg with args %d %s", 42, "42")
-		require.Equal(t, value, value)
-		require.Equalf(t, value, value, "msg with args %d %s", 42, "42")
 		assert.Equal(t, nil, nil)
 		assert.Equalf(t, nil, nil, "msg with args %d %s", 42, "42")
-		require.Equal(t, nil, nil)
-		require.Equalf(t, nil, nil, "msg with args %d %s", 42, "42")
 		assert.Equal(t, Row["col"], "foo")
 		assert.Equalf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
-		require.Equal(t, Row["col"], "foo")
-		require.Equalf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
 		assert.Equal(t, "foo", Row["col"])
 		assert.Equalf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
-		require.Equal(t, "foo", Row["col"])
-		require.Equalf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
 		assert.Equal(t, Row["col"], Row["col"])
 		assert.Equalf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
-		require.Equal(t, Row["col"], Row["col"])
-		require.Equalf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
 		assert.EqualValues(t, value, value)
 		assert.EqualValuesf(t, value, value, "msg with args %d %s", 42, "42")
-		require.EqualValues(t, value, value)
-		require.EqualValuesf(t, value, value, "msg with args %d %s", 42, "42")
 		assert.EqualValues(t, nil, nil)
 		assert.EqualValuesf(t, nil, nil, "msg with args %d %s", 42, "42")
-		require.EqualValues(t, nil, nil)
-		require.EqualValuesf(t, nil, nil, "msg with args %d %s", 42, "42")
 		assert.EqualValues(t, Row["col"], "foo")
 		assert.EqualValuesf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
-		require.EqualValues(t, Row["col"], "foo")
-		require.EqualValuesf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
 		assert.EqualValues(t, "foo", Row["col"])
 		assert.EqualValuesf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
-		require.EqualValues(t, "foo", Row["col"])
-		require.EqualValuesf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
 		assert.EqualValues(t, Row["col"], Row["col"])
 		assert.EqualValuesf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
-		require.EqualValues(t, Row["col"], Row["col"])
-		require.EqualValuesf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
 		assert.Exactly(t, value, value)
 		assert.Exactlyf(t, value, value, "msg with args %d %s", 42, "42")
-		require.Exactly(t, value, value)
-		require.Exactlyf(t, value, value, "msg with args %d %s", 42, "42")
 		assert.Exactly(t, nil, nil)
 		assert.Exactlyf(t, nil, nil, "msg with args %d %s", 42, "42")
-		require.Exactly(t, nil, nil)
-		require.Exactlyf(t, nil, nil, "msg with args %d %s", 42, "42")
 		assert.Exactly(t, Row["col"], "foo")
 		assert.Exactlyf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
-		require.Exactly(t, Row["col"], "foo")
-		require.Exactlyf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
 		assert.Exactly(t, "foo", Row["col"])
 		assert.Exactlyf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
-		require.Exactly(t, "foo", Row["col"])
-		require.Exactlyf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
 		assert.Exactly(t, Row["col"], Row["col"])
 		assert.Exactlyf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
-		require.Exactly(t, Row["col"], Row["col"])
-		require.Exactlyf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
 		assert.NotEqual(t, value, value)
 		assert.NotEqualf(t, value, value, "msg with args %d %s", 42, "42")
-		require.NotEqual(t, value, value)
-		require.NotEqualf(t, value, value, "msg with args %d %s", 42, "42")
 		assert.NotEqual(t, nil, nil)
 		assert.NotEqualf(t, nil, nil, "msg with args %d %s", 42, "42")
-		require.NotEqual(t, nil, nil)
-		require.NotEqualf(t, nil, nil, "msg with args %d %s", 42, "42")
 		assert.NotEqual(t, Row["col"], "foo")
 		assert.NotEqualf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
-		require.NotEqual(t, Row["col"], "foo")
-		require.NotEqualf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
 		assert.NotEqual(t, "foo", Row["col"])
 		assert.NotEqualf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
-		require.NotEqual(t, "foo", Row["col"])
-		require.NotEqualf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
 		assert.NotEqual(t, Row["col"], Row["col"])
 		assert.NotEqualf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
-		require.NotEqual(t, Row["col"], Row["col"])
-		require.NotEqualf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
 		assert.NotEqualValues(t, value, value)
 		assert.NotEqualValuesf(t, value, value, "msg with args %d %s", 42, "42")
-		require.NotEqualValues(t, value, value)
-		require.NotEqualValuesf(t, value, value, "msg with args %d %s", 42, "42")
 		assert.NotEqualValues(t, nil, nil)
 		assert.NotEqualValuesf(t, nil, nil, "msg with args %d %s", 42, "42")
-		require.NotEqualValues(t, nil, nil)
-		require.NotEqualValuesf(t, nil, nil, "msg with args %d %s", 42, "42")
 		assert.NotEqualValues(t, Row["col"], "foo")
 		assert.NotEqualValuesf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
-		require.NotEqualValues(t, Row["col"], "foo")
-		require.NotEqualValuesf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
 		assert.NotEqualValues(t, "foo", Row["col"])
 		assert.NotEqualValuesf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
-		require.NotEqualValues(t, "foo", Row["col"])
-		require.NotEqualValuesf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
 		assert.NotEqualValues(t, Row["col"], Row["col"])
 		assert.NotEqualValuesf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
-		require.NotEqualValues(t, Row["col"], Row["col"])
-		require.NotEqualValuesf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
 	}
 }
diff --git a/analyzer/testdata/src/checkers-default/nil-compare/nil_compare_test.go.golden b/analyzer/testdata/src/checkers-default/nil-compare/nil_compare_test.go.golden
index e7d6249..77ebf0e 100644
--- a/analyzer/testdata/src/checkers-default/nil-compare/nil_compare_test.go.golden
+++ b/analyzer/testdata/src/checkers-default/nil-compare/nil_compare_test.go.golden
@@ -6,7 +6,6 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func TestNilCompareChecker(t *testing.T) {
@@ -15,201 +14,107 @@ func TestNilCompareChecker(t *testing.T) {
 
 	// Invalid.
 	{
-		assert.Nil(t, value)                                            // want "nil-compare: use assert\\.Nil"
-		assert.Nilf(t, value, "msg with args %d %s", 42, "42")          // want "nil-compare: use assert\\.Nilf"
-		require.Nil(t, value)                                           // want "nil-compare: use require\\.Nil"
-		require.Nilf(t, value, "msg with args %d %s", 42, "42")         // want "nil-compare: use require\\.Nilf"
-		assert.Nil(t, value)                                            // want "nil-compare: use assert\\.Nil"
-		assert.Nilf(t, value, "msg with args %d %s", 42, "42")          // want "nil-compare: use assert\\.Nilf"
-		require.Nil(t, value)                                           // want "nil-compare: use require\\.Nil"
-		require.Nilf(t, value, "msg with args %d %s", 42, "42")         // want "nil-compare: use require\\.Nilf"
-		assert.Nil(t, Row["col"])                                       // want "nil-compare: use assert\\.Nil"
-		assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42")     // want "nil-compare: use assert\\.Nilf"
-		require.Nil(t, Row["col"])                                      // want "nil-compare: use require\\.Nil"
-		require.Nilf(t, Row["col"], "msg with args %d %s", 42, "42")    // want "nil-compare: use require\\.Nilf"
-		assert.Nil(t, Row["col"])                                       // want "nil-compare: use assert\\.Nil"
-		assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42")     // want "nil-compare: use assert\\.Nilf"
-		require.Nil(t, Row["col"])                                      // want "nil-compare: use require\\.Nil"
-		require.Nilf(t, Row["col"], "msg with args %d %s", 42, "42")    // want "nil-compare: use require\\.Nilf"
-		assert.Nil(t, value)                                            // want "nil-compare: use assert\\.Nil"
-		assert.Nilf(t, value, "msg with args %d %s", 42, "42")          // want "nil-compare: use assert\\.Nilf"
-		require.Nil(t, value)                                           // want "nil-compare: use require\\.Nil"
-		require.Nilf(t, value, "msg with args %d %s", 42, "42")         // want "nil-compare: use require\\.Nilf"
-		assert.Nil(t, value)                                            // want "nil-compare: use assert\\.Nil"
-		assert.Nilf(t, value, "msg with args %d %s", 42, "42")          // want "nil-compare: use assert\\.Nilf"
-		require.Nil(t, value)                                           // want "nil-compare: use require\\.Nil"
-		require.Nilf(t, value, "msg with args %d %s", 42, "42")         // want "nil-compare: use require\\.Nilf"
-		assert.Nil(t, Row["col"])                                       // want "nil-compare: use assert\\.Nil"
-		assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42")     // want "nil-compare: use assert\\.Nilf"
-		require.Nil(t, Row["col"])                                      // want "nil-compare: use require\\.Nil"
-		require.Nilf(t, Row["col"], "msg with args %d %s", 42, "42")    // want "nil-compare: use require\\.Nilf"
-		assert.Nil(t, Row["col"])                                       // want "nil-compare: use assert\\.Nil"
-		assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42")     // want "nil-compare: use assert\\.Nilf"
-		require.Nil(t, Row["col"])                                      // want "nil-compare: use require\\.Nil"
-		require.Nilf(t, Row["col"], "msg with args %d %s", 42, "42")    // want "nil-compare: use require\\.Nilf"
-		assert.Nil(t, value)                                            // want "nil-compare: use assert\\.Nil"
-		assert.Nilf(t, value, "msg with args %d %s", 42, "42")          // want "nil-compare: use assert\\.Nilf"
-		require.Nil(t, value)                                           // want "nil-compare: use require\\.Nil"
-		require.Nilf(t, value, "msg with args %d %s", 42, "42")         // want "nil-compare: use require\\.Nilf"
-		assert.Nil(t, value)                                            // want "nil-compare: use assert\\.Nil"
-		assert.Nilf(t, value, "msg with args %d %s", 42, "42")          // want "nil-compare: use assert\\.Nilf"
-		require.Nil(t, value)                                           // want "nil-compare: use require\\.Nil"
-		require.Nilf(t, value, "msg with args %d %s", 42, "42")         // want "nil-compare: use require\\.Nilf"
-		assert.Nil(t, Row["col"])                                       // want "nil-compare: use assert\\.Nil"
-		assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42")     // want "nil-compare: use assert\\.Nilf"
-		require.Nil(t, Row["col"])                                      // want "nil-compare: use require\\.Nil"
-		require.Nilf(t, Row["col"], "msg with args %d %s", 42, "42")    // want "nil-compare: use require\\.Nilf"
-		assert.Nil(t, Row["col"])                                       // want "nil-compare: use assert\\.Nil"
-		assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42")     // want "nil-compare: use assert\\.Nilf"
-		require.Nil(t, Row["col"])                                      // want "nil-compare: use require\\.Nil"
-		require.Nilf(t, Row["col"], "msg with args %d %s", 42, "42")    // want "nil-compare: use require\\.Nilf"
-		assert.NotNil(t, value)                                         // want "nil-compare: use assert\\.NotNil"
-		assert.NotNilf(t, value, "msg with args %d %s", 42, "42")       // want "nil-compare: use assert\\.NotNilf"
-		require.NotNil(t, value)                                        // want "nil-compare: use require\\.NotNil"
-		require.NotNilf(t, value, "msg with args %d %s", 42, "42")      // want "nil-compare: use require\\.NotNilf"
-		assert.NotNil(t, value)                                         // want "nil-compare: use assert\\.NotNil"
-		assert.NotNilf(t, value, "msg with args %d %s", 42, "42")       // want "nil-compare: use assert\\.NotNilf"
-		require.NotNil(t, value)                                        // want "nil-compare: use require\\.NotNil"
-		require.NotNilf(t, value, "msg with args %d %s", 42, "42")      // want "nil-compare: use require\\.NotNilf"
-		assert.NotNil(t, Row["col"])                                    // want "nil-compare: use assert\\.NotNil"
-		assert.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42")  // want "nil-compare: use assert\\.NotNilf"
-		require.NotNil(t, Row["col"])                                   // want "nil-compare: use require\\.NotNil"
-		require.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.NotNilf"
-		assert.NotNil(t, Row["col"])                                    // want "nil-compare: use assert\\.NotNil"
-		assert.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42")  // want "nil-compare: use assert\\.NotNilf"
-		require.NotNil(t, Row["col"])                                   // want "nil-compare: use require\\.NotNil"
-		require.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.NotNilf"
-		assert.NotNil(t, value)                                         // want "nil-compare: use assert\\.NotNil"
-		assert.NotNilf(t, value, "msg with args %d %s", 42, "42")       // want "nil-compare: use assert\\.NotNilf"
-		require.NotNil(t, value)                                        // want "nil-compare: use require\\.NotNil"
-		require.NotNilf(t, value, "msg with args %d %s", 42, "42")      // want "nil-compare: use require\\.NotNilf"
-		assert.NotNil(t, value)                                         // want "nil-compare: use assert\\.NotNil"
-		assert.NotNilf(t, value, "msg with args %d %s", 42, "42")       // want "nil-compare: use assert\\.NotNilf"
-		require.NotNil(t, value)                                        // want "nil-compare: use require\\.NotNil"
-		require.NotNilf(t, value, "msg with args %d %s", 42, "42")      // want "nil-compare: use require\\.NotNilf"
-		assert.NotNil(t, Row["col"])                                    // want "nil-compare: use assert\\.NotNil"
-		assert.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42")  // want "nil-compare: use assert\\.NotNilf"
-		require.NotNil(t, Row["col"])                                   // want "nil-compare: use require\\.NotNil"
-		require.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.NotNilf"
-		assert.NotNil(t, Row["col"])                                    // want "nil-compare: use assert\\.NotNil"
-		assert.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42")  // want "nil-compare: use assert\\.NotNilf"
-		require.NotNil(t, Row["col"])                                   // want "nil-compare: use require\\.NotNil"
-		require.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use require\\.NotNilf"
+		assert.Nil(t, value)                                           // want "nil-compare: use assert\\.Nil"
+		assert.Nilf(t, value, "msg with args %d %s", 42, "42")         // want "nil-compare: use assert\\.Nilf"
+		assert.Nil(t, value)                                           // want "nil-compare: use assert\\.Nil"
+		assert.Nilf(t, value, "msg with args %d %s", 42, "42")         // want "nil-compare: use assert\\.Nilf"
+		assert.Nil(t, Row["col"])                                      // want "nil-compare: use assert\\.Nil"
+		assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42")    // want "nil-compare: use assert\\.Nilf"
+		assert.Nil(t, Row["col"])                                      // want "nil-compare: use assert\\.Nil"
+		assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42")    // want "nil-compare: use assert\\.Nilf"
+		assert.Nil(t, value)                                           // want "nil-compare: use assert\\.Nil"
+		assert.Nilf(t, value, "msg with args %d %s", 42, "42")         // want "nil-compare: use assert\\.Nilf"
+		assert.Nil(t, value)                                           // want "nil-compare: use assert\\.Nil"
+		assert.Nilf(t, value, "msg with args %d %s", 42, "42")         // want "nil-compare: use assert\\.Nilf"
+		assert.Nil(t, Row["col"])                                      // want "nil-compare: use assert\\.Nil"
+		assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42")    // want "nil-compare: use assert\\.Nilf"
+		assert.Nil(t, Row["col"])                                      // want "nil-compare: use assert\\.Nil"
+		assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42")    // want "nil-compare: use assert\\.Nilf"
+		assert.Nil(t, value)                                           // want "nil-compare: use assert\\.Nil"
+		assert.Nilf(t, value, "msg with args %d %s", 42, "42")         // want "nil-compare: use assert\\.Nilf"
+		assert.Nil(t, value)                                           // want "nil-compare: use assert\\.Nil"
+		assert.Nilf(t, value, "msg with args %d %s", 42, "42")         // want "nil-compare: use assert\\.Nilf"
+		assert.Nil(t, Row["col"])                                      // want "nil-compare: use assert\\.Nil"
+		assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42")    // want "nil-compare: use assert\\.Nilf"
+		assert.Nil(t, Row["col"])                                      // want "nil-compare: use assert\\.Nil"
+		assert.Nilf(t, Row["col"], "msg with args %d %s", 42, "42")    // want "nil-compare: use assert\\.Nilf"
+		assert.NotNil(t, value)                                        // want "nil-compare: use assert\\.NotNil"
+		assert.NotNilf(t, value, "msg with args %d %s", 42, "42")      // want "nil-compare: use assert\\.NotNilf"
+		assert.NotNil(t, value)                                        // want "nil-compare: use assert\\.NotNil"
+		assert.NotNilf(t, value, "msg with args %d %s", 42, "42")      // want "nil-compare: use assert\\.NotNilf"
+		assert.NotNil(t, Row["col"])                                   // want "nil-compare: use assert\\.NotNil"
+		assert.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
+		assert.NotNil(t, Row["col"])                                   // want "nil-compare: use assert\\.NotNil"
+		assert.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
+		assert.NotNil(t, value)                                        // want "nil-compare: use assert\\.NotNil"
+		assert.NotNilf(t, value, "msg with args %d %s", 42, "42")      // want "nil-compare: use assert\\.NotNilf"
+		assert.NotNil(t, value)                                        // want "nil-compare: use assert\\.NotNil"
+		assert.NotNilf(t, value, "msg with args %d %s", 42, "42")      // want "nil-compare: use assert\\.NotNilf"
+		assert.NotNil(t, Row["col"])                                   // want "nil-compare: use assert\\.NotNil"
+		assert.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
+		assert.NotNil(t, Row["col"])                                   // want "nil-compare: use assert\\.NotNil"
+		assert.NotNilf(t, Row["col"], "msg with args %d %s", 42, "42") // want "nil-compare: use assert\\.NotNilf"
 	}
 
 	// Valid.
 	{
 		assert.Nil(t, value)
 		assert.Nilf(t, value, "msg with args %d %s", 42, "42")
-		require.Nil(t, value)
-		require.Nilf(t, value, "msg with args %d %s", 42, "42")
 		assert.NotNil(t, value)
 		assert.NotNilf(t, value, "msg with args %d %s", 42, "42")
-		require.NotNil(t, value)
-		require.NotNilf(t, value, "msg with args %d %s", 42, "42")
 	}
 
 	// Ignored.
 	{
 		assert.Equal(t, value, value)
 		assert.Equalf(t, value, value, "msg with args %d %s", 42, "42")
-		require.Equal(t, value, value)
-		require.Equalf(t, value, value, "msg with args %d %s", 42, "42")
 		assert.Equal(t, nil, nil)
 		assert.Equalf(t, nil, nil, "msg with args %d %s", 42, "42")
-		require.Equal(t, nil, nil)
-		require.Equalf(t, nil, nil, "msg with args %d %s", 42, "42")
 		assert.Equal(t, Row["col"], "foo")
 		assert.Equalf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
-		require.Equal(t, Row["col"], "foo")
-		require.Equalf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
 		assert.Equal(t, "foo", Row["col"])
 		assert.Equalf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
-		require.Equal(t, "foo", Row["col"])
-		require.Equalf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
 		assert.Equal(t, Row["col"], Row["col"])
 		assert.Equalf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
-		require.Equal(t, Row["col"], Row["col"])
-		require.Equalf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
 		assert.EqualValues(t, value, value)
 		assert.EqualValuesf(t, value, value, "msg with args %d %s", 42, "42")
-		require.EqualValues(t, value, value)
-		require.EqualValuesf(t, value, value, "msg with args %d %s", 42, "42")
 		assert.EqualValues(t, nil, nil)
 		assert.EqualValuesf(t, nil, nil, "msg with args %d %s", 42, "42")
-		require.EqualValues(t, nil, nil)
-		require.EqualValuesf(t, nil, nil, "msg with args %d %s", 42, "42")
 		assert.EqualValues(t, Row["col"], "foo")
 		assert.EqualValuesf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
-		require.EqualValues(t, Row["col"], "foo")
-		require.EqualValuesf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
 		assert.EqualValues(t, "foo", Row["col"])
 		assert.EqualValuesf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
-		require.EqualValues(t, "foo", Row["col"])
-		require.EqualValuesf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
 		assert.EqualValues(t, Row["col"], Row["col"])
 		assert.EqualValuesf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
-		require.EqualValues(t, Row["col"], Row["col"])
-		require.EqualValuesf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
 		assert.Exactly(t, value, value)
 		assert.Exactlyf(t, value, value, "msg with args %d %s", 42, "42")
-		require.Exactly(t, value, value)
-		require.Exactlyf(t, value, value, "msg with args %d %s", 42, "42")
 		assert.Exactly(t, nil, nil)
 		assert.Exactlyf(t, nil, nil, "msg with args %d %s", 42, "42")
-		require.Exactly(t, nil, nil)
-		require.Exactlyf(t, nil, nil, "msg with args %d %s", 42, "42")
 		assert.Exactly(t, Row["col"], "foo")
 		assert.Exactlyf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
-		require.Exactly(t, Row["col"], "foo")
-		require.Exactlyf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
 		assert.Exactly(t, "foo", Row["col"])
 		assert.Exactlyf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
-		require.Exactly(t, "foo", Row["col"])
-		require.Exactlyf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
 		assert.Exactly(t, Row["col"], Row["col"])
 		assert.Exactlyf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
-		require.Exactly(t, Row["col"], Row["col"])
-		require.Exactlyf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
 		assert.NotEqual(t, value, value)
 		assert.NotEqualf(t, value, value, "msg with args %d %s", 42, "42")
-		require.NotEqual(t, value, value)
-		require.NotEqualf(t, value, value, "msg with args %d %s", 42, "42")
 		assert.NotEqual(t, nil, nil)
 		assert.NotEqualf(t, nil, nil, "msg with args %d %s", 42, "42")
-		require.NotEqual(t, nil, nil)
-		require.NotEqualf(t, nil, nil, "msg with args %d %s", 42, "42")
 		assert.NotEqual(t, Row["col"], "foo")
 		assert.NotEqualf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
-		require.NotEqual(t, Row["col"], "foo")
-		require.NotEqualf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
 		assert.NotEqual(t, "foo", Row["col"])
 		assert.NotEqualf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
-		require.NotEqual(t, "foo", Row["col"])
-		require.NotEqualf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
 		assert.NotEqual(t, Row["col"], Row["col"])
 		assert.NotEqualf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
-		require.NotEqual(t, Row["col"], Row["col"])
-		require.NotEqualf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
 		assert.NotEqualValues(t, value, value)
 		assert.NotEqualValuesf(t, value, value, "msg with args %d %s", 42, "42")
-		require.NotEqualValues(t, value, value)
-		require.NotEqualValuesf(t, value, value, "msg with args %d %s", 42, "42")
 		assert.NotEqualValues(t, nil, nil)
 		assert.NotEqualValuesf(t, nil, nil, "msg with args %d %s", 42, "42")
-		require.NotEqualValues(t, nil, nil)
-		require.NotEqualValuesf(t, nil, nil, "msg with args %d %s", 42, "42")
 		assert.NotEqualValues(t, Row["col"], "foo")
 		assert.NotEqualValuesf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
-		require.NotEqualValues(t, Row["col"], "foo")
-		require.NotEqualValuesf(t, Row["col"], "foo", "msg with args %d %s", 42, "42")
 		assert.NotEqualValues(t, "foo", Row["col"])
 		assert.NotEqualValuesf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
-		require.NotEqualValues(t, "foo", Row["col"])
-		require.NotEqualValuesf(t, "foo", Row["col"], "msg with args %d %s", 42, "42")
 		assert.NotEqualValues(t, Row["col"], Row["col"])
 		assert.NotEqualValuesf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
-		require.NotEqualValues(t, Row["col"], Row["col"])
-		require.NotEqualValuesf(t, Row["col"], Row["col"], "msg with args %d %s", 42, "42")
 	}
 }
diff --git a/internal/testgen/gen_nil_compare.go b/internal/testgen/gen_nil_compare.go
index 1481b0b..34cf7bc 100644
--- a/internal/testgen/gen_nil_compare.go
+++ b/internal/testgen/gen_nil_compare.go
@@ -110,7 +110,6 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 func {{ .CheckerName.AsTestName }}(t *testing.T) {
@@ -121,7 +120,6 @@ func {{ .CheckerName.AsTestName }}(t *testing.T) {
 	{
 		{{- range $ai, $assrn := $.InvalidAssertions }}
 			{{ NewAssertionExpander.Expand $assrn "assert" "t" nil }}
-			{{ NewAssertionExpander.Expand $assrn "require" "t" nil }}
 		{{- end }}
 	}
 
@@ -129,7 +127,6 @@ func {{ .CheckerName.AsTestName }}(t *testing.T) {
 	{
 		{{- range $ai, $assrn := $.ValidAssertions }}
 			{{ NewAssertionExpander.Expand $assrn "assert" "t" nil }}
-			{{ NewAssertionExpander.Expand $assrn "require" "t" nil }}
 		{{- end }}
 	}
 
@@ -137,7 +134,6 @@ func {{ .CheckerName.AsTestName }}(t *testing.T) {
 	{
 		{{- range $ai, $assrn := $.IgnoredAssertions }}
 			{{ NewAssertionExpander.Expand $assrn "assert" "t" nil }}
-			{{ NewAssertionExpander.Expand $assrn "require" "t" nil }}
 		{{- end }}
 	}
 }