IDEO’s Futuring vs Anticipatory Design

The Promise and the Gap

IDEO’s Futuring methodology, also known as Foresight, has fundamentally reshaped how design teams approach uncertainty. Through the Futures Cone framework — originally developed by futurist Joseph Voros and adapted for design practice — teams have learned to think beyond linear prediction. They’ve embraced scenarios, signals, artifacts, and narratives as tools to expand imagination and challenge present-day assumptions.

This is vital work. It’s upstream, strategic, and essential for reframing problems before solutions solidify.

But there’s a moment that every team eventually faces:

The moment when exploration must become execution.

When a preferred future direction must survive contact with sprint planning, machine learning pipelines, and actual user interactions. When speculative artifacts must transform into production code.

That’s where most futuring exercises end — and where the real complexity begins.

Where Futuring Ends, Systems Begin

The transition from futures workshop to functioning AI system isn’t just an implementation challenge. It’s a fundamental shift in what “anticipation” means.

In a futuring workshop, anticipation is about stretching collective imagination. It’s generative, open-ended, purposefully divergent. Teams create multiple scenarios precisely because the future is unknowable.

But in a live AI system, anticipation becomes operational. The system must make choices — in milliseconds, at scale, with real consequences. It must predict what users need before they ask. It must adapt to context without explicit instruction. It must personalize without presuming.

This is anticipation as an ongoing relationship, not a one-time exercise.

And this is where traditional futuring methods, as powerful as they are, need a companion framework.

When Systems Rely Only on the Past

Let me show you what happens when companies build AI without imagining how the future might be different from the past — when they rely purely on forecasting (using historical data to predict what comes next) without foresight (imagining how things might change).

Nest: The Intent Problem

Consider the Nest thermostat. For a year, it learns a household’s routine perfectly — temperatures, schedules, preferences. The system uses all this historical data to forecast future needs.

But then a newborn arrives. Everyone’s routine changes dramatically, but Nest remains trapped in the past — locked into a year of learned patterns. It can’t adapt overnight, so it continues to optimize for energy efficiency even though the priority has shifted to the baby’s comfort.

This is where automated systems fall short:

when the prediction makes sense statistically but fails to account for human nuance.

The failure: The system optimized for statistical probability without imagining how user intent might shift when life circumstances change. Because the system was built on forecasting (analyzing past patterns) without foresight (imagining how user needs might fundamentally shift).

Mint: The Personalization Problem

Mint, the financial management app, exemplifies this failure. Despite sophisticated AI and millions of users, it couldn’t adapt to evolving realities. It failed to anticipate that income forms were changing — content creators, streamers, freelancers with irregular or multiple income streams. It couldn’t keep pace with new financial priorities like cryptocurrencies and alternative investments, remaining stuck in traditional financial logic. Most critically, it confused automation with assistance — automating too much without explaining why, reducing users to passive observers.

Mint remained stuck in traditional financial logic, forecasting a world that no longer existed for many users.

The failure: The system excelled at forecasting but lacked the foresight to imagine how users’ financial lives and goals might evolve beyond historical norms.

Vi Sense: The Agency Problem

Vi Sense, launched in 2016 as the first AI-powered fitness headset, promised a personal trainer in your ears — real-time coaching with conversational AI that sounded like a friend. Technically brilliant. But it treated all users the same, whether beginners or veterans. It gave prompts when users were injured. It suggested running during storms. It had incredible voice design but a generic experience.

And generic experiences don’t change behaviors.

The failure: The system automated coaching without imagining the diverse contexts and needs of individual users, or how those needs change over time.

The Pattern: Three Critical Gaps

These failures reveal what happens when companies build AI systems without the foresight that methodologies like IDEO’s Futuring provide. But they also reveal something else: even when companies do engage in futures thinking (like IDEO’s Futuring methodology), there’s still a gap. Futuring helps you imagine multiple possible futures, but it doesn’t tell you how to build systems that can navigate those futures while preserving human agency. This is when I see three critical gaps emerging:

The Intent Gap

Futuring asks: What futures are possible?
Systems must answer: What does this specific user need right now?

Nest could forecast behavior patterns, but couldn’t understand intent when context shifted. Even the best futuring workshop wouldn’t solve this — you need behavioral mechanisms built into the system itself.

