Shirky’s Law states that the social software most likely to succeed has “a brutally simple mental model … that’s shared by all users”.

If you use social software like Flickr or Digg, you know what this means. You can give friends a simple and compelling explanation of these sites in seconds: “it’s a website that lets you upload photos so your friends can also see them”; “it’s a community website that lets you suggest interesting sites; the users vote on submissions to determine what’s most interesting”. Of course, for each Flickr or Digg there are hundreds of failed social sites. The great majority either fail to obey Shirky’s Law, or else are knockoffs that do little not already done by an existing site.

To understand why Shirky’s Law is important, let’s look at a site where it’s violated. The site is Nature Network, one of the dozens of social networking sites aspiring to be “Facebook for scientists”. Like other social networks, Nature Network lets you connect to other users. When you make a connection, you’re asked whether you would like to connect as a “friend” or a “colleague”. Sometimes the choice is easy. But sometimes it’s not so easy. Furthermore, if someone else connects to you, you’re automatically asked to connect to them, but given no immediate clue whether they connected as a friend or as a colleague. The only thing shared in the users’ mental model at this point is acute awkwardness, and possibly a desire to never connect to anyone on Nature Network again.

I don’t mean to pick on Nature Network. It’s the most useful of the social networks for scientists. But it and most other social websites (apart from the knockoffs) don’t even come close to obeying Shirky’s Law.

Why is Shirky’s Law so hard for developers to obey? I’ll give three reasons.

The first reason is that developers often have a flawed mental model of their own software. Imagine you’re developing social software. You spend hundreds or thousands of hours on the task. In your mind’s eye, you imagine the user interacting with your software, and reason that if the user is given more capabilities, they’ll be happier.

There’s an implicit mental model being used to make decisions here. It’s a mental model of a system with two parts – the software and the user. A real user’s mental model is quite different. It’s them, the software, and the entire network of other users. How they use the software is strongly conditioned on their mental model of how other users use it. If they lack confidence in that mental model, they have less incentive to use the software themselves, as the Nature Network example shows. The more social the software, the stronger this effect.

Most developers are not stupid, and intellectually they know the user experience involves both the software and the network of other users. But their own experience, day in and day out, is of being a single user working with the software. At this stage the network of other users is a theoretical abstraction. It’s easy to get sucked into doing things that would make a single user’s experience better, but makes the experience of a network of users worse. This is a large part of why it’s so important to build a base of beta users as quickly as possible, and to release early and often.

A second reason developers fail to obey Shirky’s Law is the desire to do impressive-seeming things. Software that looks complex is much more impressive to other hackers, venture capitalists, and non-hacker friends and family.

I’ve heard hackers brag that they could have built Twitter over a weekend. Underlying this boast is a misunderstanding of what is truly impressive. Coming up with Twitter required only a small amount of technical knowledge. The hard part was the social insight to realize such a tool would be useful. This is a social insight the bragging hackers didn’t have.

It’s no accident that many of the people who’ve been most successful at building social software have strong interests outside computing. Mark Zuckerberg, the founder of Facebook, studied both computer science and psychology at Harvard. Alan Kay, arguably the father of modern computing, has a list of recommended reading. There’s barely a technical book on it. It’s all psychology, anthropology, philosophy, and so on.

A strange consequence of all this is that much of the most successful social software was invented by accident.

Ward Cunningham invented the first wiki because he was tired of responding to user’s requests to update a website he ran. To save himself time, he made the page editable, and told them to update it themselves. He was shocked when this small change utterly transformed the dynamics of the site.

One of the first widely used pieces of blogging software, Blogger, was originally a small part of a much more ambitious project management system. The project management system never caught on, but Blogger took off.

The team that developed Flickr wasn’t originally building a photo sharing service. They were building a multiplayer online game, and decided to let players share photos with one another. When they realized the players were more interested in sharing photos than playing the game, they dumped the game, and built Flickr.

Shirky’s Law does not mean the software itself needs to be simple. Social software like Digg and FriendFeed uses complex algorithms to rank the relative importance of submitted items. But the complex parts of the software are hidden from the user, and so do not add to the complexity of the users’ mental models.

There are some apparent exceptions to Shirky’s Law. For example, Facebook is now a successful and complex piece of social software. But in the early days, Facebook was extremely simple, and this simplicity fueled their rapid growth: “it’s a site where you can connect to your friends, and show them what you’re up to”. Complexity can only come later, when users are already confident in their shared understanding.

The third reason developers fail to obey Shirky’s Law is that it’s difficult to do. The most successful social software starts out doing one task supremely well. That task is simple, useful, and original. It’s easy to come up with a task which is useful and original – just combine existing ideas in a new way, perhaps with some minor twists. But finding something that’s also simple is hard. It has to be a single task that can’t be reduced or explained in terms of existing tasks. Inventing or discovering such a task requires either a lot of hard work and social insight, or a great deal of luck. It’s no wonder most social software fails.

original post by Michael Nielsen

(Visited 3 times, 1 visits today)