Designing With AI, Not Around It: Practical Advanced Techniques For Product Design Use Cases — Smashing Magazine

The Human Side of the AI Skill Curve

It is difficult to overstate how quickly generative AI has become a fixture in professional life. It writes, draws, codes, and synthesizes information at a pace that was unthinkable just a few years ago. While the constant stream of new tools can feel overwhelming, the underlying shift is structural rather than hype-driven. The Future of Jobs Report 2025 from the World Economic Forum identifies the ability to work with AI and Big Data as one of the most rapidly growing skill demands across nearly every role, product design included.

For designers, whose core value proposition rests on empathy, creativity, and critical thinking, this raises a fundamental question about staying relevant. The push for efficiency from leadership is constant, and AI offers a genuine path to reclaiming time. Yet, the tools remain deeply flawed; they hallucinate, lose context, and require careful oversight. The reality is that AI is both unreliable and remarkably useful at the same time. The differentiator is not the tool itself, but the operator's ability to design the thinking that guides it.

Prompting as a Spectrum

Prompting is often mistaken for simply writing better instructions. In practice, it is about designing a better reasoning process. Small adjustments in phrasing can yield dramatically different outputs, making the interaction between human intention and machine output profoundly sensitive.

Consider the task of improving an onboarding flow. A generic request for ideas yields a generic list of best practices. A prompt that specifies the user persona, the friction point, and the desired emotional tone, however, produces responses that are targeted and actionable. This isn't about a binary between "good" and "bad" prompts. Instead, think of prompting as a spectrum. For narrow, factual, or time-sensitive tasks, a direct and concise request is optimal. For complex, open-ended problems that require evaluation and synthesis, a more structured approach is necessary.

Advanced prompting moves beyond one-shot questions. It is an iterative process of refining inputs with specific techniques, providing the AI not just with a task but with a path. This involves guiding the model to explore options, evaluate reasoning, and converge on clear, actionable outputs rather than just a first draft.

The Practical Toolkit: Chain-of-Thought and Beyond

Guiding the Reasoning Process

One of the most powerful techniques for complex tasks is chain-of-thought prompting. This method asks the model to articulate its reasoning process before delivering a final answer. You can ask for multiple solution paths, then have the AI evaluate the trade-offs between them before selecting one. This forces a level of depth that a simple request bypasses, ensuring the final output isn't just a surface-level pattern match.

This structure makes the output easier to assess. When the AI exposes its reasoning, we can spot errors in logic or gaps in context that might otherwise be hidden. This ability to explore options and evaluate branches of reasoning before converging on a solution is critical for the design process, where the first answer is rarely the best one.

Role Prompting for Specific Outcomes

A simple but effective tool in the advanced prompting kit is assigning a specific role. When preparing for a user interview, prompting the AI to act as a specific archetype of a user—say, a "time-poor parent" or a "privacy-focused power user"—can generate more authentic responses than asking for generic feedback. This works because the model can draw on its training data to simulate a perspective.

As with chain-of-thought, the key is guiding the AI's reasoning. Give the role concrete boundaries and a specific context. By framing "you are" statements with context about the scenario, the output becomes grounded in the relevant perspective. This is particularly useful for generating user stories, anticipating objections, or testing usability scripts with a diverse set of simulated subjects.

Exercising Outputs for the Real World

A general best practice is to narrow the response frame. Instead of asking for "a tagline," you might ask for short alternatives with different tones. One of the most practical, low-lift techniques is quantity control: ordering outputs in the range of 3–5 options. This forces the model to prioritize, generating more thoughtful alternatives rather than fifty identical variations.

Similarly, adding a phrase like "This is a draft—please challenge it" encourages the model to expose assumptions for critical review, acting as a sparring partner rather than a yes-man. These are the kinds of tricks that shift AI usage from an extension of search to an instrument of thought—still fallible, still limited, but far more effective when handled with intentionality.

