Type Go Code Faster With These Drills

Where Python is colon-heavy and Rust is symbol-heavy, Go is pattern-heavy. The same short patterns appear over and over: `:=`, `if err != nil { return err }`, `func (x *Type) Method()`, `make(chan int)`. Drill these patterns as whole motor units and Go becomes dramatically faster to type.

The opposite approach — drilling individual keys in isolation — does not work as well for Go, because the patterns are short and well-defined enough that chunking them produces outsized gains.

`:=` appears on nearly every line of idiomatic Go. It is a two-character sequence where neither key is difficult, but the pair is uncommon outside Go and feels slow until drilled. The Go symbols lesson drills `:=` alongside common openings like `x := 1`, `err := doWork()`, `data, err := fetch()`.

Target: you should be able to type `err := ` in under half a second. If it is slower than that, it is worth a few focused drill sessions.

The single most common pattern in Go is `if err != nil { return err }`. Typing this character-by-character is the hallmark of a beginner. Idiomatic Go developers have this pattern chunked as a unit — their fingers produce it in about a second regardless of how they are feeling.

The Go control flow lesson drills this pattern repeatedly in different contexts so it becomes muscle memory. Once it is, a meaningful fraction of your Go typing becomes effectively free.

Struct tags are written inside backticks, which is a key that prose typists almost never use. Tags like `\`json:"email"\`` appear on nearly every API struct in a Go service. The Go declarations lesson drills struct definitions with realistic tag patterns.

Interface definitions are another place where chunked patterns help: `type Reader interface { Read(p []byte) (n int, err error) }` is long but follows a standard shape. The Go functions lesson covers both method signatures and interface definitions.

The send-receive arrow `<-` is Go's most distinctive operator. It appears in `ch <- value` (send), `value := <-ch` (receive), and `for x := range ch` (receive loop). The Go idioms lesson and real snippet lesson put these in real concurrency contexts — a worker pool, a fan-out pipeline, a small HTTP handler with goroutines.

After two to three focused practice sessions on channel patterns, `<-` stops feeling foreign and Go concurrency code becomes noticeably faster to type.