Skip to main content
Text ready — video coming soon

Vibe coding and Code Literacy: read what you receive

Hello again. In the coding agents lesson, you saw what an AI agent can reach and how to limit it. Now let's look at what it hands back.

In this lesson, we'll:

  • describe vibe coding fairly, including where it works well;
  • read a short program an AI wrote, line by line;
  • find a decision inside it that nobody asked for;
  • name the skill that found it, and the mistake it prevents.

Why it matters: AI can now write a lot of working code. Whether that code does what you need is a separate question, and you are the one who has to answer it. This lesson shows you how.

Describe vibe coding fairly​

In February 2025, the AI researcher Andrej Karpathy described a way of working he called vibe coding. He accepted the AI's changes without reading them. When an error appeared, he pasted it back to the AI. He said this was fine for quick weekend experiments that he planned to throw away.

The name spread fast, because many people recognised the experience. And for small things, vibe coding often works. A personal tool, a quick page or a short program can come out working on the first or second try. I'm not going to pretend otherwise.

The trouble starts as the work gets bigger and the stakes get higher:

  • Security: a program that works can still let the wrong person in.
  • Data: a working app can save records in a way that loses or exposes them.
  • Scale: something fine for three users can break for three thousand.
  • Change: code that nobody understood becomes technical debt when it has to change.

So the problem is not that vibe coding never works. The problem is accepting work nobody has checked. That mostly goes wrong on bigger work with more at stake, where mistakes are expensive and the person accepting the work may not see them coming. But size isn't the only danger: even a five-line program can send the wrong amount to someone. What matters most is how much harm a mistake could do, and how hard the work is to check.

You may also hear the phrase AI slop: low-quality content made with AI, often in large amounts. In software, it means poor AI-written code. AI-written code isn't automatically slop, but the only way to tell is to check it.

Read a program an AI wrote​

Imagine the organiser types one line to an AI: show this month's committee total. Here is the kind of program that request can get back. An AI wrote it for this lesson:

# This month's committee total.
monthly_contribution = 1000
members = 3
total = monthly_contribution * members
print(total)

You already have the tools to read it, from the Python reading lesson. Let's go line by line:

  1. The comment says what the program is for: the committee total.
  2. monthly_contribution stands for 1000, the amount each member is due.
  3. members stands for 3.
  4. * means multiply in Python. So total becomes 1000 × 3.
  5. print shows the result.

When it runs, it shows:

3000

There is no error. The program ran and printed a sensible-looking number.

Now remember the committee's record. Member C has paid only 500 so far. The organiser wanted the total received, which is 2,500. This program never looks at what anyone paid. It works out the total due.

The program works, and it answers a different question. The request said "total" without saying which one, so the program picked one. A careful AI assistant might have asked you, "Do you mean the total received, or the total due?" But that only helps if you know the answer.

This program was written for teaching, so it can't tell you how often AI makes this exact mistake. It shows how easily the mistake can happen when a request leaves a question open.

How could you catch it? By reading the lines while knowing what the organiser needed, which is what we just did. Or by working out the right answer yourself first, and comparing it with the output.

You can download this program if you'd like to run it yourself later. You don't need to.

The skill that caught it has a name​

What you just did has a name in this book: Code Literacy: reading and judging code. It helps you decide whether to accept a piece of work and take responsibility for it.

Code Literacy means reading two things:

  • What the AI did: what it decided, what it changed, and what its checks showed.
  • The code itself, when a decision is hidden inside it, as it was here.

Notice how little Python it took: three names, one multiplication and a print. The hard part was knowing the committee's question well enough to see that the program had answered a different one.

Recognise vibe decisioning​

The bigger danger is not one wrong number. It's accepting decisions you never looked at.

I use the term vibe decisioning for making the decisions around software blindly: by feel, or by accepting whatever the AI chose without checking it or knowing what will follow. If the organiser had sent "3,000 collected" to every member, that would have been vibe decisioning. The code had no bug: it did exactly what its lines say. The mistake was the decision to trust it without checking.

I came to this term on my own, and later learned that the analyst David Pidsley had already used it in May 2025, with a narrower meaning: using AI to build models of business decisions. In this book, I use it in the wider sense above.

Accepting an AI's decision is not always a mistake. If you checked it, and it's better than your own idea, accepting it is sensible. The mistake is accepting it without looking.

See where your value is​

Other people can use similar AI tools, and some will have stronger ones. If all you add is a request that anyone could type, you give people little reason to choose your work. The AI's ability belongs to the tool. Your value has to come from what you understand and contribute.

Your value is what you add that the AI can't add alone. Here, that was knowing that the organiser needed the amount received: the answer to give if the AI asks, and the thing to check if it doesn't. On bigger work, it's judging designs, limits and risks while the work happens.

That's the difference between two words you'll meet often:

  • Development is producing the code that runs. AI has made this much cheaper.
  • Engineering is the judgment around it: deciding what to build, setting its limits, checking it and owning the result. AI can help with this too, but the responsibility stays with you.

On the right tasks, directing AI well lets you finish useful work faster. Checking takes time too, so count the whole job. Knowing the need, judging the choices and showing the organiser results they can trust gives you something valuable to offer alongside the code.

Check what you can now explain​

Without looking back, answer these:

  1. What did the AI's program calculate, and which lines tell you?
  2. Why is "it ran without an error" not enough to accept it?
  3. Name the four risks listed under "Describe vibe coding fairly", and explain how one of them could matter even when a program runs.
  4. What would vibe decisioning look like for the committee's organiser?

You found the hidden choice by reading. In the next lesson, we'll stop that choice from being made silently in the first place, by writing down exactly what the program must do.