Six Prompting Techniques for Real Design Work

These six techniques come from hands-on product design work — research, ideation, and evaluation. They work as modular tools you can adapt to whatever you're tackling, not as copy-paste recipes. Some are structured templates; others are intentionally specific to spark your own thinking. Use them as scaffolds.

Breaking Problems Down With JTBD

Jumping straight into execution feels fast, but it risks solving the wrong problem. A useful middle step: ask the model to decompose the task before generating solutions. Jobs To Be Done (JTBD) gives you a framework for that decomposition.

Good design starts with understanding the user, the problem, and the context — and so does good prompting. That's why most solid prompts include a Role, Context, and Instructions, plus optional format constraints. In this technique, you add self-checkpoints so the AI pauses, reflects, and self-verifies along the way.

Role
Act as a senior product strategist and UX designer with deep expertise in Jobs To Be Done (JTBD) methodology and user-centered design. You think in terms of user goals, progress-making moments, and unmet needs — similar to approaches used at companies like Intercom, Basecamp, or IDEO.

Context
You are helping a product team break down a broad user or business problem into a structured map of Jobs To Be Done. This decomposition will guide discovery, prioritization, and solution design.

Task & Instructions
[👉 DESCRIBE THE USER TASK OR PROBLEM 👈🏼]
Use JTBD thinking to uncover:

• The main functional job the user is trying to get done;
• Related emotional or social jobs;
• Sub-jobs or tasks users must complete along the way;
• Forces of progress and barriers that influence behavior.

Checkpoints
Before finalizing, check yourself:

• Are the jobs clearly goal-oriented and not solution-oriented?
• Are sub-jobs specific steps toward the main job?
• Are emotional/social jobs captured?
• Are user struggles or unmet needs listed?

If anything's missing or unclear, revise and explain what was added or changed.

A one-sentence prompt gets you a generic list of features. This approach produces a structured JTBD breakdown: a goal-oriented Main Functional Job statement, Emotional & Social Jobs tied to how the user wants to feel, Sub-Jobs as concrete milestones, and Forces of Progress covering motivations and barriers. Run it against your actual product — even a quick test often surfaces unexpected insights.

Reverse-Engineering Competitors Before Judging Them

Competitive analysis starts with understanding someone else's design choices — what the feature is for, who it helps, why it was built that way. Rather than rushing into critique, you can use the model to reconstruct the thinking behind the product first.

1. Grab the competitor's documentation for the feature you want to analyze and save it as a PDF.
2. Before asking for an audit, ask the model to interpret the documentation. This Reasoning Before Understanding (RBU) step builds an accurate mental model of the feature before any evaluation.
3. Interact with the first reply: clarify, correct, or add nuance to align the model's understanding with your own.

Role
You are a senior UX strategist and cognitive design analyst. Your expertise lies in interpreting digital product features based on minimal initial context, inferring purpose, user intent, and mental models behind design decisions before conducting any evaluative critique.

Context
You've been given internal documentation and screenshots of a feature. The goal is not to evaluate it yet, but to understand what it's doing, for whom, and why.

Task & Instructions
Review the materials and answer:

• What is this feature for?
• Who is the intended user?
• What tasks or scenarios does it support?
• What assumptions does it make about the user?
• What does its structure suggest about priorities or constraints?

For the audit itself, switch to a Tree of Thought (ToT) approach. Instead of one linear answer, the model explores multiple reasoning branches, compares outcomes, and revises its logic before concluding. You can point that technique at different angles:

You are now performing a UX audit based on your understanding of the feature. You'll identify potential problems, alternative design paths, and trade-offs using a Tree of Thought approach, i.e., thinking in branches, comparing different reasoning paths before concluding.

Or adapt it:

Convert your understanding of the feature into a set of Jobs-To-Be-Done statements from the user's perspective using a Tree of Thought approach.

