Ask HN: What would you recommend a vibe coder learn about how all this works?

IMHO, reading isn't enough, you must do it and experience issues that makes you go "what? How?".

But your question is so vague that there are a lot of answers.

There are a lot of stuff that can be considered big concepts : basic electronic, networking, OS, peripheral communication, compilers, language, algorithms, assembly/procedural/object/functional programming, and the whole world of "AI".

What do you want to know?

- why you shouldn't call .where() a million times in linq?

- how internal statistics tables are managed in Sql server to produce the execution plan, how to watch the execution plan?

- big endian vs little endian?

- how to use telnet to get an HTML page from a web server?

- why everyone thinks that their favourite language is the best?

- why is the first char in a string in pascal at [1] when its at [0] in a lot of other languages?

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.

Read the following books:

* SICP - Structure and Interpretation of Computer programs

* AOA - Art of Assembly language programming

* Hello Python - Think like a computer scientist

* The C Programming language - Kernigham and Richie

* Pick one more favourite language and a book in it - Rust, Golang, Scala, Java, Ruby, Python, Typescript etc

Use the AI to teach you. I’m similar not full coder, although tinkered since I started in early 2000’s with html in notepad :)

I made a /teach-me slash-command. Everytime I run into something I want to know about I run it. It launches a background subagent (forking context) that check (and updates) my ‘learning-profile.md’. I can pass additional requests, but otherwise it just deduces from context.

It then creates an explainer/lesson. And sends it to my kindle (using a custom created mcp) - so I can read it offline. Not breaking my flow.

I’ve never learned so much so quickly, about everything. It’s awesome.

I use the same mcp from phone apps. Everytime I want to learn something I just ask.

Also: learn about the GIT concepts (not commands). You’ll learn much quicker when you can mess up and retry ;)

I've been writing a new textbook for undergrads (chemistry domain focus), and think this excerpt is generally solid advice that is applicable here. Any feedback is welcome (textbook to be published gplv3 via GitHub). I appreciate I am on the conservative side here. The following is copy-paste of the final notes/tips/warnings in the book, copied from latex source with minimal edits for display here:

Rather than viewing AI as forbidden or universally permitted, consider this progression:

1. Foundation Phase (Avoid generation, embrace explanation)

When learning a new library (e.g., your first RDKit script or lmfit model), do not ask the AI to write the code.

Instead, write your own attempt, then use AI to:

• Explain error tracebacks in plain language

• Compare your approach to idiomatic patterns

• Suggest documentation sections you may have missed

2. Apprenticeship Phase (Pair programming)

Once you can write working but inelegant code, use AI as a collaborative reviewer:

• Refactor working scripts for readability

• Vectorize slow loops you have already prototyped

• Generate unit tests for functions you have written

3. Independence Phase (Managed delegation)

When you have the skill to write the code yourself but choose to delegate to save time, you are essentially trading the effort of writing for the effort of auditing. Because your prompts are condensed summaries of intent rather than literal instructions, the LLM must fill the "ambiguity gap" with educated guesses.

Delegation only works if you are skilled enough to recognise when those guesses miss the mark; if your words were precise enough to never be misunderstood, they would already be code. Coding without oversight is dangerous and deeply incompetent behaviour in professional environments.

Examples of use-cases are:

• Generate boilerplate for familiar patterns, then audit line-by-line

• Prototype alternative algorithms you already understand conceptually

• Document code you have written (reverse the typical workflow)

I highly recommend Andrej Karpathy's Deep Dive into LLMs like ChatGPT: https://youtu.be/7xTGNNLPyMI. It's a 3.5 hour general intro to the topic that I think does a great job of making sense of the tech and how it works under the hood, without needing to build up a foundation of math and programming.

Congrats on the journey and desire to learn.

There's different books or approaches to learn more depending on your needs.

It's usually useful to tailor things to whatever you already produce for others or consume for yourself because then you get the most of your feedback loop.

Can you share more about what you've tried so far, with what tools, or what feels the most fun or useful ?

Depending on your answers one might recommend things like

- https://automatetheboringstuff.com/

- land of lisp (comics and games with functional programming to intentionally separate you from vibe coding traditional tools)

- web related dev with different viz or presentation tools

useful concepts regardless will be, in my mind, unit testing and how to approach problems and breaking them down but it all depends on where you want to go.

I'm a CS professor at an undergraduate college. I'm currently teaching a class on AI coding for non-programmers and also using Claude Code for all the projects in my upper level courses. I'm also planning to update our first course in the fall to include an intro to agentic programming.

Here are some practical suggestions based on what I've seen with my students. To summarize: AI programming de-emphasizes the specifics of languages and frameworks but rewards having a good knowledge of systems and a careful, structured development process.

