ChannelWhat is channel?A typed conduit in Go used to pass values between goroutines - can be unbuffered (synchronous) or buffered (async queue). Ask AI for more basics

A channel is a typed conduit. You create it with make, send with <-, and receive with <-:

ch := make(chan string)    // unbuffered channel of strings

go func() {
    ch <- "hello"          // send - blocks until someone receives
}()

msg := <-ch                // receive - blocks until someone sends
fmt.Println(msg)           // "hello"

The arrow direction tells you everything: ch <- value pushes into the channel, <-ch pulls out.

Unbuffered vs buffered: the critical distinction

This is where AI fails most often. The difference isn't just performance, it fundamentally changes program behavior.

Unbuffered channels are synchronous rendezvous points. The sender blocks until a receiver is ready, and vice versa. Both goroutines must arrive at the channelWhat is channel?A typed conduit in Go used to pass values between goroutines - can be unbuffered (synchronous) or buffered (async queue). Ask AI for more operation at roughly the same time:

ch := make(chan int) // unbuffered

// This deadlocks - no one is receiving!
ch <- 42             // blocks forever in main goroutine
fmt.Println(<-ch)

Buffered channels decouple sender and receiver. The sender only blocks when the buffer is full:

ch := make(chan int, 3) // buffer of 3

ch <- 1  // doesn't block - buffer has space
ch <- 2  // doesn't block
ch <- 3  // doesn't block
// ch <- 4 // WOULD block - buffer full

fmt.Println(<-ch) // 1 (FIFO)

ChannelWhat is channel?A typed conduit in Go used to pass values between goroutines - can be unbuffered (synchronous) or buffered (async queue). Ask AI for more directions in function signatures

Go lets you restrict a channel parameter to send-only or receive-only. This is documentation and compile-time safety:

func producer(out chan<- int) {   // can only send
    out <- 42
    // <-out  // compile error
}

func consumer(in <-chan int) {    // can only receive
    val := <-in
    // in <- 1  // compile error
    fmt.Println(val)
}

When you ask AI to write a pipelineWhat is pipeline?A sequence of automated steps (install, lint, test, build, deploy) that code passes through before reaching production. Ask AI for more function, check that it uses directional channels. If all channels are bidirectional chan T, the code works but loses compile-time safety against accidental misuse.

Closing channels

Closing a channelWhat is channel?A typed conduit in Go used to pass values between goroutines - can be unbuffered (synchronous) or buffered (async queue). Ask AI for more signals that no more values will be sent. Receivers can detect this:

ch := make(chan int)

go func() {
    for i := 0; i < 5; i++ {
        ch <- i
    }
    close(ch) // signal: no more values
}()

// range automatically stops when channel is closed
for v := range ch {
    fmt.Println(v) // 0, 1, 2, 3, 4
}

The rules around closing are strict and unintuitive:

The deadly deadlockWhat is deadlock?A situation where two or more operations are stuck waiting on each other forever, so none of them can proceed. Ask AI for more patterns

AI generates these constantly. Learn to spot them:

// DEADLOCK 1: unbuffered send and receive in same goroutine
func main() {
    ch := make(chan int)
    ch <- 1        // blocks forever - no other goroutine to receive
    fmt.Println(<-ch)
}

// DEADLOCK 2: two goroutines waiting on each other
func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)

    go func() {
        val := <-ch1  // waits for ch1
        ch2 <- val    // never reaches here
    }()

    val := <-ch2      // waits for ch2 - circular dependency
    ch1 <- val
}

// DEADLOCK 3: forgetting to close a channel with range
func main() {
    ch := make(chan int)
    go func() {
        ch <- 1
        ch <- 2
        // forgot close(ch)!
    }()
    for v := range ch { // blocks forever after receiving 2
        fmt.Println(v)
    }
}

ChannelWhat is channel?A typed conduit in Go used to pass values between goroutines - can be unbuffered (synchronous) or buffered (async queue). Ask AI for more patterns you'll see AI generate

Signaling with empty struct

When you only need to signal an event (no data), use chan struct{}, zero memory per signal:

done := make(chan struct{})

go func() {
    doWork()
    close(done) // signal completion to all receivers
}()

<-done // wait for signal

Closing a channel unblocks all receivers simultaneously. This is how you broadcast "done" to multiple goroutines.

Generator pattern

A function that returns a receive-only channel:

func fibonacci(n int) <-chan int {
    ch := make(chan int)
    go func() {
        defer close(ch)
        a, b := 0, 1
        for i := 0; i < n; i++ {
            ch <- a
            a, b = b, a+b
        }
    }()
    return ch
}

for v := range fibonacci(10) {
    fmt.Println(v)
}