CF

Command Line Applications in Go

27h 11m 52s
English
Paid
Added to CourseFlix

Command Line Applications in Go is a 129-lesson 27 hours 11 minutes self-paced course by Elliott Minns. Build Real Command-Line Tools in Go This 129-lesson course, taught by Elliott Minns, takes you from a first console program to full terminal user interfaces (TUIs) that can hold their own against a web app, using nothing but the Go…

Course facts

Lessons
129
Duration
27 hours 11 minutes
Language
English
Added to CourseFlix
January 2026
Instructor
Elliott Minns
Price
Premium

Build Real Command-Line Tools in Go

This 129-lesson course, taught by Elliott Minns, takes you from a first console program to full terminal user interfaces (TUIs) that can hold their own against a web app, using nothing but the Go toolchain and a project-based approach.

Core Skills You Will Practice

  • Reading and writing files and streams
  • Handling user input and output
  • Parsing command-line arguments
  • Working with concurrency and channels
  • Writing tests for reliable code
  • Building network-aware applications
  • Designing interactive TUI interfaces
  • Storing data with BadgerDB and SQLite
  • Packaging and distributing a finished binary

Projects You Will Ship

Instead of isolated exercises, you build four working tools end to end: a line-and-word counter, a git commit message generator that calls the OpenAI API, a gzip-based compression utility, and a terminal app for storing and retrieving data.

Who It's For

No prior Go experience is assumed. It suits anyone who wants to learn the language by shipping their own CLI utilities, in a year when Go's speed, clean syntax, and strong memory and type safety keep it near the top of languages worth learning.

Additional

  • https://github.com/dreamsofcode-io/vibe

Who teaches Command Line Applications in Go? Elliott Minns

Elliott Minns thumbnail

Elliott Minns is a software engineer and educator focused on practical Go (Golang) tutorials, particularly the production craft of building command-line tools.

His CourseFlix listing carries Command Line Applications in Go — a structured treatment of building production-quality CLI tools in Go: argument parsing, the cobra / urfave-cli framework choices, the testing patterns, the cross-platform release workflow, and the engineering decisions that separate polished CLI tools from generic command-line scripts.

Material is paid and aimed at Go developers shipping CLI tools as a deliberate product category. For broader content, see CourseFlix's Golang category page.

What lessons are included in Command Line Applications in Go?

This is a demo lesson (10:00 remaining)

Watch the first 10 minutes free. One payment unlocks all 129 lessons here and every other premium course. No auto-renew.

