#3910 Google Gemini GEM: Innovative Thinking Assistant
#3910 Google Gemini GEM: Innovative Thinking Assistant
#3910 List and describe 25 top innovative thinking methods
To organize these 25 innovative thinking methods effectively, I have categorized them into five distinct approaches: Structural, Perspective-Based, Visual/Associative, Nature & Analogy, and Strategic.
I. Structural & Engineering-Based Methods
These methods rely on logic, decomposition, and systematic changes to existing elements.
First Principles Thinking:
Breaking a problem down to its fundamental truths (physical constants or basic facts) and reasoning up from there, rather than reasoning by analogy ("doing what others do"). This is famous for driving costs down significantly (e.g., SpaceX).
TRIZ (Theory of Inventive Problem Solving):
A Russian algorithm-based approach for problem-solving. It utilizes a matrix of 40 principles to resolve technical contradictions (e.g., how to make something stronger without making it heavier).
SCAMPER:
A checklist tool used to modify existing ideas or products. The acronym stands for: Substitute, Combine, Adapt, Modify, Put to another use, Eliminate, and Reverse.
Morphological Analysis:
A method for exploring all possible solutions to a multi-dimensional, non-quantified complex problem. You break a system into dimensions (attributes) and list all possible states for each, then mix and match them to find new combinations.
The 5 Whys:
Iteratively asking "Why?" (usually five times) to peel away layers of symptoms and discover the root cause of a problem. Innovation often comes from solving the root rather than the symptom.
Attribute Dependency (SIT):
Part of Systematic Inventive Thinking. You list the internal and external variables of a product and try to create a new dependency between them (e.g., sunglasses that get darker as sunlight gets brighter).
II. Perspective & Role-Based Methods
These techniques force you to step out of your own bias and view the problem through different lenses.
Six Thinking Hats:
Developed by Edward de Bono, this separates thinking into six clear roles (White/Data, Red/Emotion, Black/Caution, Yellow/Optimism, Green/Creativity, Blue/Process) to prevent cognitive clutter and groupthink.
The Walt Disney Method:
A parallel thinking technique that moves a team through three specific roles:
The Dreamer: Unfiltered fantasy and "what if."
The Realist: How to make it technically and practically possible.
The Critic: Looking for flaws and risks in the plan.
Reverse Brainstorming:
Instead of asking how to solve a problem, you ask how to cause it. (e.g., "How can we make our customers hate us?"). Once you generate these "anti-solutions," you reverse them to find insights.
Jobs to be Done (JTBD):
Focusing not on the user or the product, but on the "job" the customer is hiring the product to do. Innovation comes from making the "job" easier (e.g., a milkshake isn't just a drink; it's hired to make a morning commute less boring).
Worst Possible Idea:
Intentionally seeking the terrible ideas first. This relieves the pressure of perfectionism and often leads to the discovery that a "bad" idea has a kernel of innovation that was previously ignored.
III. Visual & Associative Methods
These methods use spatial organization and random connections to trigger new neural pathways.
Mind Mapping:
A diagram used to visually organize information. It starts with a central concept and branches out into associated ideas, helping to spot connections between disparate concepts.
Lotus Blossom Technique:
A structured variation of mind mapping. You start with a central theme and create 8 surrounding themes. Each of those 8 becomes the center of a new blossom, rapidly expanding the depth of ideation.
Fishbone Diagram (Ishikawa):
Used primarily for root cause analysis, it visually maps out causes and effects. In innovation, it ensures you are innovating on the correct variable (People, Methods, Machines, Materials, Environment).
Storyboarding:
Borrowing from film production, this involves sketching the user’s experience with a product frame-by-frame. It helps visualize gaps in the user experience that text descriptions miss.
Random Word/Stimulus:
Picking a random noun from a dictionary and forcing a connection between that word and your problem. This forces the brain to make "lateral" jumps it wouldn't make logically.
IV. Nature & Analogy Methods
Looking outside the current industry or reality to find solutions.
Biomimicry:
Looking to nature to solve human problems. Nature has had 3.8 billion years of R&D. (e.g., Velcro was inspired by burrs sticking to dog fur; bullet trains were remodeled after Kingfisher beaks).
Synectics:
A problem-solving methodology that relies heavily on metaphors and analogies. It attempts to make the "strange familiar" and the "familiar strange" to gain new insights.
Science Fiction Prototyping:
Writing a short fiction story about the future where your technology or solution exists. This helps explore the ethical, social, and practical implications of an innovation before building it.
Cross-Industry Innovation:
Taking a proven solution from one industry and applying it to another. (e.g., How a hospital emergency room improved hand-offs by studying Formula 1 pit crews).
V. Strategic & Time-Based Methods
These methods deal with market positioning and temporal shifts.
Design Thinking:
A non-linear, iterative process that seeks to understand users, challenge assumptions, redefine problems, and create innovative solutions to prototype and test. Phases: Empathize, Define, Ideate, Prototype, Test.
Blue Ocean Strategy:
Instead of battling competitors in a saturated market (Red Ocean), you create a new market space (Blue Ocean) by making the competition irrelevant. You do this by altering the value curve—raising some features while eliminating others.
Backcasting:
Instead of forecasting the future from today, you define a desirable future state and work backward to identify the steps required to reach it. This prevents being limited by current constraints.
Crazy 8s:
A Design Sprint method where you fold a sheet of paper into 8 sections and sketch 8 distinct ideas in 8 minutes. It forces speed over quality, bypassing the inner critic.
Starbursting:
Instead of brainstorming answers, you brainstorm questions. You draw a star with the idea in the center and points labeled Who, What, Where, When, Why, and How. This generates a comprehensive list of questions to fully explore the validity of an idea.
Summary Table for Quick Selection
| If you need to... | Use this method... |
| Fix a complex engineering flaw | TRIZ, First Principles |
| Modify an existing product | SCAMPER, Attribute Dependency |
| Understand the User | Design Thinking, Jobs to be Done |
| Break creative blocks | Random Word, Reverse Brainstorming, Crazy 8s |
| Plan a long-term vision | Backcasting, Sci-Fi Prototyping |
Next Step
Would you like me to select one of these methods and guide you through applying it to a specific problem or project you are currently working on?
Describe how I can define a system prompt and one or more follow-on prompts to get an LLM (e.g. Google Gemini 3.0 Pro) to prompt me to consider ideas for pursuing a solution to a problem statement. The LLM's responses should not remain static from session to session, but adjust as necessary to the problem being worked.
To achieve a dynamic, adaptive partnership with an LLM like Gemini 3.0 Pro (or Ultra), you need a System Prompt that creates a "State-Aware" Persona.
This approach forces the LLM to track where you are in the problem-solving lifecycle and changes its behavior accordingly. It prevents the model from being a static "answer machine" and turns it into a "process coach."
Part 1: The System Prompt (The "Engine")
Paste this at the very start of a new project or create a specific "Gem" (if available) with these instructions.
System Instruction: The Adaptive Innovation Architect
Role: You are not a passive assistant; you are an Adaptive Innovation Architect. Your goal is not to answer my questions directly, but to force me to explore the problem space deeply. You must adapt your questioning style based on the "Phase" of our project.
Core Directives:
Do Not Solutionize Early: If I ask for a solution immediately, refuse politely and ask a clarifying question about the root cause or constraints.
Maintain "Project State": At the top of every response, you must display a "State Block" (see format below) that tracks our progress.
Dynamic Adaptation:
If I am vague --> Be surgical and demand specifics (Socratic interrogation).
If I am stuck --> Be creative and offer wild analogies (Lateral thinking).
If I am confident --> Be critical and play Devil's Advocate (Risk analysis).
The State Block:
Always start your response with this markdown code block:
**PROJECT STATE** * **Current Phase:** [Discovery / Ideation / Filtering / Prototyping] * **Current Focus:** [e.g., Defining the user, Technical constraints, Cost reduction] * **Your Mental State:** [e.g., Skeptical, Expansive, Analytical] * **Next Necessary Step:** [What the USER needs to do next]Interaction Protocol:
End every response with one high-value question or provocation that pushes me to the Next Necessary Step. Do not give me a list of 10 things unless I explicitly ask for a list. Keep the cognitive load on me.
Part 2: Follow-On Prompts (The "Steering Wheel")
Use these prompts during the session to shift the LLM's behavior or move to the next phase. These prevent the conversation from becoming repetitive.
A. To Deepen the Problem (When the LLM is being too nice)
"Review the 'Current Phase' in your State Block. You are being too agreeable. Switch your Mental State to 'Ruthless Critic'. Find three flaws in my reasoning above and force me to defend them."
B. To Expand Creativity (When you are stuck)
"We are stuck in a rut. Change the Project State to 'Radical Ideation'. Ignore all previous constraints (budget, physics, time) and prompt me with a 'What if' scenario that solves the core problem using impossible technology."
C. To Converge (When you have too many ideas)
"Shift Project State to 'Filtering & Selection'. Stop generating new ideas. Instead, present a decision matrix based on what you know about my goals. Ask me to kill 50% of the current ideas and explain why."
Part 3: The "Session-to-Session" Bridge (The Memory Hook)
Since LLMs (usually) lose context between sessions, you cannot rely on them to "remember" the project state automatically unless you use a persistent thread. If you start a new chat, use this method to carry the "Brain" of the previous session to the new one.
At the end of Session 1, send this prompt:
"We are pausing for now. Generate a 'System Handoff Summary'. This should be a single paragraph I can paste into a brand new chat session that explains:
The Problem we are solving.
The Current Phase and State we reached.
The exact instructions the new LLM needs to pick up exactly where you left off without restarting the discovery process."
At the start of Session 2, paste:
[Paste the System Prompt from Part 1]
[Paste the Handoff Summary from Session 1]
Why This Works
The State Block: It forces the LLM to "think" about its own behavior before generating text. It grounds the model so it doesn't drift.
Mode Switching: By explicitly naming states (like "Ruthless Critic" or "Radical Ideation"), you toggle the temperature and reasoning style of the model without messing with technical settings.
The Handoff: This creates a manual "save file" for your innovation process, ensuring the "Pro" model doesn't revert to a generic assistant in the next chat.
Now, what if I set up a second AI chatbot to respond to the first chatbot's response?
This strategy converts your workflow into a "Generator-Discriminator" loop (similar to how GANs work in machine learning). One AI generates ideas (Divergent), and the other critiques them (Convergent).
To make this effective, you must prevent them from entering a "compliance loop" where they just compliment each other. You need to engineer conflict into the second prompt.
Here is the setup for the second chatbot (The "Pragmatist").
1. The System Prompt for Chatbot #2
Open a separate chat window (even better if it’s a different model, e.g., using Claude or GPT-4 to debate Gemini) and use this prompt:
System Instruction: The Critical Pragmatist
Role: You are the Chief Skeptic and Implementation Lead. You are debating an "Innovation Architect" (another AI). Your goal is to ground its abstract ideas in reality, budget, and physics.
Directives:
Zero Fluff: Do not use polite conversational fillers ("That's a great point!"). Start every response immediately with your analysis.
The "Red Team" Protocol:
If the Architect suggests a "Wild Idea," attack it with Feasibility constraints (Cost, Law, Physics).
If the Architect asks for "User Needs," provide specific, painful edge cases that are hard to solve.
If the Architect tries to "Move On," force it to prove the current step is actually solved.
Response Structure:
The Block: Identify the biggest flaw in the Architect's previous output.
The Reality Check: Provide a specific constraint (e.g., "This assumes infinite budget," or "Users will not click three times for this").
The Counter-Prompt: End with a challenging instruction for the Architect to force it to refine the idea.
2. How to Run the "Volley" (The Human-in-the-Loop)
You act as the bridge. The magic happens in how you transfer the data.
Turn 1: Give Chatbot 1 (Architect) your initial Problem Statement.
Turn 2: Copy Chatbot 1's response $\rightarrow$ Paste into Chatbot 2 (Pragmatist).
Turn 3: Copy Chatbot 2's critique $\rightarrow$ Paste into Chatbot 1 with this wrapper:
"The Implementation Team returned this critique: [PASTE CRITIQUE]. Update your 'Project State' and propose a solution that satisfies these constraints."
Repeat this for 3-5 loops.
3. The "Convergence" Follow-On
Eventually, the two bots might get stuck arguing details. You need a prompt to force them to agree on a final plan.
Send this to Chatbot 1 (The Architect):
"We are entering the Synthesis Phase. Review the entire debate with the Pragmatist. Stop generating new options. Instead, generate a 'Unified Solution Document' that incorporates the Pragmatist's constraints while keeping your core innovative value. Structure it as:
Final Concept
Key Risks (Identified by Pragmatist) & Mitigations (Proposed by Architect)
Immediate Next Steps."
Why this works:
Chatbot 1 pulls up (Idea expansion).
Chatbot 2 pulls down (Risk reduction).
You maintain the tension. This mimics a real-world boardroom dynamic between a visionary CTO and a risk-averse CFO, often yielding much stronger, battle-tested ideas than a single AI could produce alone.
Would a third moderator chatbot help?
Yes, a third Moderator Chatbot can be extremely helpful, but it changes your role from "Messenger" to "Observer."
In a two-bot system, you are the judge. You have to decide when the Critic is being too harsh or when the Architect is drifting. In a three-bot system, the Moderator takes that cognitive load off you.
Here is how to structure the "Trinity" of agents and why you would use it.
The Setup: The "Hegelian Dialectic" Engine
Bot 1 (Thesis): The Adaptive Architect (Generates ideas).
Bot 2 (Antithesis): The Critical Pragmatist (Attacks ideas).
Bot 3 (Synthesis): The Executive Manager.
The System Prompt for Chatbot #3 (The Manager)
This bot does not generate ideas, nor does it critique them. It manages the conversation flow and decides when a solution is "finished."
System Instruction: The Executive Project Manager
Role: You are the decision-maker managing two sub-agents: an "Architect" (Creative) and a "Pragmatist" (Critic). Your goal is to drive them toward a finalized, actionable solution.
Directives:
Synthesize, Don't Repeat: Read the arguments from the Architect and the Critic. Do not just summarize them. Identify the "Zone of Agreement"—where does the innovation meet reality?
Break Deadlocks: If the Architect and Critic are arguing in circles (e.g., "It's too expensive" vs. "It needs to be high quality"), YOU must make an executive decision. Pick a side or propose a compromise.
Direct the Traffic: End your response by explicitly naming which bot should speak next and exactly what they need to answer.
Example: "Architect, the Critic is right about the budget. Redesign the module using cheaper materials but keep the core functionality."
Output Format (Markdown):
**EXECUTIVE SUMMARY** * **Current Status:** [Stalemate / Progressing / Near Completion] * **Key Decision Made:** [What you decided based on the arguments]
DIRECTIVE
Target Agent: [Architect OR Critic]
Instruction: [Specific constraint or creative prompt]
How the Workflow Changes
This creates a Star Topology where you sit in the center, but the Moderator calls the shots.
You paste the Problem Statement into Moderator.
Moderator analyzes it and issues a Directive to Architect.
You paste that Directive into Architect.
Architect generates an idea.
You paste that idea into Moderator.
Moderator sees the idea and decides it needs vetting. It issues a Directive to Critic.
You paste the idea + directive into Critic.
Critic rips it apart.
You paste the critique into Moderator.
Moderator synthesizes the conflict and issues a new Directive to Architect to fix the flaws.
When is a Moderator Essential?
| Scenario | 2-Bot System (You are the Judge) | 3-Bot System (AI is the Judge) |
| Simple Brainstorming | Better. Faster. | Overkill. Too much copy-pasting. |
| Complex Technical Design | Hard. You might miss technical nuances in the debate. | Essential. The Moderator tracks the technical requirements better than you can in real-time. |
| Bias Removal | You might favor the "cool" idea over the "safe" one. | Essential. The Moderator stays neutral and sticks to the system prompt's logic. |
| Context Length | You handle the memory. | The Moderator acts as the "Memory Bank," summarizing previous turns so the other bots don't hallucinate. |
The "NASA" Analogy (Since you know S&MA)
If you apply this to your background:
Bot 1 (Architect): The Design Engineering Team (wants to build the fastest rocket).
Bot 2 (Critic): Safety & Mission Assurance (wants to ensure it doesn't blow up).
Bot 3 (Moderator): The Program Manager.
The Manager doesn't design the rocket, and doesn't run the safety calculations.
The Manager listens to Engineering say "We need X" and Safety say "X is dangerous," and decides: "We will do X, but with these specific modifications to satisfy Safety."
Next Step
Since you are a Python developer, would you like me to generate a simple Python script that automates this "Three-Agent Loop" using the Gemini API? This would save you from having to copy-paste between three windows manually.
Yes
This Python script implements the Star Topology (Manager-Centralized) workflow.
It uses the Google Gen AI SDK to spin up three distinct chat sessions with the specific "System Instructions" we defined. The script automatically parses the Manager's decision to route the conversation between the Architect and the Critic.
The "Hegelian Loop" Python Script
Prerequisites:
You need your API Key from Google AI Studio.
Install the library:
pip install google-genai
import os
import re
import time
from google import genai
from google.genai import types
# --- CONFIGURATION ---
API_KEY = "YOUR_GEMINI_API_KEY_HERE" # Replace with your actual key
MODEL_ID = "gemini-1.5-pro-latest" # Update to "gemini-3.0-pro" if/when available
# --- SYSTEM PROMPTS (The "Brain" of each Agent) ---
PROMPT_ARCHITECT = """
**Role:** Adaptive Innovation Architect.
**Goal:** Explore the problem space deeply and generate innovative solutions.
**Directives:**
1. Do not solutionize early; ask clarifying questions first if the problem is vague.
2. When asked for ideas, be expansive and use lateral thinking.
3. Maintain a "Project State" block at the top of every response.
"""
PROMPT_CRITIC = """
**Role:** Critical Pragmatist & Implementation Lead.
**Goal:** Ground abstract ideas in reality, budget, and physics.
**Directives:**
1. Zero fluff. Start every response with analysis.
2. Attack "wild ideas" with feasibility constraints (Cost, Law, Physics).
3. Identify specific failure modes or edge cases.
"""
PROMPT_MANAGER = """
**Role:** Executive Project Manager.
**Goal:** Manage the debate between an "Architect" and a "Critic" to reach a finalized solution.
**Directives:**
1. Read the input. Identify the "Zone of Agreement".
2. Decide who speaks next.
- If the idea is new/vague -> Call the **Critic**.
- If the critique is valid -> Call the **Architect** to fix it.
- If the solution is solid -> Declare **FINISH**.
3. **CRITICAL OUTPUT FORMAT:**
You MUST end your response with this exact block so the system can parse it:
@@@DECISION@@@
TARGET: [ARCHITECT or CRITIC or FINISH]
INSTRUCTION: [Your specific instructions for the next agent]
@@@END@@@
"""
def parse_manager_decision(response_text):
"""Regex parser to extract the Manager's routing command."""
match = re.search(r"@@@DECISION@@@\s*TARGET:\s*(.*?)\s*INSTRUCTION:\s*(.*?)\s*@@@END@@@", response_text, re.DOTALL)
if match:
return match.group(1).strip().upper(), match.group(2).strip()
return None, None
def run_innovation_loop(initial_problem):
client = genai.Client(api_key=API_KEY)
# 1. Initialize the Trinity
architect = client.chats.create(model=MODEL_ID, config=types.GenerateContentConfig(system_instruction=PROMPT_ARCHITECT))
critic = client.chats.create(model=MODEL_ID, config=types.GenerateContentConfig(system_instruction=PROMPT_CRITIC))
manager = client.chats.create(model=MODEL_ID, config=types.GenerateContentConfig(system_instruction=PROMPT_MANAGER))
print(f"--- 🚀 STARTING INNOVATION LOOP FOR: {initial_problem} ---\n")
# Initial seed: Send problem to Manager to start the flow
current_input = f"New Project Request: {initial_problem}. Architect, please start."
next_agent = "ARCHITECT" # Force start with Architect
# Run for a maximum of 10 turns to prevent infinite billing loops
for turn in range(1, 11):
print(f"\n[Turn {turn}] 🤖 Active Agent: {next_agent}")
# --- STEP 1: EXECUTE THE AGENT ---
if next_agent == "ARCHITECT":
response = architect.send_message(current_input)
output_text = response.text
print(f"--> Architect Proposes:\n{output_text[:200]}...\n") # Preview only
elif next_agent == "CRITIC":
response = critic.send_message(current_input)
output_text = response.text
print(f"--> Critic Attacks:\n{output_text[:200]}...\n")
elif next_agent == "FINISH":
print("\n🎉 MANAGER DECLARED COMPLETION!")
print(f"Final Consensus: {current_input}") # The last input to manager is usually the refined idea
break
# --- STEP 2: MANAGER ANALYZES ---
# We send the Agent's output to the Manager
manager_prompt = f"The {next_agent} just said:\n\n{output_text}\n\nAnalyze this and decide who speaks next."
manager_response = manager.send_message(manager_prompt)
# --- STEP 3: ROUTING ---
target, instruction = parse_manager_decision(manager_response.text)
if target:
print(f"👮 Manager Directs: {target} -> '{instruction}'")
next_agent = target
current_input = instruction # The Manager's instruction becomes the prompt for the next agent
else:
print("❌ Error: Manager did not output a valid decision block.")
break
time.sleep(1) # Polite API delay
if __name__ == "__main__":
problem = input("Enter your problem statement: ")
run_innovation_loop(problem)
How this Script Works
State Persistence: It uses
client.chats.create, which maintains the "memory" for each agent separately. The Architect remembers its previous ideas, and the Critic remembers its previous complaints.The Routing Logic: The
parse_manager_decisionfunction looks for the special@@@DECISION@@@block. This allows the Manager (AI) to control the Pythonwhileloop.Variable Injection: When the Manager says, "Critic, check this for cost," the script takes that exact instruction and feeds it into the
critic.send_message()function automatically.
Relevant Resource
This video is highly relevant as it demonstrates Google's official "Agent Development Kit" (ADK) approach to building the exact type of "Critic" and "Updater" multi-agent loop described in the Python script above.
Suggest the format for several types of problem statement
Different disciplines require different ways of framing a problem to trigger the right kind of solution. For example, a business problem needs to focus on money and strategy, while a design problem needs to focus on human emotion and friction.
Here are 6 standard problem statement formats categorized by their specific use case.
1. The "Gap Analysis" Format (Business & Strategy)
Best for: Operational issues, revenue loss, or process inefficiencies. It focuses on the distance between "where we are" and "where we want to be."
The Template:
The Problem: [Describe the current dysfunctional state]. The Impact: [Quantifiable negative consequence, e.g., cost, time, morale]. The Desired State: [Describe the ideal future state]. The Gap: [What specific obstacle prevents the transition?].
Example:
The Problem: Our customer support team currently answers 40% of queries via email with a 24-hour lag time.
The Impact: This results in a 15% churn rate and $50k/month in lost renewals.
The Desired State: Immediate resolution of Tier 1 queries and <4 hour response for Tier 2.
The Gap: We lack an automated triage system to filter simple requests from complex ones.
2. The "Point of View" (POV) Format (Design Thinking)
Best for: Product design, UX/UI, and innovation. It frames the problem around a specific user and their deep emotional or functional need.
The Template:
[User/Persona] needs a way to [User’s Need] because [Surprising Insight/Constraint].
Example:
User: A freelance graphic designer working remotely.
Need: A way to collaborate on large video files in real-time without downloading them.
Because: Their home internet bandwidth is throttled during peak hours, making standard cloud sync tools unusable for client presentations.
3. The "Jobs to be Done" (JTBD) Format (Product Development)
Best for: Focusing on the motivation behind a user's action rather than their demographic. It removes bias about "who" the user is.
The Template:
When [Situation/Context], I want to [Motivation/Action], So that I can [Expected Outcome/Payoff].
Example:
When I am rushing to the airport and have only one free hand,
I want to check in and get my boarding pass with a single thumb-tap,
So that I can get through security without stopping to dig through my bag for documents.
4. The "5 Ws" Format (Journalism & Root Cause)
Best for: Investigations, incident reports, and system failures. It forces a factual, non-emotional breakdown of an event.
The Template:
Who is affected? What is happening (and what isn't happening)? Where is the problem occurring? When does the problem happen (frequency/trigger)? Why is this a problem (impact)?
Example:
Who: Mobile users on Android devices (v12.0+).
What: The "Checkout" button becomes unresponsive.
Where: On the final payment confirmation screen.
When: Only when the cart contains more than 5 items.
Why: This prevents high-value transactions, causing a 3% drop in daily revenue.
5. The "Hypothesis" Format (Scientific & Academic)
Best for: Data science, A/B testing, and research. It frames the problem as a variable to be tested.
The Template:
We believe that [Problem/Observation] is caused by [Proposed Variable/Root Cause]. If we [Proposed Solution/Intervention], Then we will see [Measurable Metric].
Example:
We believe that the high drop-off rate on the sign-up page
is caused by the requirement to enter credit card details for a free trial.
If we move the credit card requirement to after the 14-day trial,
Then we will see sign-up conversions increase by at least 20%.
6. The "How Might We" (HMW) Format (Brainstorming)
Best for: Moving a team from "complaining" mode to "solving" mode. It is open-ended and optimistic.
The Template:
How might we [Action Verb] [Core Problem] for [User] in order to [Desired Outcome]?
Example:
How might we gamify regulatory compliance training for junior engineers in order to increase retention of safety protocols?
Recommendation for your AI Workflow
If you are feeding these into your "Architect" (Bot 1), I recommend using the Gap Analysis (#1) or POV (#2) formats. These provide the most context for the AI to "reason" about constraints and user needs.
If you are prompting the "Critic" (Bot 2), ask it to convert the Architect's idea into a Hypothesis (#5) to test if the solution is actually measurable.
From <https://gemini.google.com/app/> Google Gemini 3.0 Pro (Thinking)
Comments
Post a Comment