The Personalization Gap

Futuring asks: What scenarios should we prepare for?
Systems must answer: How do we balance probable patterns with preferable outcomes in real-time?

Mint could react to past data, but couldn’t design for where users were going. Futuring might have imagined alternative financial futures, but the system still needed the ability to detect when individual users were shifting between those futures.

The Agency Gap

Futuring asks: What futures do we want to create?
Systems must answer: How do we let users shape their own futures?

Vi Sense could predict optimal fitness paths, but it removed the agency necessary for sustainable behavior change. Imagining better fitness futures isn’t enough — systems need to preserve user autonomy while guiding change.

These aren’t failures of imagination — they’re failures of operationalization. Futuring helps us imagine preferred futures. But it doesn’t tell us how to encode those futures into systems that honor human complexity while working toward them.

The Missing Layer: Behavioral Design

The bridge between futuring and implementation is behavioral design — specifically, understanding how people change, what motivates them, and when systems should act versus step back.

Three behavioral science frameworks provide this foundation. Let me show how Vi Sense failed on all three — and what would have been different if these frameworks had guided its design:

Prochaska’s Transtheoretical Model: Understanding Stages

People don’t transform overnight — they progress through distinct stages of readiness: pre-contemplation (not thinking about change), contemplation (considering it), preparation (getting ready), action (doing it), and maintenance (sustaining it). Systems must adapt to where users are in their journey, not treat everyone identically.

How Vi Sense failed here: It treated a sedentary beginner the same as an experienced runner. Giving identical coaching regardless of the readiness stage. A futuring workshop might imagine different fitness futures, but without Prochaska’s model, you can’t build a system that meets users at their actual stage of change.

What it needed: The system should have asked “Where are you in your fitness journey?” and adapted its entire approach based on the answer. Someone in pre-contemplation needs education and motivation, not workout prompts. Someone in action needs structure and encouragement. Someone in maintenance needs variety and challenge.

B.J. Fogg’s Behavior Model: Aligning Elements

Behavior occurs when three elements converge simultaneously: Motivation (wanting to do it), Ability (being able to do it), and a Prompt (being triggered to do it). The formula is (B=MAP). Systems must align all three while preserving user control.

How Vi Sense failed here: It focused almost entirely on Ability — making workouts technically accessible through voice coaching. But it ignored Motivation (why should I care?) and made inconvenient Prompts (suggesting runs when users were injured or during storms). High ability without motivation and appropriate prompts doesn’t create behavior change.

What it needed: The system should have built motivation first (showing progress, celebrating small wins), ensured ability matched the user’s current fitness level, and timed prompts contextually (nice weather, recovered from last workout, schedule has time).

Thaler and Sunstein’s Nudge Theory: Timing Interventions

The right intervention at the right moment catalyzes change. The wrong one generates rejection. Systems must understand not just what to suggest, but when — and crucially, when to stay silent.

How Vi Sense failed: It gave workout prompts regardless of context — when users were injured, during bad weather, at inconvenient times. These poorly timed nudges didn’t just fail to motivate; they created frustration and disengagement.

What it needed: Context-aware nudging. Before suggesting a run, check: Is the user recovered? Is the weather appropriate? Does their schedule allow it? If any answer is no, either adjust the suggestion or stay silent. A missed nudge opportunity is better than a mistimed one that breaks trust.

Vi Sense imagined a future where AI coaches everyone to better fitness. But without these behavioral frameworks, it couldn’t build a system that actually guided people through the messy, non-linear reality of behavior change. Futuring gave it the vision. Behavioral design would have given it the mechanism.

The Anticipatory Design Framework

So how do we actually bridge the gap? Through a systematic approach that moves from imagination, , using a technique called backcasting.

Backcasting is the opposite of forecasting. Instead of projecting the future from past patterns, you start by defining a desired future state and work backward to determine what needs to happen today to reach it. Think of it as reverse-engineering the future.

The framework has three phases:

Phase 1: Anticipate

What’s changing in user behavior and context?

This isn’t just futuring’s scenario planning — it’s behavioral research. For that, we combine foresight with behavioral research to identify:

