design-thinking-process
Skill4 starsChanged 3 months agoApache-2.0View on GitHub
Apply design thinking to product problems. Covers the 5-phase framework (Empathize, Define, Ideate, Prototype, Test), practical tools for each phase, integration with Agile, and artifact creation. Use when starting a new project, solving fuzzy problems, or facilitating workshops. Triggers on: "design thinking", "discovery", "product discovery", "user centered design", "workshop facilitation", "problem framing", "how might we", "design sprint".
We split this skill into the rules it gives an agent
5 rules. About 0 are common, 5 are distinctive, and 0 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈5
Distinctive · estimate
This author's own choices. Worth a look.
0
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 36
When you hear an interesting answer, ask "Why?" up to 5 times to get to the root cause.
- Distinctive: line 93
Prototype only what you need to test: If testing navigation, don't polish visuals.
- Distinctive: line 106
Test with 5 users — catches ~85% of usability issues (Nielsen)
- Distinctive: line 107
Don't defend your design — listen
- Distinctive: line 108
Look for patterns, not isolated issues
≈ “Common” is an estimate: at least 1 in 5 of the 308,232 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Design Thinking Process
A human-centered framework for solving fuzzy problems. Not a linear sequence — a set of modes you move between as you learn.
"Design thinking is 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." — Tim Brown, IDEO
The 5 Phases
1. Empathize — Understand the Human Need
Goal: Deep, emotional understanding of users' context, needs, and pain points.
Activities:
- User interviews (open-ended, 5-8 per segment)
- Contextual inquiry (observe in their environment)
- Diary studies (longitudinal, self-reported)
- Competitive analysis (how are they solving this now?)
Artifacts:
- Empathy map (Says, Thinks, Does, Feels)
- User personas (behavioral, not demographic)
- Journey map (current state, pain points highlighted)
Key technique — The 5 Whys: When you hear an interesting answer, ask "Why?" up to 5 times to get to the root cause.
"I don't use the reporting feature." → Why? → "It's too slow." → Why? → "I have to export to Excel first." → Why? → "The filters don't have what I need." → Root cause: Missing filter options.
2. Define — Frame the Problem
Goal: A clear, actionable problem statement that guides ideation.
Activities:
- Synthesize interview findings (affinity mapping)
- Identify patterns and themes
- Reframe problems as opportunities
Artifact — Point of View (POV) statement:
[User] needs to [need] because [insight]Example: "Small business owners need to reconcile invoices quickly because they spend 3 hours every Friday on bookkeeping instead of serving customers."
Key technique — "How Might We" (HMW): Turn problems into opportunities:
- "Users can't find settings" → "HMW make settings discoverable without cluttering the interface?"
- "The checkout is too long" → "HMW complete checkout in under 30 seconds?"
3. Ideate — Generate Many Solutions
Goal: Maximum quantity of ideas. Quality comes later.
Activities:
- Brainstorming (structured, time-boxed)
- Crazy Eights (8 sketches in 8 minutes)
- SCAMPER checklist (Substitute, Combine, Adapt, Modify, Put to another use, Eliminate, Reverse)
- Worst Possible Idea (reverse brainstorming to unlock creativity)
Rules:
- Defer judgment — no "that won't work" during ideation
- Build on others' ideas — "Yes, and..."
- Go for quantity — 100 ideas is better than 10
- Encourage wild ideas — they often spark practical ones
Artifact: Idea board with 20-50 ideas, grouped by theme.
4. Prototype — Make Ideas Tangible
Goal: Cheap, fast representations of the best ideas to test assumptions.
Fidelity Spectrum:
| Fidelity | When to Use | Tools |
| Paper | Early exploration, flow testing | Pen, paper, sticky notes |
| Low-fi digital | Structure and layout | Balsamiq, wireframes |
| Mid-fi digital | Interaction and flow | Figma clickable prototype |
| Hi-fi digital | Visual design, stakeholder buy-in | Figma, Principle |
| Coded | Technical feasibility, microinteractions | HTML/CSS/JS prototype |
Prototype only what you need to test. If testing navigation, don't polish visuals. If testing visual appeal, focus on look and feel.
5. Test — Learn from Real Users
Goal: Validate assumptions, find usability issues, refine understanding.
Structure:
- Welcome (2 min) — build rapport, set expectations
- Context questions (5 min) — understand their background
- Tasks (20-30 min) — observe without helping
- Debrief (5 min) — overall impressions
Key Rules:
- Test with 5 users — catches ~85% of usability issues (Nielsen)
- Don't defend your design — listen
- Look for patterns, not isolated issues
- One person struggling = noise; three people struggling = signal
Integration with Agile
| Timeframe | Activity | Output |
| Week 1-2 | Discovery Sprint (Empathize + Define) | Validated problem, HMW statements |
| Week 3 | Ideation + Prototyping Workshop | 3 testable prototypes |
| Week 4 | User Testing (Test) | Insights, validated concept |
| Week 5-6 | Development Sprint (Agile) | Working software |
| Ongoing | Continuous feedback | Iteration fuel |
Facilitation Tips
- Time-box everything — constraints drive creativity
- Include diverse perspectives — engineering, design, product, support
- Visualize everything — sticky notes, whiteboards, sketches
- No laptops/phones — full presence during workshops
- Vote with dots — silent, democratic prioritization
Reference Map
references/phase-tools-artifacts.md— tools, exit artifacts, fidelity, Agile shapereferences/hmw-and-pov.md— POV quality checks, HMW rules, 5 Whys bridge
Related Skills
- For user research methods detail → use
user-research-methods - For workshop facilitation → use this skill with
user-research-methods - For prototyping tools → use
interaction-design-patterns
In this repository80 other files it gives its agents.
- a11y-accessibility-designSkill
- agentic-ui-patternsSkill
- ai-native-ui-designSkill
- ai-ui-anti-patternsSkill
- ai-ui-heuristicsSkill
- calm-technology-uiSkill
- conversion-growth-designSkill
- cross-platform-designSkill
- dark-mode-designSkill
- data-visualizationSkill
- design-systemsSkill
- error-empty-statesSkill
- ethical-design-patternsSkill
- form-uxSkill
- information-architectureSkill
- interaction-design-patternsSkill
- internationalization-uiSkill
- mobile-touch-designSkill
- modal-classes-lifecycleSkill
- modal-container-imagesSkill
- modal-dicts-queuesSkill
- modal-endpointsSkill
- modal-fundamentalsSkill
- modal-gpu-computeSkill
- modal-networkingSkill
- modal-observabilitySkill
- modal-parallel-executionSkill
- modal-sandboxesSkill
- modal-scaling-performanceSkill
- modal-schedulingSkill
- modal-secretsSkill
- modal-serversSkill
- modal-storageSkill
- modal-web-servingSkill
- modal-workspace-adminSkill
- motion-design-principlesSkill
- notifications-permissionsSkill
- onboarding-uxSkill
- rust-api-designSkill
- rust-async-programmingSkill
- rust-cargo-masterySkill
- rust-cli-applicationsSkill
- rust-clippy-lintsSkill
- rust-closures-iteratorsSkill
- rust-compiler-internalsSkill
- rust-concurrencySkill
- rust-design-patternsSkill
- rust-editionsSkill
- rust-embeddedSkill
- rust-error-handlingSkill
- rust-game-developmentSkill
- rust-lifetimes-borrowingSkill
- rust-macrosSkill
- rust-performanceSkill
- rust-rustdocSkill
- rust-rustup-toolchainSkill
- rust-smart-pointersSkill
- rust-testing-benchmarkingSkill
- rust-type-systemSkill
- rust-unsafe-ffiSkill
- The first 60 shown.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

