The Prisoner’s Dilemma

Posted on November 13, 2015

Anyone who’s even a little familiar with game theory is undoubtedly familiar with The Prisoner’s Dilemma. It’s a classic thought experiment that illustrates how people can make rational choices that seem to be in their own best interest, even when another choice would result in a better outcome for themselves and for the group.

In the classic formulation of the Prisoner’s Dilemma, the prisoner in question is faced with a choice. The prisoner can sell out his accomplice to the authorities and receive a lighter sentence in return, or he can remain silent knowing that there’s not enough evidence to convict without one of their testimony. The problem is that the prisoner’s accomplice is being offered the same deal. How much can the prisoner really trust his partner in crime? What if the accomplice takes the deal and leaves the prisoner to take on the full burden of the sentence? If the prisoner remains silent and the accomplice talks, doesn’t that make the prisoner a chump?

The central conflict of the Prisoner’s Dilemma comes down to trust. If the prisoner is confident that he can trust the accomplice, and the prisoner is confident that the accomplice is confident that the prisoner is likewise trustworthy, then both are better off (both individually and as a group) remaining silent. But if the prisoner isn’t completely sure that he can trust his partner in crime, or if he isn’t sure that his trust is reciprocated, then he’s better off singing like a canary.

So what does this all have to do with iOS developers? The iOS developer community has been locked in a game of the Prisoner’s Dilemma since the App Store was introduced in 2008, and we’ve lost at every turn. For us, the stakes aren’t whether we’ll go free or go to jail, but whether there will be a vibrant market for paid mobile software. Our choice isn’t whether or not to sell out an accomplice, but rather it’s whether we’ll choose short-term gains while at the same time contributing to the perception that mobile software isn’t worth paying for, or if we’ll forego those short-term gains knowing that a competitor could cash in and make our restraint all for naught. In short, it’s about the race to the bottom.

I used to think that the race to the bottom had reached as low as it could go. After all, what could be cheaper than free, ad supported apps? Turns out I was wrong. Recently, a monetization method that has been around for a while has become suddenly more popular and has taken the race to the bottom to even lower depths. Instead of providing content and requiring customers to pay with their attention by showing them ads, this new method gives everything away for free in the hopes that a small portion of customers will throw a few coins their way.

Proponents of this model call it “patronage,” but it has little in common with the historical concept of patronage where a well-off patron paid an artist an amount to commission a work of art. This new model, in fact, is the opposite of patronage. Instead of requiring a patron to provide money up front in exchange for an item of value, this new model gives away all the value in advance and requires nothing from those who receive it. It less resembles patronage, or even commerce, than it does begging, or busking if you’re feeling generous.

So how did we get to this point? One rational decision at a time. Over the years, thousands of developers have decided that it was in their interests and their businesses’ interests to lower their price and capture more price-sensitive purchasers. Many of them no doubt increased their revenue by attracting customers who would have otherwise purchased from competitors, which was exactly the plan. The unfortunate side-effect of this strategy, of course, was that customers were trained over time to expect mobile software to be free or low-cost. And once that expectation became set, it became incredibly hard to convince customers to part with even the smallest sum of money to purchase an app.

But I don’t blame those developers that contributed to the race to the bottom by selling their work at rock bottom prices. In general, they did act in their own best interests and the best interests of their businesses, and that’s how free markets are supposed to work. Just as in the Prisoner’s Dilemma, they had no way to know that their competitors wouldn’t try the same price-lowering gimmick, so the only rational choice was to preemptively lower their price to capture those price-sensitive customers. Even if a developer realized at the time that he was contributing to the race to the bottom and diminishing his long-term prospects in the App Store, the rational decision was still often to lower an app’s price and cash in first.

That’s the insidious nature of the Prisoner’s Dilemma: By the time you’re faced with a choice, it’s too late to take the high road. By the time the prisoner is being questioned, the only rational choice is to sell out his accomplice, because he can’t be sure of the other’s thinking. Likewise, by the time an app developer faces the choice of lowering his price or holding the line, the only rational choice is to lower his price and cash in first, because if he doesn’t, a competitor will. And so, step after step, price drop after price drop, the cycle continues until we arrive at the situation we find ourselves in today where we give away months of labor gratis in the hopes that a few customers will take pity on us and drop a couple coins in our hat.

The good news is that we can break this cycle, but only if we engineer our businesses to avoid competing on price in the first place. We can avoid competing on price by choosing to build apps that are truly differentiated from their competition. We can avoid competing on price by choosing app ideas that present a barrier to entry (legal, technical, or otherwise) to prospective competition. We can avoid competing on price by entering niches that are less price-sensitive than the mass market is. We can avoid competing on price by carefully considering and analyzing the financial viability of prospective apps before ever opening Xcode. In short, we can avoid competing on price by treating our app businesses as a business and doing the up-front work that’s needed to ensure that a prospective app idea is a sustainable one.