Consider a function your team shares: average(scores). Its interface says: give it a list of numbers; it returns their mean; if the list is empty it returns 0 instead of crashing. That is everything a caller needs. Whether the function adds the numbers with a loop or a built-in sum is hidden. You can call average([80, 90, 70]) and get 80 without ever seeing the code.
The hiding is the point. Suppose the author later rewrites average to handle a million scores faster. Every call to average([80, 90, 70]) still returns 80, so no other code has to change. But if the author changes the interface itself, say the function now needs a second input for the number of decimal places, every call written as average(list) breaks at once. An interface is a promise, and breaking the promise means updating every caller.
A user interface is something else. The buttons and screens of an app are the meeting point between a person and the program; a software interface is the meeting point between two pieces of code, and no user ever sees it. The same word is used because both are boundaries. Unit tests are different again: they check that the code behind an interface keeps its promise, while the interface is the promise itself.
Think of it like this. An interface works like a restaurant menu: it lists what you can order and what will arrive, and you never see the kitchen. The chef can change the oven or the recipe and your order still comes as described. Change the menu itself, though, and regulars who order their usual dish are suddenly stuck.
Core idea. Good interfaces make modules easy to use, test, replace, and understand.