This might be a subtle thing to point out, but I believe it lies at the heart of understanding the difference between agile and waterfall:
But, in the middle of development, someone changes their mind about what to add to the program (for example, add a feature that lets users add not only text, but also videos and images to their notes)
In agile, someone didn't change their mind. They just specifically hadn't made up their mind yet, because they hadn't yet gotten to the note-content-building stage.
They hadn't yet gone through the process of locking down the requirements, doing the technical analysis, and preparing to implement the note content certain way, before then "changing their mind". Even if they had an initial idea and now have a different idea, they don't need to redo a whole lot of documentation on the initial intentions, because they didn't lock the first idea down ahead of time.
They simply deferred the decision on what the note's content should be until the time when they actually needed to build it. The reason they deferred it is because their future selves would have more knowledge than their past selves (i.e. early user feedback based on an early release), and therefore their future selves would be more likely to make the right call.
But Waterfall also lets you do the same thing (go back to the design and then write the code for it)
Waterfall has you design the whole thing before you've written the code, let alone deployed it and asked for user feedback. In a waterfall process, someone would have definitely already locked in what content a note should contain, done the technical analysis, and prepared for the codebase to be built a certain way.
That's not to say that waterfall processes don't allow for building change-friendly codebases, but the end result here is that if you go back to the drawing board on what a note should contain, then you will have wasted effort on how you designed this the first time (which you're now overwriting with new requirements).
By not deferring the analyses (requirements and technical), you run the risk of prematurely locking something down and then needing to revisit it when you have future knowledge of things you weren't aware of at the original time.
then Agile would allow developers to go another cycle to implement that feature.
I just want to point out here that if an agile process had already delivered the first version of the note content, then the cost of going back and revisiting note content is the same regardless of whether you're working with agile or waterfall.
We can argue that agile generally puts more pressure on having a change-friendly codebase and whether or not that distinction matters for the above statement. For an identically written codebase regardless of using agile or waterfall, the above statement is correct.
The only time agile prevents you from wasting time and effort is when you end up changing your mind after the dev work has already started (and/or after a version was already released) and before you got to the part that you've now changed your mind on.
If it helps, you can define agile as a series of consecutive waterfall processes, but only if those waterfall processes do not attempt to guess at what future iterations will need to contain. The expectation of being able to predict the future is what sets waterfall apart from agile.