Watch all 129 lessons from $6.67/mo
0:00
/
#1: 1. Introduction to the course
All Course Lessons (129)
#Lesson TitleDurationAccess
1
1. Introduction to the course Demo
02:59
2
2. Welcome!
04:58
3
3. Setting up your environment
15:28
4
4. Go 101- Variables, Values & Types
24:34
5
5. Go 101- Conditionals & Loops
19:27
6
6. Go 101- Functions & Pointers
17:10
7
7. Go 101- Packages
12:45
8
8. Starting a new project
12:42
9
9. Reading from a file
11:24
10
10. A Simple Word Counter
09:31
11
11. Writing te
15:35
12
12. Edge cases
10:36
13
13. Table Driven Testing
13:12
14
14. A better algorithm
15:24
15
15. Introduction to input
02:20
16
16. Exit codes
05:40
17
17. Standard error
11:11
18
18. Reading large files
23:28
19
19. Bytes & ascii
15:13
20
20. Unicode & Runes
18:05
21
21. The bufio package
08:35
22
22. Decoupling & io.Reader
08:58
23
23. Command line argume
09:10
24
24. Handling multiple errors
16:06
25
25. Closing files with defer
08:21
26
26. Standard input
08:05
27
27. Scanning data
19:47
28
28. Adding new features
05:47
29
29. Counting lines
11:48
30
30. Counting bytes
10:33
31
31. Encapsulation
10:42
32
32. File offs and seeking
18:45
33
33. Methods
17:05
34
34. Variadic parameters
07:02
35
35. Method receivers
11:49
36
36. CLI flags
25:14
37
37. Single pass algorithm_2
08:54
38
38. Tabular output
15:00
39
39. Organizing our code
13:32
40
40. Package visibility
09:23
41
41. Constructor argume
06:41
42
42. Whitebox vs Blackbox testing
11:25
43
43. Introduction to concurrency & data
01:28
44
44. Goroutines & Waitgroups
12:02
45
45. Channels
12:47
46
46. Handling async errors
14:17
47
47. io.TeeReader
06:00
48
48. io.Pipe
08:00
49
49. io.MultiWriter
05:07
50
50. Introduction to Advanced Testing
01:10
51
51. Benchmark testing
09:26
52
52. End to end testing (e2e)
15:09
53
53. e2e- Testing files
13:06
54
54. e2e- Multiple files
17:54
55
55. Determinstic output
11:35
56
56. e2e- Testing flags
05:37
57
57. Creating test helpers
18:45
58
58. Executing commands
09:00
59
59. Passing in input
08:18
60
60. Configuring commands
09:21
61
61. Asynchronous execution
15:07
62
62. Signals
13:43
63
63. Graceful shutdown
07:25
64
64. Cancellation
17:02
65
65. context.Context
17:14
66
66. Building a process guard
22:31
67
67. Opening an editor
09:53
68
68. Fuzzy finding with fzf
09:32
69
69. Introduction to Networking & Files
03:20
70
70. File flags
11:10
71
71. File permissions
20:21
72
72. Walking the filesystem
18:13
73
73. Lockfiles & PIDFiles
16:50
74
74. File locks
08:25
75
75. The net package
09:29
76
76. TCP Client
03:05
77
77. DNS lookups
03:18
78
78. Port scanning
07:26
79
79. The net-http package
17:32
80
80. Marshaling & unmarshaling data
15:31
81
81. Sending files with HTTP
08:05
82
82. Testing HTTP Reque
09:20
83
83. Introduction to Powerful CLI Apps
01:35
84
84. Subcommands
12:57
85
85. Flags
15:05
86
86. Subcommand Abstraction
21:42
87
87. Compressing files & data with GZip
24:28
88
88. Hashing files & data
15:38
89
89. Password & Secure Input
20:32
90
90. Have I been pwned.
15:33
91
91. Environment variables
12:04
92
92. Configuration files
16:32
93
93. Advanced Error Handling
20:01
94
94. Embedding Files
09:28
95
95. Cross platform code
15:31
96
96. Build flags
11:36
97
97. Regular expressions
14:19
98
98. UI- A Loading Spinner
15:37
99
99. UI- A Progress Bar
17:27
100
100. Adding color to Stdout
09:24
101
101. Working with images
19:56
102
102. Distributing an application
15:21
103
103. An Application Builder
08:27
104
104. Handling CGO
14:55
105
105. Introduction to Popular CLI packages
03:18
106
106. Subcommands with Cobra
13:54
107
107. POSIX flags with pFlag
19:23
108
108. Storing data with SQLite
28:38
109
109. Database Migrations with Migrate
24:15
110
110. Repositories with SQLc
16:32
111
111. Color with color
09:21
112
112. TUI with Bubble Tea
18:32
113
113. Forms with huh
15:02
114
114. Test assertions with Testify
18:14
115
115. Mocking with go-mock
33:34
116
116. Releasing with Go releaser
11:27
117
117. Introduction to Final Project
01:27
118
118. Project setup
04:17
119
119. Obtaining staged changes
09:04
120
120. Installing Ollama
05:25
121
121. Prompting the LLM
15:07
122
122. Commiting our messages
06:17
123
123. Adding in a spinner
07:27
124
124. Adding another provider
11:05
125
125. Adding in CLI flags
19:55
126
126. Provider registration
14:57
127
127. Integration testing
16:52
128
128. Homework and improveme
09:02
129
129. Conclusion and closing remarks
02:41
Watch the other 128 lessons

One payment unlocks this course and every other premium course. No auto-renew.

See plans

What courses are similar to Command Line Applications in Go?

Frequently asked questions

What are the prerequisites for enrolling in this course?
Before starting this course, students should have a basic understanding of programming concepts. Familiarity with Go is beneficial but not required, as the course begins with foundational topics such as variables, conditionals, functions, and packages in Go.
What type of applications will I learn to build in this course?
The course focuses on developing command-line applications. You will build various practical tools, including a file word counter, a git message generator using the OpenAI API, a data compression tool using gzip, and a console application for data storage and retrieval.
Who is the target audience for this course?
This course is ideal for individuals looking to learn Go from scratch or professionals seeking to enhance their skills in developing command-line applications. It is also suitable for developers interested in exploring the use of Go for creating CLI utilities and TUI programs.
How does the course depth compare to other programming courses?
The course provides a thorough exploration of Go for building CLI applications. It covers advanced topics like concurrency, channels, and network applications, offering a comprehensive understanding beyond basic Go programming, especially in the context of command-line tool development.
Which specific tools and platforms are covered in the course?
Students will learn to use tools and libraries such as the bufio package for handling I/O operations, concurrency features like goroutines and channels, and data stores like BadgerDB and SQLite. The course also covers packaging and distributing applications effectively.
What topics are not covered in this course?
The course does not cover GUI application development or other programming languages outside of Go. It focuses specifically on command-line applications and related Go features, without exploring web development or mobile application development.
What is the time commitment required for this course?
The course consists of 129 lessons. While the total runtime is not specified, students should be prepared to invest a substantial amount of time to engage with the lessons, complete exercises, and build the projects to gain the full benefit from the course.