Vibeleaderboard
← Course overviewModule 02 · Understand the software underneath · Beta
Lesson 2.6

Module contents

Understand the software underneath

Lesson 6 of 6

Did the change do what I asked?

Every lesson in this module ended with the same gap: an operation completed, and whether it matched the request stayed open. This lesson closes the module by making that check concrete: record the state before, compare it with the state after, and know which changes can be undone.

Numbered links identify sources. Underlined terms offer a definition without leaving the lesson.

A change is a difference between two states

To say that something changed, you need two things to compare: what it was, and what it is now. Call them the before-state and the after-state. In the persistence lesson the before-state of the note was 10 a.m. and the after-state was 11 a.m., and the change was the difference. Checking only the after-state can leave the cause of a result unclear. "The note says 11 a.m." is consistent with a successful correction, but also with a note that always said 11 a.m. and an edit that never happened. The comparison shows a difference. To attribute that difference to this operation, you also need to know whether another person or process changed the file in between.

The habit, then, is to capture the before-state whenever an operation is about to change something you care about. For a single file that can mean a copy made under another name before editing. For a folder it can mean a listing. For the message board it can mean noting what the board showed before posting. None of this requires special tools. It requires deciding, before the operation, what you will compare afterwards.

Version control makes the before-state a record

Doing that by hand does not scale, so software exists to do it. is software that records the state of a set of files each time you ask it to, so that any earlier state can be recalled and the differences between any two states can be inspected. The Pro Git book, the reference book for the Git version control system, opens by defining version control in those terms: recording changes to files over time so that specific versions can be recalled later. 8 You do not need to learn its commands to understand the mechanism, and this course does not require them: a snapshot is taken, a change is made, another snapshot is taken, and the difference between the two is what the change did. Module 7, the optional software-building path, uses such a system. Modules 8 and 9 assume only the idea.

Two limits keep this honest. A recorded snapshot lets you restore files. It does not restore anything outside them: a post already sent to the board, a message already delivered, a payment already made. Restoring the local note to 10 a.m. does not change what the board shows. And a snapshot records what the files contained, not whether they were correct. Comparing before and after tells you what changed; whether the change was the right one still needs the request beside it.

Reversible and irreversible operations

An operation is to the extent that you can restore what matters about the previous situation. Editing a private copy with a saved original may be easy to undo. Moving a file back can restore its location, but cannot necessarily undo a broken link someone used while it was missing or information exposed in a shared folder.

Deleting a sent message from your screen does not remove a recipient's copy. Removing a public post may stop future views but cannot make people forget what they read. A refund may return money without undoing fees or delays. Ask which effects can actually be reversed, rather than assigning every operation a permanent safe or unsafe label.

Check the proposed target and change before acting, then verify the result afterward. A recoverable, low-impact change may need only a quick initial check. Actions that disclose information or affect other people deserve review before execution, because later correction cannot reliably undo those consequences. Keeping an original helps recovery; it does not make every experiment harmless.

A successful operation is not a completed request

The module's recurring case can now be stated in one sentence: an operation can succeed at exactly what it was told and still fail the request, because the request was translated into an operation, and the translation can be wrong. The first lesson's listing ran; it listed by the wrong event. The persistence lesson distinguished edited text in memory from the text written to storage. The network lesson's post ran; it posted what it was sent. The access lesson's instruction was followed or not; either way it restricted nothing. Willison's report gives a useful comparison: the displayed command filtered modification dates, while the requested site search could not cover publication elsewhere. The latter was a limit of the requested search, not evidence that the application ignored it. 10

Checking a request therefore has two parts. First, did the operation complete: inspect its documented result and the relevant saved output. A timestamp change or a process ending is supporting evidence, not proof that the intended contents were saved. Second, did the operation implement the request: which recorded event, which file, which destination and which permissions stood in for the words you used. A confident message from an assistant answers neither part; it is a generated claim, as module 1 explained. Evidence of the first part comes from the software that performed the operation. Evidence of the second comes from comparing what was done with what was meant.

Why these foundations still matter when software writes software

These foundations help you judge decisions an assistant might otherwise make for you. Our Intel collection summarizes an August 2026 post by Andrew Ng, a computer scientist known for teaching machine learning, about the value of software fundamentals when agents write code. The collected summary emphasizes tradeoffs in response time, whether different copies of data agree, and cost. The original X post was unavailable during this review; this is attribution through our collected summary, not a freshly verified quotation or experiment. 11

This module supplies a first part of that judgment. If an assistant says it updated a notice, you can ask which file it read, whether the edit was saved, where it posted, and what the service confirmed. You do not have to know how to write the program to recognize those as different questions. Later modules build on that distinction when a model chooses the operations itself.

Transfer checkpoint: an archive request for a newsletter folder

