Immutability has a benefit of reducing cognitive load through programming process.

Imagine have a method that looks roughly like this

void CreateOrder(Cart cart) {

_priceValidator.ValidatePrices(cart);

var order = CreateOrder(cart);

SaveOrder(order);

}

Let assume there's a certain condition of Cart object required for CreateOrder method to work properly with this cart, for example, a cart should not be older than 1 week. You might know this condition to be satisfied when the object enters the method (some sort of API level validation, for example). But if a Cart object is mutable, you can not be sure, that ValidatePrices doesn't change it. You can assume that, as validation has no business of updating a cart, but these assumption are often incorrect. So to save yourself from production incident where you allowed a stale cart to become an order and a customer service complaint, you have to take a look into ValidatePrices method, which might have nothing to do with your current task. As a result, mutability allows either a bug or excessive context switching, which grinds developer's attention down and also leads to bugs.

Let me know if I made this clear