In almost every piece of online or offline communication you have in regards to a code base, the user should be the most important thing. The purpose of our work is to fulfill the expectations of the user and deliver to them a user experience that is intuitive and functional. This is relevant, regardless of whether our end-product is a piece of consumer software or a developer API. The user remains our priority. It is, however, incredibly common to find ourselves in situations where there is a decision to be made and we don't know how to make it; we end up relying on gut instinct or our own biased beliefs. Consider the following:

• Of course users should have to fulfill our password strength requirements
• Of course our API should be strictly type-checked
• Of course we should use a dropdown component for country selection

These may seem like fairly unobjectionable statements, but we should always seek to qualify them from the perspective of the user. If we cannot do this, then there's a strong possibility that the decision holds no water and should be challenged.

For each of the preceding statements, we can defend our reasoning as follows:

• Of course users should have to fulfill our password strength requirements: Users with stronger passwords will end up being more secure against brute-force password attacks. While we as a service need to ensure secure storage of passwords, it is the user's responsibility, and very much in their interest, to ensure a strong password. 
• Of course our API should be strictly type-checked: A strictly type-checked API will ensure that users get more informative warnings about incorrect usage and can thus reach their desired goal sooner.
• Of course we should use a dropdown component for country selection: A dropdown is an established convention that users have come to expect. We could always augment this with an autocompletion feature as well.

Notice how we are expanding upon our of course statements with reasoning that relates specifically to the user. It's easy for us to walk around making assertions about how things should be without actually backing up our claims with strong reasoning. Doing this can lead to pointless and badly argued opposition. It is better to always reason about our decisions from the user's perspective so that, if there is an argument, we are arguing based on what's best for the user and not merely what opinions are most popular, or held most strongly. Always explaining from the perspective of the user also helps to instill a culture where we and our colleagues are constantly thinking about the user, regardless of whether we're programming a deeply specialized API or developing a generic GUI.