Where users are in their change journey (Prochaska) What motivates them at each stage (Fogg) What barriers they face What contexts trigger different needs (Nudge) Output: User journey maps that show behavioral stages, not just touchpoints.

Example: Instead of imagining “a future where everyone is financially healthy,” identify the specific stages users progress through (awareness → planning → action → maintenance) and what’s needed at each stage.

Phase 2: Imagine

How do we design for multiple possible futures?

This is where foresight and behavioral design converge. Use backcasting — working backward from desired futures:

Define the behavioral outcome you want Identify what must change to get there Map the stages users must progress through Design interventions for each stage Output: Scenario-based behavioral roadmaps that show not just what’s possible, but what’s needed at each stage.

Example: For Nest, backcasting from “effortless climate comfort” would reveal the need for context-shift detection. When major life changes occur (new baby, injury, schedule change), the system needs mechanisms to recognize this and adapt, not just optimize based on past patterns.

Phase 3: Shape

How do we build systems that adapt and preserve agency?

This is the operationalization layer that foresight doesn’t provide:

Adaptive Workflows: Design systems that respond to behavioral stage, not just behavior patterns. An email client that learns you’re in “overwhelmed mode” might suggest batch processing, but gives you control over when and how.

Constraint Design: Make system boundaries explicit. A smart thermostat should signal when it’s in “learned mode” vs “manual override,” and should flag uncertainty rather than confidently making bad predictions.

User Choice Architecture: Let users see and shape how anticipation works. A fitness app should show which signals drive its suggestions (consistency, intensity, recovery patterns) and let users adjust their relative importance.

Output: Working systems with behavioral intelligence baked in.

Example: Vi Sense redesigned would ask users about their fitness stage, show why it’s suggesting specific workouts, and let users indicate when context has changed (injury, travel, weather) so the system adapts appropriately.

A Practical Bridge: Five Steps

For teams moving from foresight exercises to anticipatory implementation:

1. Stress-Test Scenarios Against Behavioral Reality

Take your preferred future scenarios and ask:

What behavioral stages must users progress through? What happens when context shifts mid-journey? What happens when the system’s prediction conflicts with user intent?

2. Map Anticipation Points to Behavioral Stages

For each system decision, identify:

What behavioral stage is the user likely in? What combination of motivation, ability, and prompt exists? What timing considerations matter?

3. Design for Agency at Every Layer

Ensure users can:

Understand why the system did what it did Correct the system when it’s wrong Shape future behavior based on changing context

4. Build Feedback Loops That Respect Change

Create mechanisms that:

Show users how their interactions shape predictions Allow users to signal major context changes Design for graceful unlearning, not just optimization

5. Establish Behavioral Guardrails

Define:

What the system should never assume What contexts require explicit consent What failure modes could harm user autonomy

Why Both Approaches Matter

IDEO’s Futuring asks: What futures should we explore? Anticipatory Design asks: How do we encode a chosen future into adaptive systems without eroding trust, transparency, or human agency?

Both questions are essential. But they operate at different scales:

→ Futuring lives upstream: Expanding possibility space, challenging assumptions, imagining alternatives. → Anticipatory Design lives downstream: Where systems meet real users, make real decisions, and shape real behaviors.

IDEO makes futures tangible through speculative artifacts that expand imagination.

Anticipatory Design makes futures tangible inside live AI systems through workflows, constraints, and user choices that operationalize intent.

IDEO’s work opens up the conversation about what’s possible. Anticipatory Design keeps that conversation alive once automation enters the picture — ensuring that the futures we imagine remain human-centered when we build them.

The Ongoing Relationship

Here’s what I’ve learned from years of building AI systems: anticipation isn’t a feature. It’s a relationship.

And like any healthy relationship, it requires:

Transparency about intentions and capabilities Respect for boundaries and autonomy Adaptation based on changing needs and contexts Trust built through consistent, predictable behavior You can’t workshop your way into that kind of relationship. You have to design for it systematically, at every layer of the system.

IDEO’s Futuring (foresight) gives us the vision. Anticipatory Design gives us the path.

That’s the hard part. And that’s where the real work begins.

Want to go deeper? The Anticipatory Design Playbook provides frameworks, case studies, and practical tools for designing AI-driven experiences that respect human agency while enabling meaningful behavior change.