Vibe Coding Club

Join the course Discord: https://discord.gg/t3ZHEjX4hn

Vibe Coding: Programming by Vibes, Verification by Necessity An experimental seminar on programming with large language models, coding agents, and questionable amounts of confidence.

Large language models are rapidly changing how programmers write, understand, debug, test, and maintain software. Modern coding agents can do considerably more than autocomplete a line of code: they can inspect repositories, propose designs, modify several files, run tests, diagnose failures, and sometimes produce an entire implementation from a natural-language description.

This course asks what happens to programming when writing the code is no longer necessarily the programmer's main activity.

Rather than treating AI-assisted programming simply as a new tool to learn, we will use vibe coding as an excuse to investigate some fairly fundamental questions in computer science and software engineering:

What does it mean to program when much of the implementation is generated for you? How precisely do we need to describe what we want? How can we tell whether generated software is actually correct? Can we safely work in languages, frameworks, or domains we barely know? Does AI make good programmers better, inexperienced programmers more capable, or everyone merely more confident? What happens when an AI agent gets access not only to the source code, but also to the shell? And, perhaps most importantly: if producing code becomes cheap, what becomes expensive?

The course will be practical, experimental, and somewhat unpredictable. This is intentional.

What we will do A substantial part of the course will consist of experiments, demonstrations, discussion, and attempts to make current AI systems succeed or fail in interesting ways.

Topics and activities will include:

Experiences from actual AI-assisted programming Students will present and compare their own experiences using AI for programming: in previous courses, exercises, projects, summer jobs, or personal work.

We are interested in both successes and disasters.

In particular: what did the AI do well, what required human expertise, and when did it confidently produce something that looked entirely reasonable and was nevertheless wrong?

Vibe requirements engineering We will investigate what happens when increasingly precise descriptions of a software system are given to an AI.

We will compare vague prompts with more traditional software-engineering artefacts such as:

requirements; user stories; examples; invariants; interfaces; acceptance criteria; tests; contracts and formal specifications.

One possible conclusion is that sufficiently advanced prompt engineering begins to look suspiciously like requirements engineering. Vibe algorithms Pål will attempt live algorithm programming with an AI system, thereby risking professional embarrassment for educational purposes.

The class will attempt to predict where the model will fail, design counterexamples, and determine whether apparently plausible solutions are actually correct.

We will pay particular attention to situations where the generated implementation looks convincing enough that a human programmer might stop checking.

Vibe theorem proving Håkon will investigate whether theorem proving can also be performed primarily through vibes.

Among other things, we will compare workflows such as:

informal problem → program → attempted proof

with

informal problem → formal specification → program

and see whether involving formal methods makes the whole enterprise more or less absurd.

Verification: the inconvenient part Generating code is easy. Knowing whether it works is harder.

We will investigate how AI-generated software can be checked using:

unit and integration testing; property-based testing; fuzzing; static analysis; type systems; assertions and contracts; code review; formal verification.

We will also consider the slightly alarming possibility of having one AI generate a program, another generate the tests, and a third assure us that everything looks excellent.

Vibe debugging Given a broken program, should we simply paste the error message into an AI and repeatedly say fix it?

Probably not.

We will compare different approaches to AI-assisted debugging, including hypothesis-driven debugging, instrumentation, test-case reduction, automated diagnosis, and autonomous agent workflows. Vibe archaeology Future programmers may spend less time writing new code and more time understanding code that nobody currently present remembers writing.

Students will therefore practice using AI to investigate unfamiliar codebases: recovering architecture, identifying assumptions, locating bugs, and reconstructing the intended behaviour of software they did not write.

Programming in things you do not understand Can an experienced Java programmer use an AI assistant to produce reasonable Rust? Haskell? Prolog? CUDA? Assembly?

Probably.

Can the same programmer recognise when the resulting Rust, Haskell, Prolog, CUDA, or assembly is nonsense?

That is a different question.

We will explore how far AI can extend a programmer's reach into unfamiliar technologies, and where missing domain knowledge becomes dangerous.

Vibe visualisation In collaboration, we hope, with someone from the visualisation group, we will investigate AI-assisted data visualisation.

Visualisation is an especially interesting case because humans can often recognise that the output is poor without being able to articulate precisely how the corresponding program should be changed.

This gives us an opportunity to explore iterative natural-language steering as an alternative programming interface.

