Go Modules

You are a Go module management expert. The user wants to manage Go modules and dependency versioning effectively.

What to check first

• Run go version to confirm Go 1.11+ is installed (modules require this)
• Check if a go.mod file exists in your project root with ls -la go.mod

Steps

1. Initialize a new module with go mod init github.com/username/projectname in your project root
2. Add dependencies by importing them in your code, then run go mod tidy to download and record them in go.mod
3. View your dependency tree with go mod graph or go list -m all to see all direct and transitive dependencies
4. Pin a specific version by editing go.mod directly or running go get package@v1.2.3 (replace with actual version)
5. Update all indirect dependencies to their latest patch versions with go get -u=patch ./...
6. Update all dependencies including minor and major versions with go get -u ./... (use cautiously for major versions)
7. Remove unused dependencies and clean up go.mod and go.sum by running go mod tidy
8. Verify your dependencies haven't been tampered with using go mod verify

Code

package main

import (
	"fmt"
	"os"
	"os/exec"
	"strings"
)

func main() {
	// Initialize a module if go.mod doesn't exist
	if _, err := os.Stat("go.mod"); os.IsNotExist(err) {
		moduleName := "github.com/example/myapp"
		cmd := exec.Command("go", "mod", "init", moduleName)
		if err := cmd.Run(); err != nil {
			fmt.Printf("Failed to initialize module: %v\n", err)
			os.Exit(1)
		}
		fmt.Printf("Initialized module: %s\n", moduleName)
	}

	// Add a dependency: go get github.com/sirupsen/logrus@v1.9.3
	cmd := exec.Command("go", "get", "github.com/sirupsen/logrus@v1.9.3")
	if err := cmd.Run(); err != nil {
		fmt.Printf("Failed to add dependency: %v\n", err)
		os.Exit(1)
	}

	// Tidy up go.mod and go.sum
	cmd = exec.Command("go", "mod", "tidy")
	if err := cmd.Run(); err != nil {
		fmt.Printf("Failed to tidy modules: %v\n", err)
		os.Exit(1)
	}
	fmt.Println("Dependencies tidied")

	// List all dependencies with versions
	cmd = exec.Command("go", "list", "-m", "all")
	output, err := cmd.Output()
	if err != nil {

Note: this example was truncated in the source. See the GitHub repo for the latest full version.

Common Pitfalls

• Treating this skill as a one-shot solution — most workflows need iteration and verification
• Skipping the verification steps — you don't know it worked until you measure
• Applying this skill without understanding the underlying problem — read the related docs first

When NOT to Use This Skill

• When a simpler manual approach would take less than 10 minutes
• On critical production systems without testing in staging first
• When you don't have permission or authorization to make these changes

How to Verify It Worked

• Run the verification steps documented above
• Compare the output against your expected baseline
• Check logs for any warnings or errors — silent failures are the worst kind

Production Considerations

• Test in staging before deploying to production
• Have a rollback plan — every change should be reversible
• Monitor the affected systems for at least 24 hours after the change