What Is Design Thinking? Modes, Origins and Evidence
Updated 6 skills6 stepsOrigin: Herbert A. Simon, with later development and popularization by IDEO and Stanford d.school
Created by Herbert A. Simon, with later development and popularization by IDEO and Stanford d.school - https://en.wikipedia.org/wiki/Herbert_A._Simon
Overview
Design Thinking is a human-centered, collaborative and iterative way of working on complex problems, using the methods designers use to understand people and shape solutions. IDEO states plainly that there is no one definition of design thinking and describes it as a set of mindsets and design-based activities that foster the collaboration needed to solve problems in human-centered ways. The most quoted version comes from IDEO's Tim Brown, who calls it a human-centered approach to innovation that draws from the designer's toolkit to integrate the needs of people, the possibilities of technology, and the requirements for business success. IDEO compresses that into three tests a solution must pass: desirable for people, feasible with technology and viable for the organization.
The method has no single inventor. Herbert A. Simon was the first to mention design as a way of thinking in his 1969 book, The Sciences of the Artificial, and through the 1970s he contributed ideas now regarded as principles of design thinking. A review of early design research places Simon's book alongside other foundational works in design methodology and notes that Simon's approach sought to formalize design through engineering, rational problem-solving and human psychology. Simon's definition, "Everyone designs who devises courses of action aimed at changing existing situations into preferred ones," treated design as any intentional change, not just the making of objects. The contemporary version moved that theory into practice. Tim Brown's Change by Design presented design thinking to business readers as a collaborative process for matching people's needs with what is technically feasible and a viable business strategy, and a CCA conversation about the book sums up its inspiration, ideation and implementation cycle.
Stanford's d.school gave the method its best-known classroom shape. The d.school identifies five modes: Empathize, Define, Ideate, Prototype and Test. In Empathize, the team studies the people affected, and the d.school's bootleg deck calls empathy the foundation of human-centered design because the problems you solve are rarely your own. Define synthesizes that research into a clear problem. Ideate goes wide on radical alternatives. Prototype makes ideas tangible, from an object to a role-play, and Test puts prototypes in front of users to refine both the solution and the team's grasp of the problem. The modes are not a checklist. The d.school itself argues against talking about THE design process, noting that intro workshops rush a linear five-step sequence in about 90 minutes, and IxDF describes the phases as non-linear and iterative.
flowchart LR
E[Empathize] --> D[Define]
D --> I[Ideate]
I --> P[Prototype]
P --> T[Test]
T -->|reframe problem| D
T -->|new ideas| I
T -->|learn more| E
The closest alternative is the UK Design Council's Double Diamond. Its history describes four phases, Discover, Define, Develop and Deliver, chosen as a deliberately memorable device. The Design Council's framework treats each diamond as divergent exploration followed by convergent action, and its first diamond exists to help people understand, rather than simply assume, what the problem is. The two map closely: Discover and Define cover Empathize and Define, Develop covers Ideate, Prototype and Test, and Deliver covers the implementation that the d.school modes leave implicit. Reach for the Double Diamond when stakeholders need the diverge and converge rhythm made explicit, and for the d.school modes when a team needs named activities it can practice.
The evidence is real but uneven. Most studies measure short-term, perceived or educational outcomes rather than market results.
| Source | Sample | Main finding | Limitation |
|---|---|---|---|
| Engineering education review, 2026 | Review of 76 studies, 2003-2023 | Strongest evidence for engagement, motivation, self-efficacy | Weakest evidence for long-term effects |
| Pedagogy review, 2026 | Review of studies | Linked to motivation, collaboration, creativity | Reported associations only |
| K-12 review, 2022 | Review of 43 papers | Great educational potential | Empirical support still limited |
| Theory review, 2025 | Review of 69 articles | Four mechanisms, including reframing | Explains impact, does not measure it |
| Global organizational study | Survey respondents | Better team culture for 71%, faster innovation for 69% | Perceived, not causal (source) |
| Practitioner survey, 2026 | Survey of 100 practitioners | Still relevant for 85% | Only 12% reliably ship session output (source) |
Read these figures carefully. The organizational study asked respondents about perceived impact, so its percentages are self-reports, not controlled comparisons, and the engineering review (source) examined differing implementation strategies and core elements, which makes studies hard to compare. The sources establish no accepted success rate against Agile, Lean Startup or traditional R&D, so treat any such headline with suspicion. The same discipline belongs inside a project: the d.school describes synthesis as frameworks, maps and abductive thinking, so keep observed behavior in the research record and hold explanations of why it happened as interpretations still to test. Hamster Studio teams can keep research notes, insights and test results side by side in one shared workspace so that line stays visible.
Core Principles
Start with the people who have the problem
The team's own assumptions are the least reliable input, because the problems you are solving are rarely your own. Research means observing and talking with the people affected, in their context, before proposing anything. If the first artifact a team produces is a solution sketch rather than notes about users, this principle has been skipped.
Pass all three tests, not just one
A good solution is desirable for people, feasible with technology and viable for the organization. Users loving a concept does not make it buildable or sustainable, and a profitable idea nobody wants fails too. Evaluate candidates against all three lenses together so trade-offs surface early instead of at launch.
Reframe the problem before solving it
The Define mode exists because the first statement of a problem is usually a symptom or a disguised solution. A 2025 review of 69 articles names reframing as one of four mechanisms through which the method may create impact. A useful frame names a specific user, a need and an insight that shifts the team's perspective.
Diverge before you converge
Generating options and choosing between them are different activities, and separating idea generation from idea selection strengthens both. Judging ideas as they appear kills the unusual ones that often lead somewhere. Hold a clear boundary between the wide phase and the narrowing phase, and announce when you cross it.
Make ideas tangible early
A prototype turns an argument into something people can react to, and the d.school counts a role-play or an object as a prototype alongside more familiar forms. Rough and cheap is the point, because it keeps the team willing to throw weak ideas away. When a team spends weeks polishing before anyone outside sees it, learning has stalled.
Move between modes as evidence demands
The d.school cautions against treating design as one fixed process, and IxDF calls the phases non-linear and iterative. A failed test might send you back to Define because the problem was wrong, or to Empathize because you misread users. Running the five modes once, in order, and calling it done is the most common way the method degrades into theater.
Keep evidence separate from interpretation
Synthesis relies on frameworks, maps and abductive thinking, which means reasoning to the most plausible explanation. That explanation is a hypothesis, not a finding. Record what people did and said apart from why you think they did it, so later tests can confirm or overturn the interpretation.
Steps
-
Empathize with the people affected Observe and interview the people who experience the problem, ideally in the setting where it happens. Capture quotes, behaviors, workarounds and emotional moments rather than feature requests. Include people at the edges, not just typical users, because extremes reveal needs the average hides. The output is a research record of what you saw and heard.
If your notes are mostly opinions about what users should want, go back into the field.
-
Synthesize and define the problem Cluster observations into patterns, then interpret those patterns into insights about needs, as covered in synthesizing user insights. Choose the insight that most shifts the team's perspective and write a point-of-view statement naming a specific user, their need and that insight; see framing human-centered problems. Turn the statement into a focused prompt such as a How Might We question. The frame is wrong if it smuggles in a solution or describes a generic customer.
-
Ideate widely Run a time-boxed session that aims for many varied ideas and defers judgment, following the practices in generating divergent ideas. Invite people from different functions and look for inspiration from other domains. Capture every idea visibly, including the absurd ones. Only after generation stops should the group select a handful of promising directions to prototype.
-
Prototype cheaply Turn the selected ideas into rough artifacts that someone else can use or react to: paper screens, a storyboard, a role-played service, a cardboard object. Build only what the question you are testing requires, as described in building rapid prototypes. Make more than one version where you can, so users compare rather than just approve. If building takes longer than testing, you are over-investing.
-
Test with real users Put the prototype in users' hands, or put users in the prototype, and give only the context they need to start. Watch what they do before asking what they think, because behavior is more reliable than stated preference. Record what worked, what confused people and what surprised the team. Evaluate surviving concepts against desirability, feasibility and viability together, using balancing desirability, feasibility, and viability.
-
Loop back or move to implementation Decide from the test evidence where to go next: refine the prototype, generate new ideas, reframe the problem or return to research. Iterating from evidence covers how to make that call deliberately. When a concept has passed tests on all three lenses, turn it into a concrete plan with an owner, scope and timeline. A cycle that ends in a presentation with no owner has not finished.
When to Use
- The problem is ill-defined or contested, because the method is built to challenge assumptions and redefine the problem before committing to a solution.
- You are designing a new product, service or experience for people whose lives and constraints the team does not share, so direct research will correct blind spots.
- Several functions (design, engineering, business) must agree on a direction, because the desirability, feasibility and viability lenses give them a shared vocabulary for trade-offs.
- Early concepts can be tested cheaply with paper, role-play or mockups before significant investment, which lets you learn fast and discard bad ideas.
- A team keeps shipping features that users ignore, a sign that the problem framing rather than the execution is failing.
When Not to Use
- The problem is well-understood and the solution is known, such as a routine compliance update, where research and ideation add cost without changing the answer.
- An emergency requires immediate action, because the method's research and iteration loops assume time to learn before committing.
- You have no access to real users and no way to get it, since empathy and testing are the core inputs and substituting team opinion defeats the purpose.
- Nobody owns implementation after the workshop, since only 12% of surveyed teams reliably ship what their design sessions produce and without an owner the output becomes a wall of sticky notes.
Skills in this method
Each skill is a self-contained write-up your agent can run. Install the ones you need; nothing here is a bundle.
Applying Desirability Feasibility Viability Design Thinking
A decision on which concept to advance, with the evidence behind each lens and an action plan listing the assumptions still to test.
npx skills add gethamster/skills --skill balancing-desirability-feasibility-and-viability --agent claude-code --yesDesign Thinking Rapid Prototyping, Step by Step
A tangible prototype plus a recorded set of user observations and a clear decision to refine, reject, or retest the idea.
npx skills add gethamster/skills --skill building-rapid-prototypes-with-design-thinking --agent claude-code --yesHow to Write a Design Thinking Problem Statement
One or a few point-of-view statements, each naming a specific user, a need, a perspective-shifting insight and a game-changing outcome, scoped tightly enough to launch ideation.
npx skills add gethamster/skills --skill framing-human-centered-problems --agent claude-code --yesDesign Thinking Ideation Techniques for Divergent Ideas
A visible collection of many varied raw concepts, sketches and combinations, ready for a separate convergence step.
npx skills add gethamster/skills --skill generating-divergent-ideas --agent claude-code --yesIterating from Evidence: Design Thinking Iteration Process
A documented loop-back decision after each test, with an updated problem statement or prototype and a clear path from session output to shipped work.
npx skills add gethamster/skills --skill iterating-from-evidence --agent claude-code --yesSynthesizing user research insights from raw observations
A short list of testable insights, each linked to the observations that support it, ready to feed a point-of-view problem statement.
npx skills add gethamster/skills --skill synthesizing-user-insights --agent claude-code --yesFAQ
Who invented Design Thinking?
No single person did. Herbert A. Simon first described design as a way of thinking in his 1969 book The Sciences of the Artificial, and IDEO and Stanford's d.school later developed the practical versions most teams use today. Tim Brown's Change by Design was especially influential with business audiences.
What are the five stages of Design Thinking?
Stanford's d.school names five modes: Empathize, Define, Ideate, Prototype and Test. The d.school deliberately calls them modes rather than stages. Teams move between them as they learn, for example returning to Define when a test shows the problem was framed wrongly.
Is Design Thinking the same as human-centered design?
They overlap heavily, and IDEO treats them as closely related. IDEO describes human-centered design as a process that starts with the people you are designing with and ends with solutions built for their needs. Design Thinking adds explicit weight on technical feasibility and business viability alongside that human focus.
How is Design Thinking different from the Double Diamond?
The Double Diamond uses four phases, Discover, Define, Develop and Deliver, and makes the alternation between divergent and convergent thinking its central visual idea. The d.school modes instead name concrete activities such as prototyping and testing. The two cover similar ground, and the Double Diamond is more explicit about delivery.
Does Design Thinking actually work?
The evidence is strongest for short-term outcomes. A 2026 review of 76 engineering education studies found the strongest support for engagement, motivation and self-efficacy and the weakest for long-term effects. Organizational figures, such as 71% of respondents reporting improved team culture, are perceptions rather than controlled comparisons.
Is Design Thinking dead?
Practitioners do not think so, but they want it to change. In a 2026 survey of 100 practitioners, 85% called it still relevant, 52% said it needs to evolve, 56% said their teams use it selectively and 21% (source) use it religiously. The bigger problem that survey flags is follow-through, since few teams reliably ship what their sessions produce.
How long does a Design Thinking project take?
It depends on the problem, and the sources set no standard duration. The d.school notes that intro workshops squeeze a linear pass through all five modes into about 90 minutes, which is a teaching exercise rather than a real project. Real work loops through the modes repeatedly until a concept survives testing.
Related methods
The Double Diamond: The Design Council's Design Process
The Double Diamond is the Design Council's four-phase design process: Discover, Define, Develop, Deliver. Learn how to run it and when to skip it.
Human-Centered Design: The People-First Design Process
Human-centered design is a design process that grounds every decision in people's needs. Learn its origins, ISO principles, evidence and limits.
Google Design Sprint: The Five-Day Process Explained
The design sprint, created by Jake Knapp at Google and refined at GV, takes a team from a big question to a tested prototype in five days.
Continuous Discovery Habits: A Practitioner's Guide
Master Continuous Discovery Habits, Teresa Torres's framework for weekly customer interviews and outcome-driven product development.
Download the What Is Design Thinking? Modes, Origins and Evidence pack
One zip with the whole method, to read offline or drop into a repository:
METHOD.md, this write-up in full- 6 skill folders, each with its
SKILL.mdand the references it ships - MIT licensed, the same files the commands above install
Source: gethamster/skills on GitHub, MIT licensed.
Install the skills
What Is Design Thinking? Modes, Origins and Evidence is a write-up of how the method works, so there is nothing to install for the method itself. Its skills are what your agent runs, and each one installs separately. The section above carries the Claude Code command for every skill, and each skill's own page carries the commands for Cursor, Codex, and Antigravity.
Or browse the skills and pick interactively:
npx skills add gethamster/skillsSource: gethamster/skills on GitHub, MIT licensed.