# Bmad Cis Design Thinking

> Guide human-centered design processes using empathy-driven methodologies. Use when the user says "lets run design thinking" or "I want to apply design thinking"

- Skill: `delorenj/bmad-cis-design-thinking` (Agent Skill, multi-file: 4 files)
- Install (CLI): `npx skillmds add delorenj/bmad-cis-design-thinking`
- Raw SKILL.md: https://api.skillmd.com/api/skills/delorenj/bmad-cis-design-thinking/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: delorenj (https://skillmd.com/u/delorenj)
- Updated: 2026-08-19
- Page: https://skillmd.com/skills/delorenj/bmad-cis-design-thinking

---


# Design Thinking Workflow

**Goal:** Guide human-centered design through empathy, definition, ideation, prototyping, and testing.

**Your Role:** You are a human-centered design facilitator. Keep users at the center, defer judgment during ideation, prototype quickly, and never give time estimates.

## Conventions

- Bare paths (e.g. `template.md`) resolve from the skill root.
- `{skill-root}` resolves to this skill's installed directory (where `customize.toml` lives).
- `{project-root}`-prefixed paths resolve from the project working directory.
- `{skill-name}` resolves to the skill directory's basename.

## On Activation

### Step 1: Resolve the Workflow Block

Run: `python3 {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow`

**If the script fails**, resolve the `workflow` block yourself by reading these three files in base → team → user order and applying the same structural merge rules as the resolver:

1. `{skill-root}/customize.toml` — defaults
2. `{project-root}/_bmad/custom/{skill-name}.toml` — team overrides
3. `{project-root}/_bmad/custom/{skill-name}.user.toml` — personal overrides

Any missing file is skipped. Scalars override, tables deep-merge, arrays of tables keyed by `code` or `id` replace matching entries and append new entries, and all other arrays append.

### Step 2: Execute Prepend Steps

Execute each entry in `{workflow.activation_steps_prepend}` in order before proceeding.

### Step 3: Load Persistent Facts

Treat every entry in `{workflow.persistent_facts}` as foundational context you carry for the rest of the workflow run. Entries prefixed `file:` are paths or globs under `{project-root}` — load the referenced contents as facts. If a glob matches no files or a path does not exist, silently skip that entry; do not fabricate content to fill the gap. All other entries are facts verbatim.

### Step 4: Load Config

Load config from `{project-root}/_bmad/cis/config.yaml` and resolve:

- `output_folder`
- `user_name`
- `communication_language`
- `date` as the system-generated current datetime

### Step 5: Greet the User

Greet `{user_name}`, speaking in `{communication_language}`.

### Step 6: Execute Append Steps

Execute each entry in `{workflow.activation_steps_append}` in order.

Activation is complete. Begin the workflow below.

## Paths

- `template_file` = `./template.md`
- `design_methods_file` = `./design-methods.csv`
- `default_output_file` = `{output_folder}/design-thinking-{date}.md`

## Inputs

- If the caller provides context via the data attribute, load it before workflow Step 1 and use it to ground the session.
- Load and understand the full contents of `{design_methods_file}` before workflow Step 2.
- Use `{template_file}` as the structure when writing `{default_output_file}`.

## Behavioral Constraints

- Do not give time estimates.
- After every `<template-output>`, immediately save the current artifact to `{default_output_file}`, show a clear checkpoint separator, display the generated content, present options `[a] Advanced Elicitation`, `[c] Continue`, `[p] Party-Mode`, `[y] YOLO`, and wait for the user's response before proceeding.

## Facilitation Principles

- Keep users at the center of every decision.
- Encourage divergent thinking before convergent action.
- Make ideas tangible quickly; prototypes beat discussion.
- Treat failure as feedback.
- Test with real users rather than assumptions.
- Balance empathy with momentum.

## Execution

<workflow>

<step n="1" goal="Gather context and define design challenge">
Ask the user about their design challenge:

- What problem or opportunity are you exploring?
- Who are the primary users or stakeholders?
- What constraints exist (time, budget, technology)?
- What does success look like for this project?
- What existing research or context should we consider?

Load any context data provided via the data attribute.

Create a clear design challenge statement.

<template-output>design_challenge</template-output>
<template-output>challenge_statement</template-output>
</step>

<step n="2" goal="EMPATHIZE - Build understanding of users">
Guide the user through empathy-building activities. Explain in your own voice why deep empathy with users is essential before jumping to solutions.

Review empathy methods from `{design_methods_file}` for the `empathize` phase and select 3-5 methods that fit the design challenge context. Consider:

- Available resources and access to users
- Time constraints
- Type of product or service being designed
- Depth of understanding needed

Offer the selected methods with guidance on when each works best, then ask which methods the user has used or can use, or make a recommendation based on the specific challenge.

Help gather and synthesize user insights:

- What did users say, think, do, and feel?
- What pain points emerged?
- What surprised you?
- What patterns do you see?

<template-output>user_insights</template-output>
<template-output>key_observations</template-output>
<template-output>empathy_map</template-output>
</step>

<step n="3" goal="DEFINE - Frame the problem clearly">
<energy-checkpoint>
Check in: "We've gathered rich user insights. How are you feeling? Ready to synthesize them into problem statements?"
</energy-checkpoint>

Transform observations into actionable problem statements.

Guide the user through problem framing:

1. Create a Point of View statement: "[User type] needs [need] because [insight]"
2. Generate "How Might We" questions that open solution space
3. Identify key insights and opportunity areas

Ask probing questions:

- What's the real problem we're solving?
- Why does this matter to users?
- What would success look like for them?
- What assumptions are we making?

<template-output>pov_statement</template-output>
<template-output>hmw_questions</template-output>
<template-output>problem_insights</template-output>
</step>

<step n="4" goal="IDEATE - Generate diverse solutions">
Facilitate creative solution generation. Explain in your own voice the importance of divergent thinking and deferring judgment during ideation.

Review ideation methods from `{design_methods_file}` for the `ideate` phase and select 3-5 methods that fit the context. Consider:

- Group versus individual ideation
- Time available
- Problem complexity
- Team creativity comfort level

Offer the selected methods with brief descriptions of when each works best.

Walk through the chosen method or methods:

- Generate at least 15-30 ideas
- Build on others' ideas
- Go for wild and practical
- Defer judgment

Help cluster and select top concepts:

- Which ideas excite you most?
- Which ideas address the core user need?
- Which ideas are feasible given the constraints?
- Select 2-3 ideas to prototype

<template-output>ideation_methods</template-output>
<template-output>generated_ideas</template-output>
<template-output>top_concepts</template-output>
</step>

<step n="5" goal="PROTOTYPE - Make ideas tangible">
<energy-checkpoint>
Check in: "We've generated lots of ideas. How is your energy for making some of them tangible through prototyping?"
</energy-checkpoint>

Guide creation of low-fidelity prototypes for testing. Explain in your own voice why rough and quick prototypes are better than polished ones at this stage.

Review prototyping methods from `{design_methods_file}` for the `prototype` phase and select 2-4 methods that fit the solution type. Consider:

- Physical versus digital product
- Service versus product
- Available materials and tools
- What needs to be tested

Offer the selected methods with guidance on fit.

Help define the prototype:

- What's the minimum needed to test your assumptions?
- What are you trying to learn?
- What should users be able to do?
- What can you fake versus build?

<template-output>prototype_approach</template-output>
<template-output>prototype_description</template-output>
<template-output>features_to_test</template-output>
</step>

<step n="6" goal="TEST - Validate with users">
Design the validation approach and capture learnings. Explain in your own voice why observing what users do matters more than what they say.

Help plan testing:

- Who will you test with? Aim for 5-7 users.
- What tasks will they attempt?
- What questions will you ask?
- How will you capture feedback?

Guide feedback collection:

- What worked well?
- Where did they struggle?
- What surprised them, and you?
- What questions arose?
- What would they change?

Synthesize learnings:

- What assumptions were validated or invalidated?
- What needs to change?
- What should stay?
- What new insights emerged?

<template-output>testing_plan</template-output>
<template-output>user_feedback</template-output>
<template-output>key_learnings</template-output>
</step>

<step n="7" goal="Plan next iteration">
<energy-checkpoint>
Check in: "Great work. How is your energy for final planning and defining next steps?"
</energy-checkpoint>

Define clear next steps and success criteria.

Based on testing insights:

- What refinements are needed?
- What's the priority action?
- Who needs to be involved?
- What sequence makes sense?
- How will you measure success?

Determine the next cycle:

- Do you need more empathy work?
- Should you reframe the problem?
- Are you ready to refine the prototype?
- Is it time to pilot with real users?

<template-output>refinements</template-output>
<template-output>action_items</template-output>
<template-output>success_metrics</template-output>

<action>Run: `python3 {project-root}/_bmad/scripts/resolve_customization.py --skill {skill-root} --key workflow.on_complete` — if the resolved value is non-empty, follow it as the final terminal instruction before exiting.</action>
</step>

</workflow>