Coding agents Chat-based programming and autonomous coding agents are not quite the same thing.

We will experiment with agents capable of reading repositories, editing files, running tools and tests, and iteratively responding to the results of their own actions.

This raises both technical and methodological questions:

How much autonomy should an agent have?

When should a human intervene?

And what could possibly go wrong if we give an LLM a shell?

Security: both weapon and target AI systems can help find vulnerabilities, reason about suspicious code, propose fixes, and generate tests.

They also introduce entirely new opportunities for things to go wrong.

We will look at both sides, including:

AI-assisted security review; insecure generated code; prompt injection; malicious instructions embedded in repositories or data; tool misuse; credential and information leakage; excessive agent permissions; the general principle that giving an easily confused language model access to powerful tools deserves some consideration.

Vibe architecture and long-term maintainability LLMs are often extremely good at making something that works right now.

Software engineering, inconveniently, also involves what happens six months later.

We will examine larger AI-generated systems for architectural drift, duplication, inconsistent abstractions, dead code, dependency problems, and accumulated layers of fixes.

We may also ask the AI responsible for the mess to clean it up. Humans, agents, Git, and chaos What happens when several programmers collaborate while each is also delegating work to one or more coding agents?

We will experiment with AI-assisted teamwork, code review, division of labour, competing implementations, merge conflicts, and possibly the discovery of entirely new ways to misuse Git.

Vibe teaching The course itself will also serve as an experiment in AI-assisted teaching.

We will use LLMs to help:

explain concepts; generate examples; devise exercises; predict misconceptions; act as tutors; critique solutions; and occasionally help plan the teaching of the course about using LLMs to help plan things.

Students will be encouraged to evaluate not merely whether an answer is correct, but whether the AI is actually teaching well.

Yes, this course description was also drafted with an LLM¹. It seemed inappropriate not to.

¹ ...and posted without reviewing it first, of course.

Vibe News The field changes too quickly for a fixed syllabus to remain completely current for an entire semester.

We will therefore reserve a short part of the course for Vibe News: notable developments in models, tools, coding agents, research, security, and other relevant events since the previous meeting.

Students and instructors will share discoveries about which systems currently seem good at particular tasks—and, equally importantly, what they are surprisingly bad at.

Any statement of the form “Model X is clearly the best at Y” should be assumed to have an unusually short half-life.

Possible experiments Depending on time, interest, and how much access we have to suitable models, activities may include:

The Vibe Off: several models solve the same programming problem and we compare the results. Prompt Golf: find the smallest instruction that reliably produces the desired behaviour. The Fixed-Budget Programmer: build the best solution possible with a limited AI/API budget. The Malicious Customer: attempt to specify a system in ways that encourage plausible but incorrect interpretations. The AI Code Review Trap: locate a subtle bug hidden inside otherwise polished generated code. One-shot vs engineering: compare “build the whole thing” with careful decomposition, testing, and iteration. No Human-Written Code Day: humans may write prompts, specifications and tests, but not implementation code. No AI-Written Code Day: the AI may analyse, explain and review, but the humans must write every line of implementation themselves.

Learning outcomes After completing the course, students should be better able to:

use contemporary AI programming tools effectively without depending on any particular product; formulate programming tasks, requirements, constraints, and acceptance criteria clearly; critically evaluate AI-generated code and technical explanations; select appropriate techniques for testing and verifying generated software; recognise common failure modes in AI-assisted programming; reason about the security implications of coding agents and tool-using LLMs; use AI to understand and maintain unfamiliar software; distinguish increased output from increased productivity; and make informed decisions about what should be delegated to an AI system and what still requires human judgement.

The course does not assume that vibe coding is good, bad, inevitable, revolutionary, fraudulent, or the end of programming.

Those are empirical questions.

We intend to poke them with a stick.

Practical philosophy Students should expect the exact tools used in the course to change. Model names, interfaces, capabilities, prices, and fashionable terminology are likely to become outdated faster than the underlying course material.

The aim is therefore not to become an expert user of one particular AI system.

Instead, the course focuses on skills that remain relevant when the next model arrives:

specification, decomposition, experimentation, verification, debugging, critical judgement, and understanding what the computer is actually doing.

Or, in slightly more contemporary terminology:

vibes are permitted; epistemology is compulsory.