diff --git a/.golangci.yml b/.golangci.yml
index 736de88..0030774 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -1,9 +1,6 @@
 run:
   timeout: 5m
   modules-download-mode: readonly
-  skip-dirs:
-    - scripts
-    - test
   skip-dirs-use-default: true
 
 issues:
@@ -12,6 +9,9 @@ issues:
   # Value 0 means show all.
   max-issues-per-linter: 0
   max-same-issues: 0
+  exclude-dirs:
+    - scripts
+    - test
 
 linters-settings:
   revive:
diff --git a/command.go b/command.go
index b6e064a..80cf5f5 100644
--- a/command.go
+++ b/command.go
@@ -106,7 +106,8 @@ func (c Command) runForModule(module *internal.Module) error {
 	module.Skipped = true
 
 	// Verify if the module is private.
-	if c.vcs.IsPrivate(module.Path) {
+	// Use default handler for go-list.
+	if !c.optionIsSet(OptionUseGoList) && c.vcs.IsPrivate(module.Path) {
 		var err error
 		repo, err = c.vcs.GetHandler(module.Path)
 		if err != nil {
diff --git a/command_test.go b/command_test.go
index 7d9d89c..7756330 100644
--- a/command_test.go
+++ b/command_test.go
@@ -968,6 +968,41 @@ func TestCommand_FindLatestBefore(t *testing.T) {
 	}
 }
 
+// Fixes: https://github.com/nieomylnieja/go-libyear/issues/56
+func TestCommand_UseDefaultHandlerForPrivateRepoWithGoList(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	currentLatest := &internal.Module{
+		Path:    "github.com/nieomylnieja/go-libyear",
+		Version: semver.MustParse("v0.5.0"),
+		Time:    mustParseTime(t, "2024-05-20"),
+	}
+	modulesRepo := mocks.NewMockModulesRepo(ctrl)
+	modulesRepo.EXPECT().
+		GetLatestInfo("github.com/nieomylnieja/go-libyear").
+		Times(1).
+		Return(currentLatest, nil)
+	modulesRepo.EXPECT().
+		GetLatestInfo("github.com/nieomylnieja/go-libyear/v2").
+		Times(1).
+		Return(nil, errors.New("no matching versions"))
+	vcsHandler := mocks.NewMockVCSHandler(ctrl)
+	vcsHandler.EXPECT().
+		CanHandle(gomock.Any()).
+		Times(0)
+	cmd := Command{
+		repo: modulesRepo,
+		opts: OptionFindLatestMajor,
+		vcs: &VCSRegistry{
+			vcsHandlers: []VCSHandler{vcsHandler},
+		},
+	}
+
+	module := currentLatest
+	err := cmd.runForModule(module)
+
+	require.NoError(t, err)
+}
+
 func mustParseTime(t *testing.T, date string) time.Time {
 	t.Helper()
 	parsed, _ := time.Parse(time.DateOnly, date)
diff --git a/go.mod b/go.mod
index 54c2fd6..d243c45 100644
--- a/go.mod
+++ b/go.mod
@@ -6,17 +6,17 @@ require (
 	github.com/Masterminds/semver v1.5.0
 	github.com/pkg/errors v0.9.1
 	github.com/stretchr/testify v1.9.0
-	github.com/urfave/cli/v2 v2.27.1
+	github.com/urfave/cli/v2 v2.27.2
 	go.uber.org/mock v0.4.0
 	golang.org/x/mod v0.17.0
 	golang.org/x/sync v0.7.0
 )
 
 require (
-	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.4 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
+	github.com/xrash/smetrics v0.0.0-20240312152122-5f08fbb34913 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/go.sum b/go.sum
index b7bf759..d592549 100644
--- a/go.sum
+++ b/go.sum
@@ -2,6 +2,8 @@ github.com/Masterminds/semver v1.5.0 h1:H65muMkzWKEuNDnfl9d70GUjFniHKHRbFPGBuZ3Q
 github.com/Masterminds/semver v1.5.0/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y=
 github.com/cpuguy83/go-md2man/v2 v2.0.3 h1:qMCsGGgs+MAzDFyp9LpAe1Lqy/fY/qCovCm0qnXZOBM=
 github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4=
+github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
@@ -14,8 +16,12 @@ github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsT
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/urfave/cli/v2 v2.27.1 h1:8xSQ6szndafKVRmfyeUMxkNUJQMjL1F2zmsZ+qHpfho=
 github.com/urfave/cli/v2 v2.27.1/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ=
+github.com/urfave/cli/v2 v2.27.2 h1:6e0H+AkS+zDckwPCUrZkKX38mRaau4nL2uipkJpbkcI=
+github.com/urfave/cli/v2 v2.27.2/go.mod h1:g0+79LmHHATl7DAcHO99smiR/T7uGLw84w8Y42x+4eM=
 github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU=
 github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=
+github.com/xrash/smetrics v0.0.0-20240312152122-5f08fbb34913 h1:+qGGcbkzsfDQNPPe9UDgpxAWQrhbbBXOYJFQDq/dtJw=
+github.com/xrash/smetrics v0.0.0-20240312152122-5f08fbb34913/go.mod h1:4aEEwZQutDLsQv2Deui4iYQ6DWTxR14g6m8Wv88+Xqk=
 go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU=
 go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc=
 golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA=
diff --git a/internal/mocks/vcs.go b/internal/mocks/vcs.go
new file mode 100644
index 0000000..bd61ddb
--- /dev/null
+++ b/internal/mocks/vcs.go
@@ -0,0 +1,275 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/nieomylnieja/go-libyear (interfaces: VCSHandler)
+//
+// Generated by this command:
+//
+//	mockgen -destination internal/mocks/vcs.go -package mocks -typed . VCSHandler
+//
+
+// Package mocks is a generated GoMock package.
+package mocks
+
+import (
+	reflect "reflect"
+
+	semver "github.com/Masterminds/semver"
+	gomock "go.uber.org/mock/gomock"
+
+	internal "github.com/nieomylnieja/go-libyear/internal"
+)
+
+// MockVCSHandler is a mock of VCSHandler interface.
+type MockVCSHandler struct {
+	ctrl     *gomock.Controller
+	recorder *MockVCSHandlerMockRecorder
+}
+
+// MockVCSHandlerMockRecorder is the mock recorder for MockVCSHandler.
+type MockVCSHandlerMockRecorder struct {
+	mock *MockVCSHandler
+}
+
+// NewMockVCSHandler creates a new mock instance.
+func NewMockVCSHandler(ctrl *gomock.Controller) *MockVCSHandler {
+	mock := &MockVCSHandler{ctrl: ctrl}
+	mock.recorder = &MockVCSHandlerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockVCSHandler) EXPECT() *MockVCSHandlerMockRecorder {
+	return m.recorder
+}
+
+// CanHandle mocks base method.
+func (m *MockVCSHandler) CanHandle(arg0 string) (bool, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CanHandle", arg0)
+	ret0, _ := ret[0].(bool)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CanHandle indicates an expected call of CanHandle.
+func (mr *MockVCSHandlerMockRecorder) CanHandle(arg0 any) *MockVCSHandlerCanHandleCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CanHandle", reflect.TypeOf((*MockVCSHandler)(nil).CanHandle), arg0)
+	return &MockVCSHandlerCanHandleCall{Call: call}
+}
+
+// MockVCSHandlerCanHandleCall wrap *gomock.Call
+type MockVCSHandlerCanHandleCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockVCSHandlerCanHandleCall) Return(arg0 bool, arg1 error) *MockVCSHandlerCanHandleCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockVCSHandlerCanHandleCall) Do(f func(string) (bool, error)) *MockVCSHandlerCanHandleCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockVCSHandlerCanHandleCall) DoAndReturn(f func(string) (bool, error)) *MockVCSHandlerCanHandleCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// GetInfo mocks base method.
+func (m *MockVCSHandler) GetInfo(arg0 string, arg1 *semver.Version) (*internal.Module, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetInfo", arg0, arg1)
+	ret0, _ := ret[0].(*internal.Module)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetInfo indicates an expected call of GetInfo.
+func (mr *MockVCSHandlerMockRecorder) GetInfo(arg0, arg1 any) *MockVCSHandlerGetInfoCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInfo", reflect.TypeOf((*MockVCSHandler)(nil).GetInfo), arg0, arg1)
+	return &MockVCSHandlerGetInfoCall{Call: call}
+}
+
+// MockVCSHandlerGetInfoCall wrap *gomock.Call
+type MockVCSHandlerGetInfoCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockVCSHandlerGetInfoCall) Return(arg0 *internal.Module, arg1 error) *MockVCSHandlerGetInfoCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockVCSHandlerGetInfoCall) Do(f func(string, *semver.Version) (*internal.Module, error)) *MockVCSHandlerGetInfoCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockVCSHandlerGetInfoCall) DoAndReturn(f func(string, *semver.Version) (*internal.Module, error)) *MockVCSHandlerGetInfoCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// GetLatestInfo mocks base method.
+func (m *MockVCSHandler) GetLatestInfo(arg0 string) (*internal.Module, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetLatestInfo", arg0)
+	ret0, _ := ret[0].(*internal.Module)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetLatestInfo indicates an expected call of GetLatestInfo.
+func (mr *MockVCSHandlerMockRecorder) GetLatestInfo(arg0 any) *MockVCSHandlerGetLatestInfoCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestInfo", reflect.TypeOf((*MockVCSHandler)(nil).GetLatestInfo), arg0)
+	return &MockVCSHandlerGetLatestInfoCall{Call: call}
+}
+
+// MockVCSHandlerGetLatestInfoCall wrap *gomock.Call
+type MockVCSHandlerGetLatestInfoCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockVCSHandlerGetLatestInfoCall) Return(arg0 *internal.Module, arg1 error) *MockVCSHandlerGetLatestInfoCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockVCSHandlerGetLatestInfoCall) Do(f func(string) (*internal.Module, error)) *MockVCSHandlerGetLatestInfoCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockVCSHandlerGetLatestInfoCall) DoAndReturn(f func(string) (*internal.Module, error)) *MockVCSHandlerGetLatestInfoCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// GetModFile mocks base method.
+func (m *MockVCSHandler) GetModFile(arg0 string, arg1 *semver.Version) ([]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetModFile", arg0, arg1)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetModFile indicates an expected call of GetModFile.
+func (mr *MockVCSHandlerMockRecorder) GetModFile(arg0, arg1 any) *MockVCSHandlerGetModFileCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetModFile", reflect.TypeOf((*MockVCSHandler)(nil).GetModFile), arg0, arg1)
+	return &MockVCSHandlerGetModFileCall{Call: call}
+}
+
+// MockVCSHandlerGetModFileCall wrap *gomock.Call
+type MockVCSHandlerGetModFileCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockVCSHandlerGetModFileCall) Return(arg0 []byte, arg1 error) *MockVCSHandlerGetModFileCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockVCSHandlerGetModFileCall) Do(f func(string, *semver.Version) ([]byte, error)) *MockVCSHandlerGetModFileCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockVCSHandlerGetModFileCall) DoAndReturn(f func(string, *semver.Version) ([]byte, error)) *MockVCSHandlerGetModFileCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// GetVersions mocks base method.
+func (m *MockVCSHandler) GetVersions(arg0 string) ([]*semver.Version, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetVersions", arg0)
+	ret0, _ := ret[0].([]*semver.Version)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVersions indicates an expected call of GetVersions.
+func (mr *MockVCSHandlerMockRecorder) GetVersions(arg0 any) *MockVCSHandlerGetVersionsCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVersions", reflect.TypeOf((*MockVCSHandler)(nil).GetVersions), arg0)
+	return &MockVCSHandlerGetVersionsCall{Call: call}
+}
+
+// MockVCSHandlerGetVersionsCall wrap *gomock.Call
+type MockVCSHandlerGetVersionsCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockVCSHandlerGetVersionsCall) Return(arg0 []*semver.Version, arg1 error) *MockVCSHandlerGetVersionsCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockVCSHandlerGetVersionsCall) Do(f func(string) ([]*semver.Version, error)) *MockVCSHandlerGetVersionsCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockVCSHandlerGetVersionsCall) DoAndReturn(f func(string) ([]*semver.Version, error)) *MockVCSHandlerGetVersionsCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Name mocks base method.
+func (m *MockVCSHandler) Name() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Name")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// Name indicates an expected call of Name.
+func (mr *MockVCSHandlerMockRecorder) Name() *MockVCSHandlerNameCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockVCSHandler)(nil).Name))
+	return &MockVCSHandlerNameCall{Call: call}
+}
+
+// MockVCSHandlerNameCall wrap *gomock.Call
+type MockVCSHandlerNameCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *MockVCSHandlerNameCall) Return(arg0 string) *MockVCSHandlerNameCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *MockVCSHandlerNameCall) Do(f func() string) *MockVCSHandlerNameCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *MockVCSHandlerNameCall) DoAndReturn(f func() string) *MockVCSHandlerNameCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
diff --git a/vcs.go b/vcs.go
index d217411..fdfffa2 100644
--- a/vcs.go
+++ b/vcs.go
@@ -10,6 +10,8 @@ import (
 	"github.com/nieomylnieja/go-libyear/internal"
 )
 
+//go:generate mockgen -destination internal/mocks/vcs.go -package mocks -typed . VCSHandler
+
 // VCSHandler is an interface that can be implemented by specifc VCS handler.
 type VCSHandler interface {
 	ModulesRepo