How does prototypal inheritance work?
Prototypal inheritance means that one object inherits behaviour from another object by holding a reference to it as its prototype. When a property is read and the object does not have it, the runtime looks along the chain of prototypes until it finds it. Nothing is copied, so the relationship between the two objects stays live.
The chain is built with the create method, which takes a prototype object and returns a new object whose internal prototype points at it. Setting the prototype property directly does the same thing, although the create method is preferred because it does not trigger the setters that a plain assignment can trigger.
The useful mental model here is delegation and not copying. The child object does not contain the parent's data at all. It contains a link, and every read that misses goes through that link. That is why the parent and the child stay in step with each other, and it is also why a deep hierarchy of prototypes makes lookups slower than a flat structure.
There are two consequences to be ready for. A method that sits on the prototype is shared by every object that inherits from it, so that is where you put behaviour that is common to a group. And because the prototype is just an ordinary object, you can add to it after the fact. That is how a lot of older libraries used to add methods to the built-in prototypes, and modern style guides advise against it, because it makes the behaviour of unrelated code unpredictable.