About five or six years ago, I led a fast-growing software development group. We were scaling quickly—hiring at pace, maintaining large legacy systems, and trying to identify future leaders from the talent we brought in. The company had a smart (and admittedly scrappy) model: hire a lot of recent grads, pay on the lower end, and accept that most would move on in a few years. Those who showed real potential stuck around and moved up.

What surprised many was just how positive the culture was. These new hires were mostly the same age, came from the same big college, and it was like an extension of campus life—fun, collaborative, high energy. A few senior folks were there to guide, but the day-to-day was peer-led, and engagement was through the roof.

But one thing became clear very quickly: most of these developers had no idea how to design software.

I don’t mean they couldn’t code. They could. But when it came time to go from a problem statement to an actual architecture—even something as small as a feature—they were lost. Design thinking just hadn’t been taught. They hadn’t been asked to think through failure modes, or reason about data sources and system boundaries.

So we adjusted our interviews.

A Wake-Up Call (Literally): The Alarm Clock Question

We started asking candidates to design an alarm clock—one that lets the user sleep as long as possible but still get to work on time. It needed to take into account traffic, weather, holidays, and anything else relevant.

And then we’d hit them with the critical question:
“Under what circumstances would your design fail?”

That’s when the wheels came off for most folks. They hadn’t been taught to think like designers, to poke holes in their own work, or to test their logic against the unpredictability of real-world inputs.

It was a revealing moment—and honestly, a bit scary. Because what we need from developers now, especially as AI becomes ubiquitous, isn’t just code. It’s design. Robust, thoughtful, failure-tolerant design.

Enter AI: The New Frontier of Design Problems

Today, we’re building systems that don’t just follow a script. They converse, they adapt, they help people with Alzheimer’s remember who just visited or coach someone with a traumatic brain injury through a daily routine. And here’s the truth: every failure in design becomes a failure in trust.

For example, detecting when someone has stopped speaking sounds trivial—until you realize that a child or someone with dementia might pause mid-sentence, then continue 2 seconds later. Should the AI jump in? Stay silent? What about when a person mumbles, repeats themselves, or stutters?

These aren’t just edge cases—they’re the core of the experience when you’re building tech for real people, especially the vulnerable.

And you can't just throw an LLM at the problem and expect it to “figure it out.” You need good design. Design that anticipates human quirks, failures in signal, or shifts in context. You need developers who can draw a line from a messy requirement, through a series of assumptions, into a coherent, testable, maintainable system.

Requirements → Design → Code (Not the Other Way Around)

In that fast-paced hiring model, we learned the hard way that skipping design leads to brittle systems. It’s easy to default to diving into code—especially with AI tools that autocomplete your thoughts for you. But that only works if you’ve done the thinking first.

Real design means:

  • Understanding the user’s constraints
  • Modeling how the system should behave over time
  • Considering interruptions, failures, and edge cases
  • Designing for handoffs between humans and machines

It’s what turns a “cool prototype” into something that actually helps someone get to work, remember their granddaughter’s birthday, or avoid confusion in a complex conversation.

Final Thoughts

Look—AI is going to keep changing the landscape. That’s a given. But no matter how powerful the models get, they won’t replace the developer who can think in systems, reason through ambiguity, and ask the hard question: “What could go wrong?”

Design is the skill that turns a competent coder into a builder of futures.

And in the age of AI, that’s who we need.