1. Do learn some by-hand programming in a standard language like Python. Even if you aren't looking at the AI-generated code, this will teach you the building blocks of software design - things like functions, classes, files, and data types - which will help you design more complex applications. The ability to look at a program and reason about what it's doing is a key skill.

2. The terminal environment if you aren't already using it. This will unlock additional levels of control and help you understand how agents use tools.

3. Architecture of the applications you're creating. If you're making web apps, for example, learn about the front-end and back-end, how they exchange information, how a back-end database works, etc. The key is not the low-level details of those things, but how an application is divided into parts that exchange data with each other. This knowledge helps you move from a general concept for an application to an actual design.

4. Related to that point: the concept of encapsulation in software design. This is the idea that each part of your system should be self-contained and exchange information with other parts through a well-defined interface. If a component is encapsulated, you can change its internal details without messing with the rest of the system. This is important for AI, because it allows you to carefully control the targets of your generations.

5. Specs-driven development. This is the evolution of vibe coding and is the main approach I teach now. Chat about the problem, then develop a detailed spec that describes the desired behavior. Refine that into a system design and detailed step-by-step task list with tests for each step. Working with the AI to compare design options is a great learning tool.

6. You don't need to learn much about algorithms unless you want to. Models are very strong at choosing and implementing all of the standard algorithms. Let these emerge naturally as you work on interesting problems.

Stop vibing and use your own brain. After you have learned enough and consider yourself a software engineer you can restart using AI-tools. Only then you will have enough knowledge and experience to review the output of those machines.

And don't you dare to ever open a pull request with AI generated code in any free and open source project.

This might sound condescending but I fully do not mean it to: learn programming.

Raw dog code on small projects while avoiding using AI, except to explain things when you get stuck.

Learn theory. Learn algorithms. Learn data structures. Learn about secure coding. All of these will help inform you, even if you stick with agentic coding.

Go as deep or as shallow as you want to.

If you want to go deep, read some of the classics (SICP, C book, Pragmatic Programmer, etc), but don't beat yourself up if you don't find them interesting. Most programmers haven't read those books either.

Why should you want to know?

Don't you mind about the future. Don't you try to think ahead. Save tomorrow for tomorrow. Think about today instead.

I could give you facts and figures. Even give you plans and forecasts. Even tell you where I'm going.

Reading The Language of Machines book and the Linux Programming Interface.

Teachyourselfcs.com is good too

you have to choose to keep vibing or learn to code. there's a possibility that programming might not matter and being good at vibing would be what matters. no one knows yet ... for now it does pay to know how to.

hello,

as always: imho (!)

recognize that software-engineering is not about writing / vibing code but to solve (!) problems.

nobody cares if the code which solves a problem is generated / copied / written ... as long as it was legally obtained ... ;))

anyway: code is liability, every line of code which was not written to solve a problem keeps future maintenance-costs low(er) ...

additionally especially for non-trivial problem-solutions - read: projects -, its essential to have maintainable code. which means, code that is ...

* easy to understand ~ new developers

* easy to extend ~ new features

* easy to sustain ~ update dependencies, update the underlying runtime-environment etc.

especially if it solves a complex problem for a company, the code may be used for years or even decades =?> keep that in mind!

just my 0.02€

I'd bet one has to figure out the neurology, college level mathmatics, and computer science theories before dive into how these neural networks work and all the nitty gritties.

There's two paths here.

Bottom up and top down.

Bottom up would roughly be 1. Picking a simple introduction to programming textbook ideally Python 2. Work through a building a transformer LLM in python 3. Move to training it on a corpus

You're not mastering each step. Reading the python book and doing some exercises is fine.

The top down: This 3Blue1Brown playlist will have you covered https://youtube.com/playlist?list=PLZHQObOWTQDNU6R1_67000Dx_...

Either way you want to meet in the middle. There is still a lot in the middle that isn't clear so don't try and work from the middle out!

There are institutes scattered around the world — “colleges” and “universities” — where people spend a lot of time thinking about what set of knowledge should be considered part of the baseline understanding of a subject. These are published as “syllabi”, “core courses”, “majors”, etc. I recommend finding a college or university you respect, a major that interests you (maybe “computer science” or “software engineering”), looking at the core courses for that major, reading each syllabus and coming up with a strategy to learn the material in it. The colleges and universities even offer help with that last bit!

Hi,AI tools just shifted the interface of programming from code to natural language. The tool you've been sharpening your whole career — words — is now the primary tool of software development. You're not a non-programmer learning to code. You're a native speaker arriving in a country that just switched to your language. And that's exactly why it's been "one of the most fun things you've ever done." We're always drawn to the things where our strengths quietly do the heavy lifting. Trust that signal. Keep going.