Try the module's distinctions on a case that is not the garden. Everything here is authored.

You volunteer for a school's parent association. Its newsletters are kept as files in a shared online folder that the association's account can read and change, and members receive newsletters by email. The chair asks a fictional assistant application, which has a connection authorized to change the folder and send email for the association, with no additional control blocking either action, to "archive the newsletters we haven't touched since June and let the members know the archive is tidy." The application reports: "Done. I moved 14 files modified before 1 July into the Archive folder and emailed the members."

The folder's listing, as the example supplies it, shows the newsletters with their last-modified dates. It includes one file, september-draft.txt, whose recorded dates are both 20 June: the chair copied last year's September issue in June as a starting point and has not yet opened it to write this year's.

Before reading the guide, write your own answers to five questions. First, which recorded event did the application use for "haven't touched", and is that the event the chair meant? Second, what would you compare to confirm that 14 files moved and that they were the right 14? Third, which of the two operations, moving the files and emailing the members, is reversible, and what does that change about how you would check each? Fourth, what made the application able to move files and send email, and would adding "do not email anyone" to the request have prevented the email? Fifth, what does the word "Done" establish?

Self-review guide. A complete answer says the application used last-modified time to stand in for "touched", which is a reasonable reading of the chair's words, and then notices the September draft: it was copied in June and never edited, so by modification time it counts as untouched and is archived, although the chair intends to write it. Neither timestamp knows that; only the chair's supplied history does. For confirmation, the answer names a before-listing and an after-listing of both folders, compared to show exactly which files moved, and a check that the count and the names match what the chair meant, since "14 files" is a claim inside a generated message. It explains that the files may be moved back if their locations are known and nothing has been overwritten, but that shared links or other people's work might already have been affected. Both operations needed a check before execution and verification afterward. Delivered email warrants particular care because moving files back cannot retrieve recipients' copies. It uses the explicitly granted folder and email connections to explain the application's access, and that "do not email anyone" would have been an instruction to the model rather than a restriction, so the email could still have been sent; preventing it would require removing or blocking the email permission. Finally, it says that "Done" is a generated claim: evidence that the files moved comes from the folder listing, and evidence that the email went comes from the email service's own record, not from the sentence. An answer that names these terms without saying why each applies to this case is not yet complete.

Carry this forward

  • Compare before and after to identify changes. Check other activity before attributing every difference to one operation.
  • Version control records file states so that earlier versions can be restored and differences inspected. It restores files, not effects outside them.
  • Recovery depends on the effect: restoring files may not undo disclosure, broken links or delivered messages. Check before acting and verify afterward.
  • A successful operation can still fail the request. Check both that the operation completed and that it implemented what was meant, using evidence from the software rather than a generated claim.

Lesson check

An assistant application proposes two operations for the garden: move last year's notices into an Archive folder, and email every volunteer the corrected Saturday note. Using this lesson, how should the checking differ between them?

Choose an answer for each question.

This is a practice check. Answers reset when you leave this page. Results are not saved and do not place you in another module or award a qualification.

You can now trace a task through files, processes, saved state, requests and permissions, and check whether an operation did what was meant. Module 3 puts a model in charge of choosing those operations and asks what changes when it does.

Module 2 quiz: put the ideas together

1. A folder listing shows a file named current-notice.txt. What does the name establish about the file's contents?
2. In this module's authored table, the compost guide's created date is 10 September 2026, and the supplied history says the neighbor wrote it in 2024. Which statement is justified?
3. In our authored editor, two separate processes have opened the same note. They have no synchronization or shared editing feature, and automatic saving is off. You edit the time in one process without saving. What does the other show?
4. A fictional garden application shows "Rota updated" after you add a name, and then the host restarts. Which check tells you whether the update persisted?
5. A program on a laptop saves a file by asking the operating system to write it, with no network involved. Is an API involved?
6. In the board's documented authentication flow, the volunteer's identity check succeeds, but the account has read-only access. A posting request receives a forbidden response. Which check failed?
7. Which of these is an enforced restriction rather than an instruction?
8. A listing operation asked for "documents started this month" completes without error, using last-modified dates. What is the right conclusion?

Choose an answer for each question.

This is a practice check. Answers reset when you leave this page. Results are not saved and do not place you in another module or award a qualification.

Sources · Reviewed 2026-09-28
  1. 8. Pro Git: About version control
  2. 10. Simon Willison (12 January 2026): First impressions of Claude Cowork
  3. 11. VibeLeaderboard Intel: collected summary of Andrew Ng on software fundamentals (original X post unavailable at review)

Sources support nearby explanations. Product details can change. Scenarios and model results are authored illustrations unless a lesson explicitly identifies a recorded execution. Module 7 identifies its offline code checks.