Even as a fast dev, I wasn't fast enough for my ideas. Then came Vibe Coding

[derverstand]

The Speed Trap of Modern Dev

I’ve always been a fast developer. I know my stack, I know my shortcuts. But there was still a painful latency between my mental architecture and the screen. My ideas always outpaced my output. No matter how fast I typed, the "Implementation Friction" was a tax on my creativity.

The 10x Shift: Moving at the Speed of Thought

Vibe Coding didn't just make me "better" — it removed the mechanical bottleneck. I’m no longer translating thoughts into code; I’m describing the vibe of the system and watching it manifest.

The Result: I’m building things alone that previously required a dedicated team or a month-long sprint.

The High: The dopamine hit isn't just about "it works." It’s the rush of zero latency. It's the feeling of your brain being directly plugged into the compiler.

The "Dark Side" of Hyper-Flow

But here’s the rub: When you remove the friction, you remove the "sanity check."

The Addiction: The feedback loop is so fast that it becomes a slot machine. Each prompt is a pull of the lever. Because I'm fast, I can pull that lever 100 times an hour.

The Loss of Friction: Typing was a form of "slow thinking." It forced me to vet my own architecture while my fingers moved. Now, I’m building at the speed of light, but am I outrunning my own ability to reason about the system?

The speed is a drug, and I'm fully addicted. For the first time in my career, my output matches my imagination. But as the friction of implementation hits zero, the value of 'knowing how to code' is being replaced by the value of 'knowing what to build.' If you could manifest any system in an hour, would you actually know what to build, or would you just get lost in the 10x dopamine loop of pure iteration?

[kgwxd]

Shouldn't even be typing code while planning. There's no software idea that needs to be coded as it's planned. It's just a waste of time, and potentially harmful. The devs I've worked with that "think" in classes, or tables, or whatever code structure they're most comfortable with, inevitably end up creating garbage in the first 10 minutes that ends up lasting the lifetime of the project, confusing the hell out of everyone that looks at it, including themselves a week later.

[TimSchumann]

This reads like it was written using a prompt.

[gregjor]

[flagged]

[dang]

"Don't be curmudgeonly. Thoughtful criticism is fine, but please don't be rigidly or generically negative."

https://news.ycombinator.com/newsguidelines.html

Also, please don't cross into personal attack. That is in no way allowed here.

[derverstand]

You’re fair to call out the wording. I agree some of it reads more buzzword-y than intended.

My point wasn’t that thinking fast is inherently good or that coding is “drag.” Quite the opposite: the friction of implementation used to be a form of thinking time for me. Typing forced pacing and reflection.

What I’m noticing now is that when iteration becomes extremely cheap, the bottleneck shifts from “can I build this?” to “should I build this?” That’s not about hyperactivity. It’s about decision quality.

The “dopamine” part wasn’t meant as a brag but as a caution. Fast feedback loops can encourage shallow iteration instead of deeper design if you’re not careful.

So if anything, I’m arguing for more deliberate thinking, not less.