List implicit assumptions this feature makes about the user's behavior, workflow, or context using a Tree of Thought approach.

Propose alternative versions of this feature that solve the same job using different interaction or flow mechanics using a Tree of Thought approach.

Forcing the Model to Disagree

Left to its own defaults, AI tends to validate your ideas rather than challenge them. The fix: condition the model to act as a critical thinking partner and tell it to hold that mode across the session.

Instructions
From now on, remember to follow this mode unless I explicitly say otherwise.

Do not take my conclusions at face value. Your role is not to agree or assist blindly, but to serve as a sharp, respectful intellectual opponent.

Every time I present an idea, do the following:

• Interrogate my assumptions: What am I taking for granted?
• Present counter-arguments: Where could I be wrong, misled, or overly confident?
• Test my logic: Is the reasoning sound, or are there gaps, fallacies, or biases?
• Offer alternatives: Not for the sake of disagreement, but to expand perspective.
• Prioritize truth and clarity over consensus: Even when it's uncomfortable.

Maintain a constructive, rigorous, truth-seeking tone. Don't argue for the sake of it. Argue to sharpen thought, expose blind spots, and help me reach clearer, stronger conclusions.

This isn't a debate. It's a collaboration aimed at insight.

The key phrase is remember to follow this mode unless I explicitly say otherwise — it persists beyond a single exchange, so the model stays in critical mode as you iterate on ideas.

Meta-Prompts for Better Prototype Generators

Tools like v0, Bolt, Lovable, and UX Pilot only output what you describe — and your prompt needs to be sharper than most PRDs. Writing that kind of prompt is hard, so skip it: write a meta-prompt asking GPT to help you produce better design prompts instead.

Feed the model what you know about the app or screen, then instruct it to treat information architecture, layout, and user flow as variables. You get multiple concept directions rather than one rigid interpretation. In this example, the goal is three variations for the same screen, each anchored to a different IA and layout logic:

Role
You are a product design strategist working with AI to explore early-stage design concepts.

Goal
Generate 3 distinct prompt variations for designing a Daily Wellness Summary single screen in a mobile wellness tracking app for Lovable/Bolt/v0.

Each variation should experiment with a different Information Architecture and Layout Strategy. You don't need to fully specify the IA or layout — just take a different angle in each prompt. For example, one may prioritize user state, another may prioritize habits or recommendations, and one may use a card layout while another uses a scroll feed.

User context
The target user is a busy professional who checks this screen once or twice a day (morning/evening) to log their mood, energy, and sleep quality, and to receive small nudges or summaries from the app.

Visual style
Keep the tone calm and approachable.

Format
Each of the 3 prompt variations should be structured clearly and independently.

Remember: The key difference between the three prompts should be the underlying IA and layout logic. You don't need to over-explain — just guide the design generator toward different interpretations of the same user need.

From Cognitive Walkthrough to Testable Hypotheses

A cognitive walkthrough breaks down a user action step by step and checks whether each step is intuitive: Does the user know where to click? What to do next? Do they know it worked? It works whether you have a finished mockup or are still debating what should go where.

The walkthrough itself gets stronger when you simulate different user profiles and ask the model to reflect at each step on assumptions and visual feedback:

Context
You've been given a screenshot of a screen where users can create new tasks in a project management app. The main action the user wants to perform is "add a task". Simulate behavior from two user types: a beginner with no prior experience and a returning user familiar with similar tools.

Task & Instructions
Go through the UI step by step and evaluate:

1. Will the user know what to do at each step?
2. Will they understand how to perform the action?
3. Will they know they've succeeded?

For each step, consider alternative user paths (if multiple interpretations of the UI exist). Use a casual Tree-of-Thought method.

At each step, reflect: what assumptions is the user making here? What visual feedback would help reduce uncertainty?

Format
Use a numbered list for each step. For each, add observations, possible confusions, and UX suggestions.