honestly the biggest thing that clicked for me was understanding how data moves around - like not in an abstract way but literally where stuff lives in memory vs disk vs network. once I got that everything else made more sense

I'd skip the heavy CS books tbh, they're written for people who want to be software engineers. what helped me more was just breaking things on purpose and reading error messages carefully. like really carefully - most of them tell you exactly what went wrong if you slow down

the other thing - and this sounds dumb but it's not - is learning to read documentation instead of always asking the AI. not because the AI is bad but because docs teach you the mental model of how the tool's creators think about it. that's the stuff that makes you go oh THAT'S what's happening

I think for vibe coding specifically, understanding APIs (what they are, how they work, why they matter) is huge. and basic HTTP stuff - requests, responses, status codes. you don't need to memorize it all but knowing the shape of it helps when debugging

The course on deeplearning.ai are a good starting point. Anthropic and OpenAI both have decent stuff on there, plus their own docs have examples.

The cornerstone of coding is the function. Study functions.

First of all, that’s great. That’s what I hope it would happen: non technical people using this tools, feeling the apart of “power” of coding, and feeling the desire to learn more.

About your question, it is hard to give one. I don’t think there is one big thing that makes everything click, and if there is one, it is probably different for different people. But I can give some advices.

1. You can ask the AI itself to explain how the code works. In my experience they are usually fine at that. You can probably tailor the explanation to your technical level, so that’s neat.

2. Stick to one language. I don’t know which language your AI is using for your tools (probably Python if they run on your machine or JavaScript if they work on a browser). Learning what you are using is the first step.

3. Once you know that, you can use the AI and some online guides to learn the very basics of the language. Maybe ask the AI for very simple toy tools (e.g., a web page where you write a phrase, click a button, and it will show that phrase with the words in reverse order) and try to understand what the code does. You may still ask the AI about the lines you don’t understand.

4. It is a potentially long journey. Go as far as you like. After these first steps, you will likely have more specific questions. That’s good. :)

>> The stuff that made you go "oh, THAT'S what's going on."

That comes from years of 70 hour weeks of hand coding!

What do you mean with "how all this works"? Do you want to know how program code works, or how LLMs turn natural language into code?

For the former, I think some hand coding will get the best results.

A large part of "thinking like a programmer" is thinking about the sort of invisible structures that code will produce in a computer's memory when it runs - which is not the same as what's literally written in the code file. IMO, the best way to get a feel for that is to write code yourself, run it, examine the results, etc.

But writing code can be a rather dry activity if you don't have motivation for what to write. The usual vibe coded projects are probably too complex to hand code without experience. I think two good starting points could be Code Katas [1] or the Pico8 game engine [2] (and of course any good "intro to Python" or "intro to JavaScript" tutorial on the web)

--

For the latter, you could maybe start with the history of generative text models (like markov chains) and neural networks. Both technologies are several decades old and sort of form the very basic building blocks that made development of LLMs possible.

In particular, neural networks made use of the gradient descent and backpropagation algorithms that are still the basis of most LLM training processes - even if they might now run for months and take exabytes of training data.

Then there is of course the "Attention is all you need" paper that introduced the Transformer architecture - the kind of latest-generation neural network that underpins most LLMs - and basically started the whole LLM revolution. (It's also the "T" in GPT)

(For historical interest, there is also the whole theory of formal languages/grammars and automata - which was the previous attempt to understand human language with computers. That theory gave us a lot of things - such as the Turing Machine and the entire theory of how to build and read a programming language. What it didn't give us though was a way to process human language...)

--

As for the specific question of how an LLM can take this request in human language and generate that code from it that happens to fullfill all the requirements - that's an active area of research and I honestly doubt that right now anyone understands that in all entirety.

Through I believe Anthropic and LessWrong had some interesting blog posts about this topics where they tried to understand the functions of certain specific neurons in an LLM. See also "Golden Gate Claude".

[1] http://codekata.com/

[2] https://www.lexaloffle.com/pico-8.php

do an online cs50 course

don't be a vibe coder

ask the vibe to explain in to you, unlike hunans it is very self-aware and patient teacher (albeit prone to say made up horseshit at times)

Honestly scrap AI and do tutorials. Then for each exercise try doing it in a blank folder with nothing to refer to. Then play with the code. Refer to docs only after trying. Yes, like Karate kid. Wax on. Wax off.

Use AI for building still. But have non AI sessions for learning. Good luck!

[dead]

I feel like we might have more to learn from you than the other way round. Where by "we" I mean the traditional programmers who frequent this place.