My first Tesla -- a Model 3 -- came with what I would describe as polite cruise control with ambitions. It could hold a lane and maybe change one if you coaxed it. You never trusted it. Hands on the wheel. Eyes wide open. Ready to intervene at any moment.
Six years later, my Model Y handles unprotected lefts, merges confidently, and navigates roundabouts without intervention. The hardware barely changed. The cameras are slightly better. The compute is faster. The core sensor setup is largely the same.
The difference is entirely software. Over-the-air updates, fueled by data from hundreds of thousands of cars driving millions of miles, compounded into something qualitatively different from what shipped.
The Shift Was Predictability, Not Accuracy
Early versions felt like roulette. Would it brake too hard? Swerve mid-curve? Slow to 15 mph on a freeway on-ramp? The car might technically do the right thing, but it did not feel like it understood the situation.
The transformation was not primarily about getting more decisions right. It was about becoming predictable. The software got calmer. It signals intent before acting. It handles merges assertively instead of hesitantly. It recovers smoothly when inputs are ambiguous.
Most importantly, it learned to fail well. When it gets confused now, it slows down, waits, and asks for takeover. It is not flawless, but it is legible -- which matters far more for trust than raw accuracy metrics.
Programming Versus Teaching
The same visual inputs that produced tentative lane-holding in 2019 now generate rich semantic maps. Intersection behavior went from hardcoded heuristics to learned patterns. The car interprets social signals -- a pedestrian hesitating at a crosswalk, a truck signaling intent to merge.
Every disengagement became a training signal. Every obscure intersection, an edge case absorbed into a neural net. The learning compounded in a way that manual programming never could.
What This Means
I still keep a hand near the wheel. I still scan for unusual scenarios. But I am not white-knuckling it anymore.
The trust was not earned in a single update. It was earned across six years of incremental improvement, each one too small to notice individually, transformative in aggregate. This is what it looks like when software compounds on static hardware -- and it is a strong argument for building systems that can learn from their deployment, not just their development.