Limits
Don't assume prior knowledge unless it's visually implied.
Do not limit analysis to a single user type.

The walkthrough only becomes actionable when flagged friction points turn into validation plans. Push the model to define exactly how you'd test each hypothesis with real users:

Task & Instructions
Based on your previous cognitive walkthrough:

1. Extract all potential usability hypotheses from the walkthrough.
2. For each hypothesis:
   • Assess whether it can be tested through moderated or unmoderated usability testing.
   • Explain what specific UX decision or design element may cause this issue. Use causal reasoning.
   • For testable hypotheses:
     • Propose a specific usability task or question.
     • Define a clear validation criterion (how you'll know if the hypothesis is confirmed or disproved).
     • Evaluate feasibility and signal strength of the test (e.g., how easy it is to test, and how confidently it can validate the hypothesis).
     • Assign a priority score based on Impact, Confidence, and Ease (ICE).

Limits
Don't invent hypotheses not rooted in your walkthrough output. Only propose tests where user behavior or responses can provide meaningful validation. Skip purely technical or backend concerns.

Simulating a Cross-Functional Review

Design review in practice means collecting feedback from PMs, engineers, QAs, analysts, and other designers — then turning it into clear action items. Multi-role prompting simulates that roundtable in one go by assigning several expert perspectives to the same artifact.

Role
You are a cross-functional team of experts evaluating a new dashboard design:

• PM (focus: user value & prioritization)
• Engineer (focus: feasibility & edge cases)
• QA tester (focus: clarity & testability)
• Data analyst (focus: metrics & clarity of reporting)
• Designer (focus: consistency & usability)

Context
The team is reviewing a mockup for a new analytics dashboard for internal use.

Task & Instructions
For each role:

1. What stands out immediately?
2. What concerns might this role have?
3. What feedback or suggestions would they give?

Each perspective surfaces different concerns — feasibility and edge cases from engineering, clarity and testability from QA, metric definition from analytics. The result is a faster, broader critique than any single review pass would give you.

Prompting as a Design Decision

The techniques covered so far are not interchangeable tricks. They each change the relationship between you and the model: some tighten control, others open up exploration. The useful question is not which prompt style is best, but what does this task require right now?

Choosing the Right Technique for the Moment

Match the technique to the kind of thinking you need, not to a default habit. If the task calls for clarity and control, Role + Checkpoints keeps the output structured and verifiable. If you need breadth or alternative viewpoints, Multi-Role or Tree of Thought will deliberately open up more paths.

The same applies to whether the model should adopt your assumptions or question them. When you want the output to align with your framing, a straightforward Role + Context + Instructions prompt is sufficient. When you suspect your own framing is part of the problem, Opponent prompting forces the model to surface the weaknesses in that framing.

Precision, Ambiguity, and Depth

Another axis is whether you are trying to reduce ambiguity or deliberately expose its complexity. Meta-prompting is the right move when your ask is unclear and you need the model to refine the question itself. But when you already know the ask and want to uncover what sits beneath a seemingly simple solution, Tree of Thought or RBU are better equipped to reveal layers the first answer will miss.

Finally, consider the intended outcome. Are you aligning stakeholders or exploring a concept? Simulating consensus across roles is what Multi-Role prompting excels at. For pushing a single idea into deeper territory, a Cognitive Walkthrough will systematically test it against realistic use.

• Need precision? Use Role + Checkpoints.
• Need perspective? Use Multi-Role or Tree of Thought.
• Reduce ambiguity? Use Meta-prompting.
• Surface complexity? Use ToT or RBU.
• Align views? Use Multi-Role prompting.
• Deepen exploration? Use Cognitive Walkthrough.

Long, elaborate prompts are not inherently better. They carry a cost in time and in possible drift. Use detail when the task genuinely demands it, not as a routine reflex. The model will always mirror the structure of your thinking, so the discipline lies in shaping that structure deliberately for each design problem.