Over the holidays I got the chance to drive electric cars from a few different brands. Nothing exotic, and nothing dramatic — I wasn’t testing them for a magazine or clocking 0-to-100 times. It was the ordinary stuff. Picking someone up at the train station. A quick run to the grocery store for the one thing we’d forgotten to buy. The kind of short drives you don’t really plan, but that are still long enough to start fiddling with the seat, the mirrors, the climate, and all the little settings that make a car feel like yours for the afternoon.
And somewhere in the middle of all those short trips, something surprised me. The cars had attitude.
Some of them, honestly, were a little rude.
Drift slightly over the speed limit on a stretch where the limit is about to increase anyway, and the warnings start blinking like you’ve done something genuinely dangerous. Not a gentle nudge — a furious, insistent flashing, as if the car has caught you in the act. Take a country road and you get a lane-keeping lecture, because the software doesn’t understand that lanes out in the countryside behave differently than they do in the city. Faded markings, gravel edges, roads that curve in ways the model didn’t expect. The car doesn’t know that, so it corrects and warns and corrects again, convinced it knows better.
Here’s the thing that stuck with me: none of this was about how the cars actually drove. The engineering was fine. The motors were smooth, the brakes were good, the range was what it promised to be. If you judged these cars purely as machines, there was nothing to complain about.
But I noticed I had started to dislike some of them. Not the hardware — the personality. And that personality came entirely from the software.
The interface was doing the talking, and it wasn’t being pleasant. It was anxious, it was pushy, it assumed the worst about me. It mistook vigilance for helpfulness. Every warning was pitched at maximum urgency, whether the situation deserved it or not, and after a while that constant low-grade nagging colored how I felt about the entire brand. I’d get out of the car slightly annoyed, without always being able to say exactly why.
That, to me, is the real user experience challenge, and it’s one we don’t talk about enough.
We tend to measure software by whether it works. Does it do the thing? Does it do the thing correctly? Does it do the thing quickly? Those are necessary questions, but they’re not sufficient ones. A lane warning that fires correctly but at the wrong moment, in the wrong tone, is technically doing its job and still making the experience worse. Accuracy without judgment isn’t help — it’s noise with good intentions.
Because the truth is that people don’t just use software. They form a relationship with it. They build up a feeling about it, trip by trip, click by click, notification by notification. And that feeling is shaped less by whether every feature functions and more by how the software treats them. Does it trust me? Does it understand the context I’m actually in? Does it know the difference between a real problem and a minor one? Does it speak to me like a helpful passenger, or like a backseat driver who won’t let anything go?
The cars taught me that automation always carries an attitude, whether we design that attitude on purpose or not. Every threshold, every alert, every default is a small decision about how to treat the person on the other side. Get those decisions right and the software fades pleasantly into the background, feeling like a good companion. Get them wrong and it becomes that passenger nobody wants in the car.
So this is the bar I’ve started holding our own work to. It isn’t enough for software to function. It has to be likeable. And if we’re honest about what we’re aiming for, maybe even loveable.
Working software is table stakes. Likeable software is the actual goal — and the attitude is a feature, whether we designed it or not.
