From 9df2cec104621d436e0f4049c808757f9d461cf4 Mon Sep 17 00:00:00 2001 From: sanbuphy Date: Wed, 25 Mar 2026 17:40:30 +0800 Subject: [PATCH] =?UTF-8?q?docs:=20=E6=96=B0=E5=A2=9E=E9=99=84=E5=BD=95?= =?UTF-8?q?=E3=80=8C=E5=88=9B=E6=84=8F=E6=9D=A5=E6=BA=90=E3=80=8D=E7=AB=A0?= =?UTF-8?q?=E8=8A=82=E5=B9=B6=E4=BC=98=E5=8C=96=E6=96=87=E6=A1=A3=E6=A0=BC?= =?UTF-8?q?=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/.vitepress/config.mjs | 4 + docs/en/stage-0/index.md | 5 + .../stage-1/appendix-double-diamond/index.md | 528 +++++++++++------- .../en/stage-1/appendix-idea-sources/index.md | 301 ++++++++++ .../stage-1/appendix-jobs-to-be-done/index.md | 8 +- docs/en/stage-1/appendix-mom-test/index.md | 382 +++++++------ docs/public/sitemap.xml | 20 +- .../stage-1/appendix-double-diamond/index.md | 6 +- .../stage-1/appendix-jobs-to-be-done/index.md | 6 +- docs/zh-cn/stage-1/appendix-mom-test/index.md | 6 +- 10 files changed, 884 insertions(+), 382 deletions(-) create mode 100644 docs/en/stage-1/appendix-idea-sources/index.md diff --git a/docs/.vitepress/config.mjs b/docs/.vitepress/config.mjs index be4958c..1e1d556 100644 --- a/docs/.vitepress/config.mjs +++ b/docs/.vitepress/config.mjs @@ -389,6 +389,10 @@ const productManagerSidebarEn = [ text: 'Appendix: User Research and Validation', collapsed: false, items: [ + { + text: 'Where to Find Ideas: 3 Beginner-Friendly Sources', + link: '/en/stage-1/appendix-idea-sources/' + }, { text: 'Jobs to Be Done', link: '/en/stage-1/appendix-jobs-to-be-done/' diff --git a/docs/en/stage-0/index.md b/docs/en/stage-0/index.md index 337500b..c62304f 100644 --- a/docs/en/stage-0/index.md +++ b/docs/en/stage-0/index.md @@ -92,6 +92,11 @@ Master the Vibe Coding workflow, learn to deconstruct requirements, and independ - When you want to define the problem better before jumping into a solution + @@ -15,407 +15,535 @@ const duration = 'About 1.5 hours' -One of the most common beginner mistakes is not a lack of effort. It is moving to solutions too fast. +One of the most common beginner mistakes in product work is not "not trying hard enough." It is moving into solutions too fast. -You get an idea, then immediately start sketching pages, features, AI integrations, buttons, and flows. Later you realize the real issue was never clear in the first place: is this even the right problem, and is it worth solving now? +The moment an idea appears, people start thinking about screens, buttons, AI integrations, login flows, and prototype tools. Then after a lot of work, they realize the most basic question was never clear: does the user really have this pain point, and is it worth solving now? What feels like project progress is sometimes just accelerating very quickly in the wrong direction. -That is exactly what the **Double Diamond** helps prevent. +That is exactly what the **Double Diamond** is designed to prevent. + +Its most valuable reminder is this: **"choosing the right thing to do" and "doing the thing right" are two different stages.** If the problem is still unclear and you rush into prototyping, you usually just make the wrong direction more complete. ::: info Minimal SOP -**Goal**: After this, you should be better at knowing when to think about the problem first and when to start designing solutions. +**Goal**: After this, you should be much clearer about when to think about the problem first and when to start designing solutions and prototypes. -**Action**: Move through `Discover → Define → Develop → Deliver`, and only do the work that belongs to the current stage. +**Action**: Move through `Discover → Define → Develop → Deliver`, and only do the kind of work that belongs to the current stage. -**Result**: You will leave with a clearer problem definition, a few comparable solution directions, and a more realistic first validation cut. +**Result**: You will leave with a clearer problem definition, several comparable solution directions, and one testable first version. -**Quick links**: [What it is](#dd-what) · [The first diamond](#dd-first) · [How AI can help](#dd-ai) +**Quick links**: [What the Double Diamond is](#dd-what) · [The first diamond](#dd-first) · [How AI can help](#dd-ai) ::: ## What You Will Learn -1. What the Double Diamond is and why it helps beginners +1. What the Double Diamond is, and why it is especially useful for beginners 2. What Discover, Define, Develop, and Deliver actually mean -3. How to tell whether you should still be exploring or should start narrowing -4. How to use the Double Diamond in AI products, prototyping, and validation +3. How to tell whether you should still be expanding or whether it is time to narrow down +4. How to use the Double Diamond in AI products, prototype design, and demand validation -## 1. What the Double Diamond Is [↩ Back to top](#top-dd) +## [1. What the Double Diamond Really Is](#top-dd) -The Double Diamond is a design process framework popularized by the UK **Design Council**. +The Double Diamond is a classic design process framework promoted by the UK **Design Council**. It represents a full design and innovation process as two connected diamond shapes. -It divides the process into four stages: +It is called a "diamond" because each diamond contains two opposite but equally important motions: -1. **Discover** -2. **Define** -3. **Develop** -4. **Deliver** +- **diverge**: open the view and look at more possibilities +- **converge**: narrow the scope and make choices -It is called a “double diamond” because it includes two cycles of: +The full process has four steps: -- divergence: opening up possibilities -- convergence: narrowing and choosing +1. **Discover**: broadly understand users, problems, context, and market +2. **Define**: extract the core problem that is actually worth solving +3. **Develop**: explore multiple solution directions around that problem +4. **Deliver**: choose, prototype, test, and deliver the more suitable solution -In simple language: +If you want the shortest way to remember it: -- the first diamond is about choosing the right problem -- the second diamond is about building the right solution +- **the first diamond**: first figure out what problem is really worth solving +- **the second diamond**: then decide what kind of solution should solve it -## 2. Why It Matters for Beginners +That is why a very accurate summary is: -Beginners often do this: +- **first diamond: choose the right thing to do** +- **second diamond: do that thing right** + +## 2. Why the Double Diamond Is Especially Useful for Beginners + +The most common beginner rhythm looks like this: - get an idea +- feel that the direction sounds exciting - start prototyping immediately - keep adding more features -- lose track of the real problem +- eventually lose track of the actual problem -The Double Diamond helps by separating two very different questions: +The value of the Double Diamond is not that it makes the process more complicated. It **forces you to separate "understanding the problem" from "designing the solution."** -- What problem is worth solving? -- What solution is best for that problem? +That sounds obvious, but it matters a lot. Many failed products were not badly executed. They failed because: -Many failed products are not weak because people did not work hard. They fail because they polished the wrong thing. +- they chose the wrong problem +- they misunderstood the user +- they locked in a solution too early +- they spent a lot of time polishing detail before validating direction + +The Double Diamond keeps reminding you: + +- do not assume a problem is real just because the idea is easy to imagine +- do not assume something is worth building just because it is technically buildable +- do not assume a prototype matters just because it looks complete -## 3. The First Diamond: Choose the Right Problem [↩ Back to top](#top-dd) +## [3. The First Diamond: Choose the Right Thing to Do](#top-dd) -The first diamond is about the **problem space**, not the solution space. +The first diamond is about the **problem itself**, not the solution. -You can translate it as: +You can translate it into one simple sentence: -**before building, first make sure this is worth building.** +**before building, first make sure this is worth building at all.** -### 3.1 Discover +### 3.1 Discover: Open up the problem space first -This is the broad exploration stage. +The core task in Discover is **broad research, not quick conclusions.** -You look at: +Typical work in this phase includes: -- what users actually do -- when the pain shows up -- what workarounds they use now -- what other products or substitutes already exist -- what constraints, environments, or process details shape the problem +- watching how users behave in real situations +- interviewing potential users and asking when the problem last happened +- seeing how they currently patch the issue together +- checking how competitors and substitutes handle it +- collecting context about market, workflow, constraints, and surrounding systems -The goal is not to rush to a conclusion. The goal is to avoid acting as if you already know the answer. +Many people think Discover just means "read more things." But the more important part is this: **you need to understand people and situations, not just collect information.** -### 3.2 Define +For example, imagine you want to build an AI tool for organizing meeting notes. In Discover, the better questions are: -This is the narrowing stage. +- what exactly feels painful after a meeting +- is the hard part recording, organizing, or syncing +- are people writing notes themselves, asking interns to do it, listening to recordings later, or simply skipping documentation +- which meeting types really need notes, and which ones do not -You turn a broad topic into a focused problem definition. +The main goal in Discover is not to get the answer right away. It is to **avoid assuming too early that you already know the answer.** -For example: +### 3.2 Define: Extract the core problem from a pile of information -- too broad: “I want to improve resume writing” -- more useful: “Students applying for internships often delay submitting because they are unsure whether their resume is good enough” +If Discover opens the view, Define starts to narrow it. -Now the direction is more actionable: +Define is not about preserving every observation. It is about asking: + +- which problem is most worth solving first +- which problem shows up most often, hurts most, or matters most +- which single situation version one should focus on + +The core of this phase is turning a broad topic into one clear problem definition. + +For example, maybe you start with: + +> I want to build an AI tool that improves meeting efficiency. + +By the time you reach Define, a much stronger version might be: + +> We will first solve the problem that project teams often cannot produce a shareable meeting note with action items, owners, and deadlines within 10 minutes after a 30-60 minute collaboration meeting. + +At that point, the problem is starting to become clear: - who the users are -- in what situation the problem appears -- where they get stuck +- what the situation is +- where the bottleneck is - what success would look like -## 4. The Second Diamond: Build the Right Solution +The essence of Define is this: **go from "there are many problems" to "this is the one problem we will solve first."** -Once the first diamond is done, you can move into solutions without drifting as much. +## 4. The Second Diamond: Do the Thing Right -### 4.1 Develop +Only after you complete the first diamond does it make sense to move fully into the second. By then, you are not solving a vague direction anymore. You are solving a specific problem that has already been narrowed down. -Now you explore multiple solution directions: +### 4.1 Develop: Explore multiple solutions around the same problem -- checklist -- AI rewrite tool -- feedback tool -- example library -- role comparison view +The focus in Develop is **to expand the solution space around one defined problem.** -The goal here is not to fall in love with the first idea. It is to open the solution space while keeping the problem fixed. +This kind of divergence is different from Discover: -### 4.2 Deliver +- Discover expands the problem space +- Develop expands the solution space -This is where you narrow again: +Still using the meeting-note example, in Develop you can ask: -- choose the most testable direction -- build the smallest useful version -- test it with real people +- should this be a web tool or a meeting plugin +- should it process recordings after the meeting or work in real time +- should it focus only on summary, or mainly on extracting action items +- should it optimize for personal productivity or team sync +- should the user edit freely, or should the product output a structured template directly -Deliver does not have to mean “launch the full product.” It can be: +This is a good phase for brainstorming, comparison, and co-creation. -- a flow sketch -- a low-fidelity prototype -- a tiny MVP +But there is an important precondition: **all of these solution directions must still serve the same defined problem.** +If the problem is not clear, Develop quickly turns back into random feature sprawl. + +### 4.2 Deliver: Choose, prototype, test, and put the solution into reality + +Deliver is the convergence phase inside the second diamond. + +At this stage, you are no longer trying to imagine more possibilities. You are making choices: + +- which direction fits the current stage best +- which version is smallest but still useful +- which features are necessary first and which can wait +- how to prototype, test, and validate with a smaller group + +Many people think Deliver means "launch." A more accurate way to understand it is this: + +**turn one solution into something testable, usable, and improvable.** + +That could be: + +- a low-fidelity flow diagram +- a Figma prototype +- a working MVP - a small user test +- a revised version after one round of feedback -What matters is that the solution becomes testable. +The point of Deliver is not perfection. It is to **get the solution into a real environment quickly enough to validate it.** -## 5. A Simple Comparison Table +## 5. A Comparison Table That Is Easy to Remember -| Stage | What you are doing | Keywords | Typical outputs | +If you keep mixing up the four stages, this table is the easiest version to remember: + +| Stage | What you are doing | Keywords | Common outputs | | --- | --- | --- | --- | -| Discover | Understanding the problem | research, observation, interviews | notes, patterns, pain points | -| Define | Narrowing the problem | synthesis, prioritization, framing | problem definition, target slice | -| Develop | Expanding solution directions | brainstorming, comparison, prototyping ideas | multiple concepts, rough flows | -| Deliver | Narrowing and testing | prototype, test, iterate | prototype, user feedback, validation cut | +| Discover | Understanding the problem | research, observation, interviews, collecting information | user insight, context notes, problem list | +| Define | Defining the problem | synthesis, focus, tradeoff, rewriting the problem | problem statement, priority, MVP cut | +| Develop | Exploring solutions | brainstorming, comparison, co-creation, prototype directions | solution list, flow sketches, prototype directions | +| Deliver | Validating solutions | prototype, test, iteration, delivery | prototype, test feedback, improved version | -If you want the shortest version: +You can compress it even further: -- **Discover / Define** = choose the right problem -- **Develop / Deliver** = build the right solution +- **Discover / Define**: choose the right thing to do +- **Develop / Deliver**: do that thing right ## 6. Common Double Diamond Mistakes -### 6.1 Jumping to Deliver before Discover +### 6.1 Jumping into Deliver before doing Discover -This is the classic one: people build screens and flows before they even know whether the problem deserves attention. +This is the most common one. People get an idea and immediately start drawing screens, writing PRDs, integrating models, or building pages. -### 6.2 Staying in Discover forever +The problem is not that they are not serious. The problem is that they may not even know whether the problem is worth solving. -The opposite mistake is endless research with no convergence. The Double Diamond is not “keep exploring forever.” It is “explore, then decide.” +### 6.2 Staying in Discover for too long and never reaching Define -### 6.3 Quietly changing the problem to fit a favorite solution +The opposite mistake is endless research, endless reading, endless interviews, and no convergence. -Sometimes teams define a problem, then later shift the problem statement just to justify the solution they already wanted to build. +The Double Diamond is not telling you to expand forever. It is reminding you that after expansion, you must eventually make choices. -That is dangerous because you may stop solving the real problem and start defending a favorite idea. +### 6.3 Quietly changing the problem after Define -### 6.4 Treating Deliver as “build everything” +Some teams define a problem, but during Develop they discover that a certain solution is easier to build. Then they quietly rewrite the problem so it fits their preferred solution. -Deliver does not mean a complete polished product. A useful prototype or a small validation test can already be a strong deliverable. +That is dangerous. At that point, you may no longer be solving the real problem. You may be defending a favorite implementation. -## 7. How This Helps in AI Products +### 6.4 Treating Deliver as "build everything" -AI products are especially vulnerable to “capability-first” thinking because the technology looks exciting. +Deliver does not mean shipping a huge complete product. Often, a testable prototype or one round of real user testing is already a strong deliverable. -It is easy to jump to: +## 7. How to Use the Double Diamond in AI Products -- Should we add multimodal support? -- Should we build an agent? -- Should we connect a workflow engine? -- Should we add voice, image, web search? +AI products are especially likely to fall into capability-first thinking because model capabilities are so tempting. It is very easy to jump straight to: -The Double Diamond helps you ask first: +- should we add multimodal input +- should we build an agent +- should we connect workflow automation +- should we add voice, image, or web search -- where are users genuinely stuck? -- is this a place where AI is actually necessary? -- what is weak about the current workaround without AI? -- what progress would AI make possible here? +The Double Diamond forces you to ask first: -That protects you from a common failure mode: +- where are users actually stuck +- is this bottleneck something AI is truly needed for +- without AI, what is so weak about the current method +- if AI is added, what real progress does it create + +That helps you avoid a very common failure mode: **high capability, low value.** -## 8. A Template You Can Use Right Away +A practical sequence looks like this: -If you are working on your own product, you can write through the stages like this. +1. in Discover, observe how users currently handle the task +2. in Define, write the most painful scenario as one clear problem statement +3. in Develop, compare which AI capabilities best serve that problem +4. in Deliver, build a small first version and test it with real users + +## 8. A Double Diamond Template You Can Reuse + +If you are working on your own product, you can write through the stages in this order: ### Discover - Who are the users I am observing? - When did they last experience this problem? -- What do they do now? -- What feels slow, painful, or risky? +- How do they solve it now? +- What feels most annoying, slow, or risky? ### Define -- Which problem is most worth prioritizing? +- Out of all these problems, which one is most worth solving first? - Which situation is most frequent or most important? -- Who does version one serve, and what exactly does it solve? -- What changes for the user if we solve it well? +- Who exactly does version one serve, and what exactly does it solve? +- If we solve it well, what change happens in the user's state? ### Develop -- What solution directions are possible? -- Which are the lightest, fastest, and easiest to validate? -- What is essential now, and what can wait? +- What solution directions are possible for this problem? +- Which directions are lightest, fastest, and easiest to validate? +- Which parts are essential now, and which can wait? ### Deliver -- What is the smallest useful thing we can put in front of users? -- Is it a sketch, prototype, or MVP? +- What is the smallest thing we can deliver to validate this direction? +- Is it a flow sketch, a prototype, or an MVP? - Who do we need to test with? -- What would make us continue, change direction, or stop? +- After testing, how will we decide whether to continue, change, or stop? -## 9. A Beginner-Friendly Example +## 9. A Full Example a Beginner Can Understand -Suppose you want to build an AI tool that helps students prepare resumes for job applications. +Suppose you want to build an AI tool that helps college students prepare job-application resumes. -Many people would jump straight into the second diamond and start asking: +Many people would immediately jump into the second diamond and start asking: -- should there be one-click beautification? -- should there be AI rewriting? -- should it auto-match job descriptions? -- should it generate self-introductions? +- should there be one-click beautification +- should there be smart rewriting +- should it auto-match the job description +- should it generate self-introductions -The Double Diamond suggests a better process. +But with the Double Diamond, a stronger process looks like this: ### First diamond **Discover** -- talk to recent graduates about the last time they edited a resume -- watch how they move from an old resume to a new version -- see whether their pain is “I can't write,” “I can't revise,” or “I can't judge quality” +- talk to recent graduates about the last time they revised a resume +- watch how they turn an old version into a new one +- figure out whether their biggest issue is "I cannot write," "I cannot revise," or "I cannot judge quality" **Define** -- narrow down to something more concrete -- not “students cannot make resumes” -- but “students applying for internships for the first time struggle to turn existing experiences into role-fit wording, so they delay applying” +- narrow it into a more specific problem +- not "students cannot make resumes" +- but "students applying for internships for the first time struggle to rewrite existing experiences into role-fit wording, so they delay applying" ### Second diamond **Develop** -- compare directions: templates, AI rewriting, job comparison, resume scoring, examples +- compare several directions: template library, AI rewriting, role comparison, resume scoring, example references **Deliver** -- build only one narrow version first, such as “rewrite bullet points using a job description” -- test it with five students and see whether it helps them submit faster +- build only one narrow first version, such as "rewrite resume bullet points based on a job description" +- let five students test it and see whether it helps them submit a first version faster -When the first diamond is solid, the second diamond becomes much clearer. +Once the first diamond is solid, the second diamond becomes much clearer. ## 10. Summary -The real strength of the Double Diamond is that it breaks a messy process into four clearer moves: +The strongest part of the Double Diamond is that it breaks one big messy process into four clearer moves: -- first expand the problem space -- then narrow the problem definition -- then expand the solution space -- finally narrow toward delivery +- first expand to understand the problem +- then narrow to define the problem +- then expand to explore solutions +- finally narrow to deliver the solution -It does not make you slower. It helps you avoid spending a lot of energy on the wrong direction. +It does not make you slower. It helps you **avoid many detours that look busy but are moving in the wrong direction.** -This matters even more in the AI era, because building things is getting easier. When making becomes cheap, choosing the right problem becomes even more valuable. +This matters even more in the AI era because building things is getting easier and faster. When "making something" becomes cheap, the scarcer skill becomes this: **are you solving a problem worth solving, and are you solving it in an appropriate way?** + +If you remember only one sentence, remember this: + +**first choose the right thing to do, then do that thing right.** -## 11. How AI Can Help You Use the Double Diamond [↩ Back to top](#top-dd) +## [11. How AI Can Help You Run the Double Diamond](#top-dd) -AI is useful here not as the decision-maker, but as a helper for research, synthesis, and comparison. +The Double Diamond is not an AI tool, but AI works very well as an accelerator inside all four stages. The key is not to let AI decide for you. The key is to let it help you expand the view, organize information, compare directions, and generate validation material. -### 11.1 Discover: Build a rough problem map +### 11.1 In Discover, use AI to build a rough problem map first -Before interviews and deeper research, AI can help you scan the problem space: +Before formal interviews and deeper research, AI can help you do a lightweight scan of the space, for example: -- common substitutes -- frequent public complaints -- typical situations and user groups -- what current tools ignore +- what common substitutes already exist +- what users complain about most in public communities +- which scenarios and user groups this problem shows up in +- what current products often ignore -Simple input: +This cannot replace real research, but it is very useful for creating a first map of the space. + +A simple beginner prompt could be: ```text -I want to build something that helps students improve resumes. -Do not give me features yet. -First help me map the most common problems people seem to face. +I want to build a tool that helps college students improve resumes. +Do not help me think about features yet. +First help me figure out what problems people most often run into here. ``` Possible AI output: ```text Initial problem map: -1. Not knowing what to include -2. Not knowing how to tailor for different roles -3. Not knowing when the resume is good enough -4. Depending on others for feedback -5. Delaying applications because of uncertainty + +1. They do not know what experiences to include +2. They do not know how to tailor the resume to different roles +3. They revise many times and still do not know if it is good enough +4. They need someone else to review it, but cannot always ask +5. Because they feel unsure, they keep delaying applications ``` -This does not replace research, but it helps you enter Discover faster. +That kind of output is not there to replace your judgment. It helps you enter Discover faster. -### 11.2 Define: Narrow the problem +### 11.2 In Define, use AI to narrow the problem statement + +After collecting a lot of information, one of the hardest things is turning it into one really clear problem statement. You can give research notes to AI and ask it to compress them into candidate definitions: ```text -Here are the issues I collected: -1. people don't know what to write -2. people don't know how to revise -3. people keep delaying because they are unsure it is good enough +Below are user notes and research notes I collected during Discover: +[paste the content] -Help me decide which one is the best first problem to focus on. +Please do 3 things: +1. summarize the most common problem patterns +2. based on frequency, pain, and ease of validation, suggest 3 problems worth prioritizing +3. write each problem as one clear problem statement +``` + +You can keep the input very simple too: + +```text +These are the issues I collected: +1. people do not know what to write on the resume +2. people do not know how to revise it +3. people keep feeling it is not good enough, so they do not apply + +Please help me decide which problem is the best first one to solve. ``` Possible AI output: ```text Recommended first problem: -"Students applying for internships delay applications because they cannot tell when their resume is good enough to submit." + +"Students applying for internships for the first time are unsure whether their resume has reached a submit-ready level, so they keep revising and delay applying." + +Reasons: +1. it is more concrete +2. it explains the delay behavior +3. it is easier to test with a smaller first version ``` -That kind of output is useful because it turns a pile of fuzzy issues into a more testable first problem. +That is useful because it helps you narrow a fuzzy set of issues into something closer to an MVP starting point. -### 11.3 Develop: Generate multiple directions +### 11.3 In Develop, use AI to expand multiple solution directions + +Once people define a problem, they often fixate immediately on the first solution that comes to mind. AI is very useful here as a forced divergence tool: ```text -My problem definition is: -"Students delay applications because they are unsure whether their resume is ready." +I have defined this core problem: [your problem statement] +Please do not give me only one final answer. +Instead, propose 2-3 solution directions from each of these angles: +1. the lightest MVP +2. the best option for validating demand +3. the best option for improving user experience +4. a non-AI solution +5. an AI-based solution -Please suggest 4 different solution directions. +At the end, compare the strengths, risks, and validation cost of each direction. +``` + +That stops you from getting trapped by one favorite solution too early. + +A simpler prompt could be: + +```text +My problem statement is: +"Students delay applying because they are not sure whether their resume is ready." + +Please suggest 4 different solution directions, not just one. ``` Possible AI output: ```text -1. Resume readiness checklist -2. Role-specific rewrite assistant -3. Risk and gap detector -4. Example comparison library +Option 1: resume readiness checklist +Option 2: job-description-based rewrite assistant +Option 3: resume risk detector +Option 4: example comparison library ``` -This helps you compare rather than overcommit too early. +Now you are in comparison mode instead of only staring at one AI rewriting path. -### 11.4 Deliver: Generate a lightweight test script +### 11.4 In Deliver, use AI to generate prototype copy and testing material + +Once you reach Deliver, AI is very useful for speeding up work like: + +- writing copy for low-fidelity prototypes +- organizing user test scripts +- generating multiple versions of titles, buttons, and instructions +- summarizing test feedback and issue lists + +For example, you can ask AI to generate a 20-minute user test script, or summarize five pieces of feedback into a decision frame like "continue / revise / pause." + +A very small input could be: ```text -I built a simple prototype where users upload a resume and get "not ready yet" feedback. +I made a very simple prototype: +the user uploads a resume, and the system tells them which parts are not yet ready for submission. + Please generate a 15-minute user testing script. ``` Possible AI output: ```text -15-minute test script: +15-minute user testing script: -1. Ask the user to describe their last resume-editing experience -2. Let them upload a resume on their own -3. Observe whether the feedback is understandable -4. Ask which parts feel useful and which parts feel confusing -5. Ask whether they would want to use this before their next application +1. Ask the user to describe their most recent resume submission experience +2. Let them upload a resume independently +3. Observe whether they understand the feedback +4. Ask which parts feel helpful and which parts feel confusing +5. Ask whether they would want to use this again before the next application ``` -### 11.5 Use AI as a stage guard +That is useful because it moves you from "I finished the prototype" to "how do I actually test this?" -One of the biggest Double Diamond risks is jumping stages. AI can help by acting like a process coach: +### 11.5 Let AI act as a stage guard + +One of the biggest risks in the Double Diamond is that people skip stages. You can directly ask AI to act like a process guard: ```text -Act as a product process coach. +Please act as a product process coach. Here is my current project state: [your description] -Please tell me whether I am mainly in Discover, Define, Develop, or Deliver. -Also tell me: -1. whether I am jumping too early -2. what the most important action in this stage is +Please judge whether I am mainly in Discover, Define, Develop, or Deliver. +Then tell me: +1. whether I am jumping ahead too early +2. what the most important action in the current stage is 3. what I should not do yet ``` -That is especially useful for beginners who tend to prototype before the problem is clear. +That is especially helpful for beginners because it is very easy to start prototyping before the problem is truly clear. ## Assignments -1. Pick one product idea and map it into Discover, Define, Develop, Deliver -2. Write one clear problem definition -3. Generate at least 3 different solution directions -4. Define one small validation version you could test within a week +1. Pick one product idea you have been thinking about and write a draft for its Discover, Define, Develop, and Deliver stages +2. In Define, force yourself to compress the problem into one concrete sentence +3. In Develop, list at least 3 different solution directions instead of clinging to the first one +4. In Deliver, write down one smallest validation version you could ship within a week ## Further Reading +This article mainly draws on the Design Council's official material about the Double Diamond. These are good places to continue: + - [Design Council: The Double Diamond](https://www.designcouncil.org.uk/our-resources/the-double-diamond/) - [Design Council: Framework for Innovation](https://www.designcouncil.org.uk/our-work/skills-learning/tools-frameworks/framework-for-innovation-design-councils-evolved-double-diamond/) - [Design Council: History of the Double Diamond](https://www.designcouncil.org.uk/our-resources/the-double-diamond/history-of-the-double-diamond/) diff --git a/docs/en/stage-1/appendix-idea-sources/index.md b/docs/en/stage-1/appendix-idea-sources/index.md new file mode 100644 index 0000000..c0ba98e --- /dev/null +++ b/docs/en/stage-1/appendix-idea-sources/index.md @@ -0,0 +1,301 @@ +--- +title: 'Where to Find Ideas: 3 Beginner-Friendly Sources' +description: 'A beginner-friendly guide to product idea discovery. This appendix focuses on websites for browsing idea lists, trend sources, real business signals, and VC requests so you can find a more concrete direction faster.' +--- + + + +# Where to Find Ideas: 3 Beginner-Friendly Sources + + + +## Introduction + + + +Many people do not get stuck because they have zero inspiration. They get stuck because after reading a lot of content, what remains in their head is still a big label: + +- AI for education +- AI for healthcare +- AI for finance +- AI agent for business + +Those are not product ideas yet. They only say the direction is broad. They do not tell you: + +- who the user is +- in what situation they need help +- what they do today to hold the workflow together +- which step is worth cutting into first + +This article does not spend time on abstract theory. It gives you a more practical set of sources. + + + +::: info Minimal SOP +**Goal**: After this, you should know where to browse when you have no clear idea yet, which links are better for concrete demand, which are better for trends, and which are closer to real business signals. + +**Action**: Browse one round of idea lists, one round of small profitable products, then a round of trend and business sources. Keep only one direction you still want to investigate. + +**Result**: You will leave with one more concrete direction worth validating instead of a broad category. + +**Quick links**: [Reference apps](#idea-apps) · [Trend sources](#idea-trends) · [Business signals](#idea-business) · [VC / accelerator sources](#idea-vc) · [Shortest path](#idea-path) · [How AI can help](#idea-ai) +::: + +## What You Will Learn + +1. Which sites are best for directly browsing product ideas +2. Which sites are useful for studying small products that already make money +3. Which sources are better for spotting trends and industry movement +4. Which sources are closer to real business demand and real budgets +5. A shortest path that works well for beginners + + +## [1. Reference Apps: Start with Things People Are Already Building](#top-idea-sources) + +This is the best starting point for beginners because it is the most concrete. + +### Tier 1: Open the site and pick directly from idea lists + +- [Reddit — r/SomebodyMakeThis](https://www.reddit.com/r/SomebodyMakeThis/) + The core use of this subreddit is simple: real users post “I wish someone would build X.” Each post is usually one concrete product need, often with some situation context. A good way to browse is `Top -> Past Month` or `Top -> Past Year`. +- [Reddit — r/AppIdeas](https://www.reddit.com/r/AppIdeas/) + Similar to the one above, but more focused on software and apps. A lot of posts are basically “I need an app that can do X,” which makes the granularity easier for beginners. +- [Reddit — r/Startup_Ideas](https://www.reddit.com/r/Startup_Ideas/) + More complete than the first two. Many posts include not just the problem, but some quick market thinking or monetization logic. +- [Unvalidated Ideas](https://unvalidatedideas.com/) + Publishes startup ideas that are still unvalidated. The structure is consistent: target user, monetization angle, and a rough validation path. +- [IdeasAI](https://ideasai.com/) + AI-generated startup ideas you can browse endlessly. Quality is uneven, but it works well as a way to spark directions that you later narrow yourself. + +### Tier 2: Study small products that already make money and reverse-engineer the idea + +These platforms matter because they show you not just “someone wants this,” but “someone has already turned this into a product and maybe into revenue.” + +- [Starter Story](https://www.starterstory.com/) + Real small-business case studies with founder interviews, revenue data, and origin stories. The best entries to study are often not the giant successes, but the niche products making roughly $10k-$100k per month. +- [Indie Hackers — Products](https://www.indiehackers.com/products) + A place where indie makers show products, growth, and often revenue. Sort by revenue and look at products making a few thousand to a few tens of thousands a month. +- [MicroConf Blog](https://microconf.com/blog) + Strong for Micro SaaS. Useful if you want to learn what “small enough to build, but still worth paying for” looks like. +- [1000 Tools](https://1000.tools/) + An AI tool directory. Useful for checking which categories already exist, which ones feel weak, and which niches are still under-served in your region or industry. +- [Product Hunt](https://www.producthunt.com/) + Useful for watching what categories keep appearing repeatedly. Do not only watch the number one launch. Look for repeated product types with no clear dominant winner. +- [BetaList](https://betalist.com/) + Good for early-stage products and teams still exploring direction. + +### Do not only study the product itself. Study reviews and “done-for-you” services too + +- [G2](https://www.g2.com/) + Look at 1-star and 2-star reviews. Negative reviews often tell you exactly which step current products still handle badly. +- [Capterra](https://www.capterra.com/) + Similar use case to G2, especially for SaaS complaints and workflow friction. +- Taobao / Xianyu / [Fiverr](https://www.fiverr.com/) / [Upwork](https://www.upwork.com/) / ZBJ + Search for services like “done for you,” “organized for you,” “data entry,” “transcription,” and “manual cleanup.” If people keep paying humans to do it, there is often a repeatable workflow behind it. + +The signal you want is simple: + +- users are already complaining about current tools +- users are already paying someone to do the work manually +- users are already spending a lot of time and labor on the workflow + +### Another useful format: watch videos where someone breaks down ideas for you + +If you do not like browsing lists and forums, video and podcast formats can work better. + +- Search `Greg Isenberg startup ideas` + Good when you want someone to break down 2 or 3 concrete startup ideas with market size, competition, and entry angle. +- Search `My First Million podcast` + Strong for loose but high-density idea brainstorming. It often surfaces surprisingly specific niches. +- Search `YC startup ideas` or `Michael Seibel startup ideas` + Good for beginners because the explanations are usually direct and practical. + + +## [2. Trend Sources: See Which Directions Are Rising](#top-idea-sources) + +Trend sites are not there to hand you a product idea. They help you judge whether a direction is heating up and worth a closer look. + +- [Exploding Topics](https://explodingtopics.com/) + Tracks fast-growing topics and product categories before they fully hit the mainstream. Good for spotting things that are rising but not yet too crowded. +- [Google Trends](https://trends.google.com/) + Search a keyword, look at the trend line over the past year, then check the “related queries” section for breakout terms. +- [Glimpse](https://meetglimpse.com/) + Similar in spirit to trend products, but more consumer-oriented. Useful for product categories, consumption patterns, and rising lifestyle signals. +- Industry report summary pages + Useful when you already have a direction and want quick context on where it sits in the market. +- McKinsey / BCG / Gartner trend content + Better for B2B, traditional industries, enterprise, and industrial settings. +- [State of AI Report](https://www.stateof.ai/) + Useful when your direction is tightly tied to AI technology itself and you want a broader yearly map. + +When looking at trends, focus on only three things: + +- is the topic rising consistently +- what concrete scenario it falls into +- who would be the first to pay with time, switching cost, or budget + + +## [3. Business Signals: See Who Is Paying, Complaining, and Selling Manual Services](#top-idea-sources) + +If you want something more grounded than “this sounds cool,” you need sources closer to real workflows. + +### See who is already paying for what + +- [China Government Procurement Network](https://www.ccgp.gov.cn/) + Search terms like “smart construction site,” “lab management system,” “data collection,” “clinic management,” or “quotation system.” Look at budget, technical requirements, and workflow details. +- Provincial and municipal public resource trading centers + Useful for seeing what local governments and state-owned enterprises actually buy. +- Bidding platforms such as Bibiaowang, Qianlima, and Zhaobiatong + Useful for enterprise-side procurement and repeated system demand. + +The reason these sources matter is simple: they are not discussing the future. They reveal what someone is already willing to spend money on today. + +### See who is really complaining + +- Manufacturing: machinery communities and industrial control forums +- Healthcare: DXY, Yimatong +- Construction / engineering: Tumu, Glodon communities +- Finance / accounting: accounting forums +- Foreign trade: trade communities and export forums +- Retail / food service forums +- [Reddit](https://www.reddit.com/) vertical communities such as `r/smallbusiness`, `r/Entrepreneur`, `r/SaaS`, `r/healthcare`, `r/manufacturing` +- [V2EX](https://www.v2ex.com/) +- Jike +- Xiaohongshu + +Do not only search for terms like “AI” or “innovation.” Better searches are: + +- this is too annoying +- is there a better way +- recommend a tool +- Excel is no longer enough +- I wish there was +- is there a tool for +- I hate + +### See who is selling repeat manual labor + +- [Fiverr](https://www.fiverr.com/) +- [Upwork](https://www.upwork.com/) +- ZBJ +- Taobao +- Xianyu + +If you find these services selling well, it is usually worth looking deeper: + +- turning PDF quotations into Excel +- cleaning customer data in bulk +- editing resumes / copy / transcripts / archives + +These are rarely one-off needs. They are usually repeat workflows. + +### Study the full workflow, not just the idea list + +Sometimes the shortest path is to pick an industry, trace the workflow, and find the steps still running on WeChat, Excel, paper, or phone calls. + +- Foreign trade: finding suppliers, requesting quotes, price comparison, making quotations, sending them to clients, following up, inspections, booking shipment, customs. + A strong cut point: converting supplier quotes into customer-facing quotations. +- Dental clinics: intake, scans, diagnosis, treatment plans, follow-up, treatment, revisit. + A strong cut point: explaining treatment plans clearly and following up afterward. +- Construction sites: inspection, photos, chat groups, reports, delivery to the client. + A strong cut point: turning on-site photos into compliance reports. + + +## [4. VC / Accelerator Sources: See Where the Wave Is Moving](#top-idea-sources) + +These sources are useful for finding broader direction, but they do not replace validation. + +- [Y Combinator — Requests for Startups](https://www.ycombinator.com/rfs) + Good for concrete cuts because YC often says very directly: “we want to see someone build this.” +- [a16z — Big Ideas](https://a16z.com/big-ideas-2025/) + More useful for broad trend and category judgment. +- [NFX](https://www.nfx.com/) + Good for quickly scanning a set of startup directions. +- [Sequoia Capital](https://www.sequoiacap.com/article/) + Not always a direct idea list, but often useful for platform shifts and new opportunity framing. +- [First Round Review](https://review.firstround.com/) + Better for deeper thinking about a direction, not necessarily quick idea lists. + +The upside of these sources: + +- they tell you which directions may be worth watching +- they tell you which categories may keep getting pushed forward +- they help you enter the language of a category faster + +Their limitation: + +- they are usually investor-facing +- they do not always tell you which exact role feels the pain most +- they do not always tell you which workflow step is most broken +- they do not always tell you who is already paying today + +A better use pattern is: use them to find a direction, then go back to reference products, industry communities, procurement signals, and real workflows. + + +## [5. The Shortest Path for Someone Who Has No Clear Idea Yet and Only Knows How to Build "Assistants"](#top-idea-sources) + +If you only follow one path, make it this one: + +1. Step one, 30 minutes. + Open [r/SomebodyMakeThis](https://www.reddit.com/r/SomebodyMakeThis/), sort by `Top -> Past Year`, scan 50 posts, and save every direction that makes you think, “I might actually be able to build something here.” +2. Step two, 30 minutes. + Open [Starter Story](https://www.starterstory.com/) or [Indie Hackers Products](https://www.indiehackers.com/products), sort by revenue, and study the middle-income products, not just the biggest wins. Find products related to your saved directions and note who they sell to and which step they solve. +3. Step three, 20 minutes. + Use [Google Trends](https://trends.google.com/) to search the related keywords. Check whether the trend is rising and what the breakout related queries are. +4. Step four, 20 minutes. + Go to G2 / Capterra / industry forums / bidding platforms / Fiverr-type sites and check what part of the workflow still feels painful and manual today. + +After that, being able to say this one sentence is enough: + +- A certain type of user, in a certain situation, is stuck on a certain workflow step and is currently holding it together with a clumsy workaround. + + +## [6. How AI Can Help](#top-idea-sources) + +AI is not the center of this article, but it is very useful for organizing what you find. + +The two most practical uses are: + +- paste links, post titles, and user quotes into AI, and ask it to sort them into user group / situation / pain point / workaround +- ask AI to compress a pile of scattered notes into 3 candidate directions instead of expanding into 50 features + +You can ask like this: + +```text +I recently browsed these sources: +1. [paste title or quote] +2. [paste title or quote] +3. [paste title or quote] + +Please do not give me a feature list. +Only do 3 things: +1. group them by user type and situation +2. identify the workflow steps that keep showing up as painful +3. turn them into 3 more concrete candidate directions +``` + +## Further Reading + +- [Y Combinator - Requests for Startups](https://www.ycombinator.com/rfs) +- [a16z - Big Ideas](https://a16z.com/big-ideas-2025/) +- [NFX](https://www.nfx.com/) +- [Reddit - r/SomebodyMakeThis](https://www.reddit.com/r/SomebodyMakeThis/) +- [Reddit - r/AppIdeas](https://www.reddit.com/r/AppIdeas/) +- [Reddit - r/Startup_Ideas](https://www.reddit.com/r/Startup_Ideas/) +- [Starter Story](https://www.starterstory.com/) +- [Indie Hackers - Products](https://www.indiehackers.com/products) +- [Product Hunt](https://www.producthunt.com/) +- [BetaList](https://betalist.com/) +- [IdeasAI](https://ideasai.com/) +- [Unvalidated Ideas](https://unvalidatedideas.com/) +- [Google Trends](https://trends.google.com/) +- [Exploding Topics](https://explodingtopics.com/) +- [G2](https://www.g2.com/) +- [Capterra](https://www.capterra.com/) diff --git a/docs/en/stage-1/appendix-jobs-to-be-done/index.md b/docs/en/stage-1/appendix-jobs-to-be-done/index.md index b2aae64..0894310 100644 --- a/docs/en/stage-1/appendix-jobs-to-be-done/index.md +++ b/docs/en/stage-1/appendix-jobs-to-be-done/index.md @@ -48,7 +48,7 @@ This article explains JTBD in plain language and turns it into something you can 4. How JTBD connects to AI product thinking, interviews, and prompt-based analysis -## 1. What Jobs to Be Done Means [↩ Back to top](#top-jtbd) +## [1. What Jobs to Be Done Means](#top-jtbd) Jobs to Be Done, often shortened to **JTBD**, is built around a simple idea: users “hire” a product to get something done. @@ -99,7 +99,7 @@ On the surface, they are buying breakfast. In JTBD terms, they may really be try - avoid being hungry before arriving at work - keep their morning routine moving without disruption -The product they “hire” is not really a sandwich. It is a reliable way to keep the morning moving. +The thing they "hire" is not really one specific sandwich brand. It is a reliable way to keep the morning moving. The same logic applies to AI products. If you want to build an AI meeting summary tool, JTBD helps you step back from feature brainstorming and ask: @@ -178,7 +178,7 @@ What would make the user say this was truly helpful? If you cannot say what “useful enough” means, the direction is probably still not focused enough. -## 5. A One-Sentence Formula You Can Reuse [↩ Back to top](#top-jtbd) +## [5. A One-Sentence Formula You Can Reuse](#top-jtbd) Use this sentence pattern: @@ -337,7 +337,7 @@ your idea usually becomes much sharper. It also helps you avoid one of the biggest mistakes in AI products: falling in love with capability demos instead of user progress. -## 12. How AI Can Help You Practice JTBD [↩ Back to top](#top-jtbd) +## [12. How AI Can Help You Practice JTBD](#top-jtbd) JTBD is not an AI invention, but AI can be a very helpful research assistant, organizer, and challenger. The key is this: diff --git a/docs/en/stage-1/appendix-mom-test/index.md b/docs/en/stage-1/appendix-mom-test/index.md index e0b04ea..7ebbabf 100644 --- a/docs/en/stage-1/appendix-mom-test/index.md +++ b/docs/en/stage-1/appendix-mom-test/index.md @@ -1,6 +1,6 @@ --- title: 'The Mom Test: How to Validate Demand Through User Interviews' -description: 'A beginner-friendly introduction to The Mom Test. Learn how to stop collecting polite praise and start getting evidence from real behavior, real costs, and real user situations.' +description: 'A beginner-friendly introduction to The Mom Test. Learn how to avoid polite feedback, ask about real behavior and real costs, and turn “sounds good” into more reliable demand evidence.' ---