In Stability We (T)Rust

I’ve been thinking about trust a lot. Trust is desirable to many of us, since it reflects a state in which we can rely on one another in future actions. Trust helps us eliminating options: When we follow the trustee, we don’t have to find out for ourselves the consequences of all other choices. And, trust is stronger than contracts. In modern kindergartens (and team building events, occasionally), kids learn the concept of trustworthiness by letting themselves fall backwards until another child catches them so nobody gets hurt. This requires -amongst other capabilities- trust from both the falling and the catching.

In Stability We (T)Rust

In some cases, however, people seem to derive trust not so much from the actions of others rather than from the stability of their environment. They have trust in -say- their group, because the group remains stable – the group members continuously perform the same kind of work, apply the same level of skills, use the same procedures and tools and keep moving at the same pace. So when any member of the group returns from vacation, the place will be still cozy and pretty much as expected, because change happens at the speed of the continental drift.



Biologists call this homeostasis – a state in which a system tends to maintain an equilibrium by inventing its own regulatory mechanisms. I assume that in an organization those mechanisms can be supportive (e.g. positive, progressive team spirit) but also very harmful (when somebody who wants to try out new things is treated as an outlaw, for example). However, I am not a biologist. Therefore, I use a different term for it. I call this rust.

Rust is something that creeps in and corrodes working mechanisms until they come to a full standstill. You recognize rust when you see it. It can ruin even the most sophisticated machines. Rust is a bit like moss on a tree. Trees cannot shake off the moss, but have you ever seen moss on a cheetah?

Trust Has Nothing To Do With Yesterday

Quite often trust is being mixed up with experience. The latter usually reflects learnings from previous actions – very helpful in many cases, but probably useless for the next step. The difference between experience and trust can be illustrated by picturing a 150 year old ropeway over a canyon: It has worked for quite some time… Wanna try?

Trust is something different: it is forward-facing and future-oriented. Trust is required when things change, not when everything is stable.

On one side, you can always trust in your own capabilities (free solo mountaineers are good at it). But the stronger aspect of trust is that it is a mutual concept. When employees ask for trustworthy leaders, they must ask themselves at the same time how trustworthy they are themselves – and vice versa. If you want to rely on co-workers, you must be reliable in the first place. Face it.

I actually believe that what you entrust others with tells more about yourself than it does about the trustee.

Please let me know what you think.

2 responses to “In Stability We (T)Rust

  1. Nice idea to compare types of trust with (t)rust. But still trust needs to be earned and that is only possible given some time. If there is no history, no prior knowledge, how could I trust anybody? Well I could trust blindly, which is dangerous as well. I agree that stability is not creating trust, but actions do. Then, as soon as trust is established, it is forward-facing, but is evaluated while things happen all the time.

    • Hi Peter,

      I appreciate your feedback and yes, time does matter. I also agree that the actions make the difference. Therefore it is crucial to close the gap between announcement and execution.



Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s