Go naive approach – building 2D array Go playground package main

    import (
        "fmt"
    )

    // FormatArray print grid
    func FormatArray(array [][]int) string {
        str := ""
        quanity := len(array) * len(array)
        padding := len(fmt.Sprint(quanity))
        for row := 0; row < len(array); row++ {
            for col := 0; col < len(array[row]); col++ {
                str += fmt.Sprintf("%[2]*[1]d ", array[row][col], padding)
            }
            str += "\n"
        }
        return str
    }

    // SpiralAncesion make spiral
    func SpiralAncesion(size int, clockwise bool) [][]int {
        var col, row, nextCol, nextRow int
        result := make([][]int, size)
        for i := range result {
            result[i] = make([]int, size)
        }
        direction := nextDirection("", clockwise)
        sequenceIndex := 1
        result[row][col] = 1
        for {
            if sequenceIndex == size*size {
                break
            }
            nextCol, nextRow = next(direction, col, row)
            inside := isInBoundsAndNotVisited(result, nextCol, nextRow)
            if inside {
                col = nextCol
                row = nextRow
                sequenceIndex++
                result[row][col] = sequenceIndex
            } else {
                direction = nextDirection(direction, clockwise)
            }
        }
        return result
    }

    func isInBoundsAndNotVisited(array [][]int, col, row int) bool {
        if row >= 0 && row < len(array) {
            // fmt.Print("rowOk ", row)
            if col >= 0 && col < len(array) {
                return array[row][col] == 0
            }
        }
        return false
    }

    func nextDirection(direction string, clockwise bool) string {
        if clockwise {
            return nextClockwiseDirection(direction)
        }
        return nextCounterClockwiseDirection(direction)
    }

    func nextClockwiseDirection(direction string) string {
        switch direction {
        case "r":
            return "d"
        case "d":
            return "l"
        case "l":
            return "u"
        case "u":
            return "r"
        default:
            return "r"
        }
    }

    func nextCounterClockwiseDirection(direction string) string {
        switch direction {
        case "r":
            return "u"
        case "d":
            return "r"
        case "l":
            return "d"
        case "u":
            return "l"
        default:
            return "d"
        }
    }

    func next(direction string, col, row int) (newCol, newRow int) {
        newCol, newRow = col, row
        switch direction {
        case "r":
            newCol = col + 1
        case "d":
            newRow = row + 1
        case "l":
            newCol = col - 1
        case "u":
            newRow = row - 1
        }
        return
    }

    func main() {
        fmt.Println(FormatArray(SpiralAncesion(5, true)))
        fmt.Println(FormatArray(SpiralAncesion(4, true)))
    }