The four forms of for

Every for loop in Go is one of these. When AI generates a loop, your first job is identifying which form it used and whether it picked the right one.

Classic three-part loop

When you ask AI to "iterate 10 times" or "loop from 0 to n", it generates this:

for i := 0; i < 5; i++ {
    fmt.Println("Iteration:", i)
}

The three parts: init; condition; post. All optional, but if you include any, you need the semicolons.

While-style loops

Drop the init and post, and for becomes a while loop:

count := 0
for count < 3 {
    fmt.Println("Count is:", count)
    count++
}

No semicolons needed. AI trained on C-style languages sometimes generates for (; count < 3; ) which compiles but is not idiomatic Go. If you see semicolons in a condition-only loop, that is a code smellWhat is code smell?A pattern in code that isn't a bug but signals a design problem that will make future changes harder. Ask AI for more.

Infinite loops and break

When you ask AI to build a server listener or a retry loop, it generates this pattern:

for {
    conn, err := listener.Accept()
    if err != nil {
        break
    }
    go handleConnection(conn)
}

No condition means "loop forever." The only exit is break, return, or os.Exit.

Range loops

This is where AI makes the most mistakes. range returns two values, and the rules change depending on what you are ranging over:

// Slices: index, value
fruits := []string{"apple", "banana", "cherry"}
for index, fruit := range fruits {
    fmt.Printf("%d: %s\n", index, fruit)
}

// Maps: key, value
ages := map[string]int{"Alice": 30, "Bob": 25}
for name, age := range ages {
    fmt.Printf("%s is %d\n", name, age)
}

// Strings: byte index, rune (not byte!)
for i, char := range "Go!" {
    fmt.Printf("Index %d: %c\n", i, char)
}

Do not need the indexWhat is index?A data structure the database maintains alongside a table so it can find rows by specific columns quickly instead of scanning everything. Ask AI for more? Use blank identifier:

for _, fruit := range fruits {
    fmt.Println(fruit)
}

Do not need the value? Just omit it:

for i := range fruits {
    fmt.Println(i) // prints 0, 1, 2
}

What range returns by type

Map iteration order is random

This trips up AI-generated tests constantly:

m := map[string]int{"a": 1, "b": 2, "c": 3}
for k, v := range m {
    fmt.Println(k, v) // Different order each run!
}

Go randomizes map iteration order on purpose. If AI generates a test that asserts keys[0] == "a" after ranging over a map, that test will pass sometimes and fail other times. This is a flaky test, and AI generates them regularly.

Labels for nested loops

When you need to break out of an outer loop from inside an inner one:

OuterLoop:
for i, a := range numbers {
    for _, b := range numbers[i+1:] {
        if a+b == 10 {
            fmt.Printf("Found: %d + %d = 10\n", a, b)
            break OuterLoop
        }
    }
}

Without the label, break only exits the inner loop. AI rarely generates labeled breaks, so if you need one, you will likely have to ask for it explicitly.

break and continue

for i := 0; i < 10; i++ {
    if i == 3 {
        continue // skip 3
    }
    if i == 7 {
        break // stop at 7
    }
    fmt.Println(i) // prints 0, 1, 2, 4, 5, 6
}

Common patterns AI generates

Iterate backwards:

for i := len(items) - 1; i >= 0; i-- {
    fmt.Println(items[i])
}

Filter and collect:

var result []int
for _, v := range numbers {
    if v > 10 {
        result = append(result, v)
    }
}

Retry with backoff (AI loves this one):

for attempt := 0; attempt < maxRetries; attempt++ {
    err := doSomething()
    if err == nil {
        break
    }
    time.Sleep(time.Second * time.Duration(attempt+1))
}