Building Command-Line Applications in Go: A Practical Guide

By Anastasia K.4 min readFebruary 19, 2026

To build a command-line application in Go, you will typically use the flag package for argument parsing, and you might want to structure your application using packages for better organization. This guide will cover creating a simple CLI tool that performs basic file operations, including reading, writing, and deleting files.

Setting Up Your Go Environment

Before we dive into the code, ensure you have Go installed on your machine. You can verify your installation by running:

go version

If Go is installed, you can proceed to create a new directory for your project:

mkdir go-cli-tool
cd go-cli-tool
go mod init go-cli-tool

Implementing the CLI Tool

Step 1: Import Necessary Packages

Create a new file named main.go and import the necessary packages:

package main

import (
    "flag"
    "fmt"
    "io/ioutil"
    "os"
)

Step 2: Define Command-Line Flags

We will define flags for our CLI tool to specify the operation and the file name. Here’s how you can set it up:

func main() {
    operation := flag.String("operation", "read", "Operation to perform: read, write, delete")
    fileName := flag.String("file", "", "Name of the file to operate on")
    content := flag.String("content", "", "Content to write to the file (used with write operation)")

    flag.Parse()

    // Check if the file name is provided
    if *fileName == "" {
        fmt.Println("Error: Please provide a file name using -file flag.")
        os.Exit(1)
    }

    switch *operation {
    case "read":
        readFile(*fileName)
    case "write":
        writeFile(*fileName, *content)
    case "delete":
        deleteFile(*fileName)
    default:
        fmt.Println("Error: Unknown operation. Use read, write, or delete.")
        os.Exit(1)
    }
}

Step 3: Implement File Operations

Now, let’s implement the functions for reading, writing, and deleting files.

Read File Function

func readFile(fileName string) {
    data, err := ioutil.ReadFile(fileName)
    if err != nil {
        fmt.Printf("Error reading file: %s\n", err)
        return
    }
    fmt.Printf("File content:\n%s\n", string(data))
}

Write File Function

func writeFile(fileName, content string) {
    if content == "" {
        fmt.Println("Error: No content provided to write.")
        return
    }
    err := ioutil.WriteFile(fileName, []byte(content), 0644)
    if err != nil {
        fmt.Printf("Error writing to file: %s\n", err)
        return
    }
    fmt.Println("File written successfully.")
}

Delete File Function

func deleteFile(fileName string) {
    err := os.Remove(fileName)
    if err != nil {
        fmt.Printf("Error deleting file: %s\n", err)
        return
    }
    fmt.Println("File deleted successfully.")
}

Step 4: Running the CLI Tool

Now that we have implemented the core functionality, you can build and run your CLI tool. Use the following commands:

Write to a file:

go run main.go -operation write -file example.txt -content "Hello, Go CLI!"

Read from a file:

go run main.go -operation read -file example.txt

Delete a file:

go run main.go -operation delete -file example.txt

Best Practices for CLI Applications

Best Practice	Description
Use Clear and Concise Flags	Ensure that command-line flags are easy to understand and use.
Provide Help Documentation	Implement a help flag (`-h`) to guide users on how to use your application.
Handle Errors Gracefully	Always check for errors and provide meaningful messages to the user.
Structure Your Code	Organize your code into packages and functions for better readability.
Test Your CLI Tool	Write tests for your CLI tool to ensure reliability and correctness.

By adhering to these best practices, you can create robust command-line applications that are user-friendly and maintainable.

Conclusion

In this tutorial, you learned how to create a basic command-line application in Go that performs file operations. We covered setting up the Go environment, defining command-line flags, implementing file operations, and best practices for CLI development. With this foundation, you can expand your tool to include more complex features and functionalities.

Learn more with useful resources: