CC by-sa from user Peggy S on Flickr https://flic.kr/p/6wGNnf

The last few years have seen some impressive steps forward in big artificial intelligence projects. Yahoo has used deep learning for a major recategorization of Flickr’s massive photo set. Earlier this year, AlphaGo beat 9-dan professional Go player Lee Sedol in 4 out of 5 games. Everyone from Facebook to open.ai is developing new and exciting AI projects with cutting-edge software and massive data sets.

Matt, my co-founder at fuzzy.ai, points out that most of us don’t play televised Go matches on an international level. Most of us don’t have billions of images to recategorize. Most of us are still using software on our phones, tablets and laptops developed with the same old programming techniques that have been the backbone of software engineering for the last 30 years. The same techniques that aren’t very intelligent and that never, ever learn.

Programmers in the next decade are going to make huge strides in applying artificial intelligence techniques to software development. But those advances aren’t all going to be in moonshot projects like self-driving cars and voice-operated services. They’re going to be billions of incremental intelligent updates to our interfaces and back-end systems.

I call this casual intelligence — making everything we do a little smarter, and making all of our software that much easier and more useful. It’s casual because it makes the user’s experience less stressful, calmer, more leisurely. It’s also casual because the developer or designer doesn’t think twice about using AI techniques. Intelligence becomes part of the practice of software creation.

It should just know

How many times have you said things like this?

“I just told you a second ago that I didn’t want to use that image.”

“Who even uses this feature?”

“Just hit Cancel, then Cancel again, then Ignore, then OK, then Cancel.”

“I don’t have time to try to make this work.”

“Why do I have to enter this again?”

“It should just know.”

“It should remember.”

“Why doesn’t it just figure it out?”

Software that is not intelligent and adaptive is inevitably frustrating. It doesn’t remember how we work. It makes simple tasks irritating, and complex tasks exhausting. It puts us into an adversarial stance with our devices — rolling our eyes at how dumb the computer can be.

For software makers, this means that our users actively avoid our technology. We have lower conversion and retention rates because users aren’t being guided onto optimal paths. We leave money on the table when we give users the same old interface instead of addressing their needs directly.

Casual intelligence is a means to improve these results by improving our user experiences. It makes using software easier, more productive, and more pleasant. And it makes software businesses more optimal and more profitable.

Intelligence in every corner

There are thousands of points in a modern application that would benefit from AI techniques. In the design process, we can ask at each point, “What if we knew what the user wanted? What if we knew where they had been? What if we were writing this software just for this single user, just for this exact time?”

If you know that a user is experienced with your application, you don’t need to show them the tutorial link every time they come to the settings page.

A user that’s been having problems with your Ruby SDK should probably have higher-ranked support search results for Ruby-related issues.

You may have “advanced” or “basic” menus, but how many sites or apps use what they know about the user to present exactly the menu for stuff the user needs?

These are the kind of interactions that our users have with software every day, but too many of us in the software world think that “intelligent” behavior means making something like Hal from 2001. And because that kind of intelligence is difficult and resource-intensive, we fall back on the kind of interaction and development patterns that we’re used to: stiff, inflexible interfaces that don’t adjust to the user.

Keep it casual

Casual intelligence has five important qualities:

It is personalized. Every user is different; every user has their own style. Casual intelligence doesn’t design for the 51% of users that prefer red buttons over blue and give up on the other 49%. It caters to all users, improving retention and conversion for everyone. Casual intelligence makes your stated and unstated preferences part of how your app works. It makes the app yours. It is ubiquitous. Intelligent behavior isn’t cordoned off in some moonshot project or third-party API. It is a part of every aspect of your software — from the lowliest settings page to the dev-ops Slack channel to the central UI metaphors. Every piece of functionality on the front or back end is a valid target for improved intelligence. It is situational. Casual intelligence applies knowledge about the user right now, in the current situation, to make decisions. Time of day, day of week, location and session history change how the application behaves. Because that’s what intelligent systems do; they know what is going on in the world, and they act accordingly. It is informed. Modern applications are spread across a constellation of operating systems, devices, and interfaces. Casual intelligence remains informed by all the ways a user has interacted with an application. The full history of a user’s interactions with the application are part of the decision-making process. It is self-optimizing. Casual intelligence optimizes for personal goals of the user and business goals of the software development organization. It improves its own performance over time, based on feedback from the individual user’s behavior and analysis of users in aggregate. Casual intelligence moves important metrics up and to the right.

The casual competition

Users are developing a taste for intelligent behavior, and software creators that don’t begin catering to that taste will find themselves losing out to the competition. Software that implements casual intelligence will out-perform static, unintelligent software over time. It gets better every time it’s used.

Creators need to be honing their skills on intelligent behavior right away. And that doesn’t mean running through a deep-learning tutorial on image classification. Instead, developers should be looking at parts of their application where they’ve been accepting low performance as part of the cost of doing business.

What if the home page didn’t have a 70% bounce rate? What if conversion rates on the pricing page were 15% instead of 5%? What if churn was much lower? What if upsell rates were much higher?

These are the parts of an application that could benefit from casual intelligence.

Across disciplines

Designers, product managers and developers can work together to make casual intelligence an integral part of their applications. Designers need to stop thinking in terms of either-or interfaces — either we do it this way, or we do it that way. Casual intelligence lets interfaces become and-also — different users have different experiences. Some users will have experiences never dreamed of in your wireframes — and those may be the best ones of all.

For product managers, ideas about features need to change, and ideas about goals need to change. Accepting that a majority of users will give up on an app is something baked into our ideas of metrics and analytics. We can do better than that, by giving those “lost” users a different experience and putting them on a different path. A consistent experience is the enemy of casual intelligence.

Most of all, developers need to investigate their options. There are a world of technologies between deep-learning and procedural code that can and should be explored. Casual intelligence may not be the best place to apply TensorFlow or a natural-language parsing toolkit; it’s important not to get hung up on particular packages or techniques. It’s much more important to provide intelligent behavior that answers a user’s needs at each decision point in your application. Knowing what can be done, with what kind of resources, is going to be a key skill for developers.

All of these professions should be opening up their practices to techniques of artificial intelligence at a rapid pace. There is a lot of room for improvement, and those teams that are making the first strides in casual intelligence will reap the most benefit.