Go code, judged.

A goto loop with no sleep, no backoff, and no escape hatch because tries is incremented straight into the void never to be read again. This is a fork bomb wearing a function signature, and it'll hammer that endpoint until the heat death of the server.

Four discarded errors in five lines, ending in a json.Unmarshal you didn't even bother to catch. A missing file returns a zero-value Config and no complaint, so every typo in that path quietly becomes an empty config. It runs, which is the frightening part.

You built an `interface{}` tunnel that shits out `int` when you put in a `string` and calls that "processing." That's not type switching, that's a pipe that turns everything into a mystery meat surprise and dares the caller to guess.

You fired an infinite number of goroutines into a channel with no reader, which isn't a leak, it's a structural collapse of your entire runtime. That anonymous goroutine isn't a helper, it's a terminally ill orphan you keep producing and abandoning one line at a time.

A bare map shared across every goroutine is just a countdown timer with a nicer font. Go will hand you a concurrent map write panic at the worst possible moment and your users will get front-row seats.

Using `time.Sleep` to wait for goroutines is you guessing at physics with a stopwatch. The comment "they should be done by now" is a prayer, not synchronization.

Two errors, two `_`s, zero fucks given. You swallowed every failure mode like it's a competitive eating contest and shipped the leftovers as a Config.

A plain map guarded by nothing but optimism, and you just let every request goroutine perform surgery on it at once. Go's runtime will politely murder your whole process with a concurrent map write, and honestly it's earned.

You declared a nil map and went to town incrementing it like it owes you money. That panic isn't a bug, it's the runtime politely refusing to watch you write to imaginary furniture.

A global counter with no lock — every concurrent request races to Inc and the mutex is literally in another file's dreams. This will pass every test you throw at it right up until it doesn't, and the bug report will just say "wrong number sometimes."

You're concatenating `id` straight from the query string into `WHERE id = `, so congratulations on writing a SQL injection tutorial with a `row.Scan` error handling plan of "ignore it."

That `go func()` captures the loop variable like a toddler grabs candy — with zero understanding of consequences. And when `err` shows up, you pat it on the head and whisper "not today" while appending a nil `User` into the slice like it's a participation trophy.