[avin01]

If you are enjoying vibe coding, the biggest "aha" for me is realizing that software is mostly about managing state, data flow, and failure, not syntax.

Once you get how data moves, where state lives, and what happens when things break, a lot of the "magic" disappears. Learning basic debugging and reading stack traces also compounds forever, even with AI.

One thing that helped me: think a bit like a PM. Spend time crafting good prompts (use chatgpt for generating prompts and feed it to your AI coder ;) ) for ChatGPT/Claude/Cursor, ask it to generate docs and explain what it just did. Over time, patterns emerge and things feel less mysterious.

LLMs write code well, but they don't give you mental models. That part you still have to build.

[buschleague]

This is exactly right. The mental model gap is the real risk for AI-first builders. The code works until it doesn't, and when it breaks you have no framework for understanding why.

One thing that helped us: externalize the structure that experienced developers carry in their heads. Things like test driven development or wheel-and-spoke based file size limitations etc. are the distilled judgment of decades of software engineering. But if you've never written code traditionally, you don't know they exist.

We formalized these into enforced workflows. What I found pretty exciting about it, from an educational tool standpoint, is that the side effect was that new team members and vibe coders working within those constraints started absorbing the patterns themselves. They learn why tests matter because the system won't let them skip them and learn why file size matters because the system blocks them and forces decomposition etc.

[bnchrch]

This is an understate and often unsaid take. But its 100% right.

Its also why you'll hear many engineers opine over functional programming.

Most start by thinking about 1. What does a system do for me?

Then onto 1. What actions does a system do? 2. Where should files and folders live? 3. Where should services live?

and stop there.

But the true key is when you just think about how data moves through your system.

Then you learn to simplify.

No classes, no hidden state, just simple functions with an input and an output and nothing else.

Long story short: Think about your system in data, and learn how to keep your code super simple to help with that thinking