Tired of Generic AI Answers?

How Structuring Your Prompts Unlocks Better Results, by Gemini 2.5 Flash

Created with Midjourney v7 using the first paragraph of this article

You’ve been there. You turn to your favorite AI assistant—ChatGPT, Claude, Gemini—hoping for a spark of brilliance for your latest UX project. Maybe you need some quick UI copy, ideas for user interview questions, or a summary of competitor features. You type in your request, hit enter, and... get something bland, off-target, or so generic it’s barely usable. Hours of re-prompting and editing later, you wonder if AI is really the time-saver it promises to be for UX designers.

What if the problem isn't just what you're asking, but how you're asking? Even in the simple chat boxes of today's web-based AI tools, a little bit of structure in your prompts can make a world of difference. Think of it like a mini-design brief for the AI. This isn't about deep coding; it's about clear communication. By borrowing some simple principles from markup languages, you can guide your AI to deliver more precise, relevant, and genuinely helpful outputs for your design tasks.

Why "Markup" Matters: Speaking the AI's (Sort of) Language

When we talk about "markup" in the context of AI prompting for tools like ChatGPT, Claude, or Gemini, we're not usually talking about the AI strictly parsing complex XML schemas like a web browser does. Instead, we're using markup-<em>like</em> structures and principles to make our intentions crystal clear. Think of it as adding signposts and labels within your prompt.

Why bother? As UX designers with 2-5 years of experience, you already know that clear communication is key – whether it's with stakeholders, developers, or users. The same applies to AI. By structuring your prompts, you can:

1. Gain Greater Control Over AI Output: Clearer instructions about persona, tone, content focus, and even desired output format (like a list or table) mean the AI is less likely to guess and more likely to deliver what you actually need. This translates to less editing and more relevant content for your UX deliverables.

2. Improve AI's Understanding of Complex UX Requests: Need the AI to analyze something from multiple angles, generate content with several distinct parts (like a user journey outline with pain points and opportunities), or follow a specific thought process? Structure helps the AI break down and process that complexity.

3. Start Simple for Big Wins: You don’t need to be a developer. Beginning with basic Markdown (for lists and headings) or simple, descriptive tags (e.g., <objective>Summarize this</objective> <format>In a bulleted list</format>) directly within the prompt box can significantly boost the quality and consistency of AI responses.

4. Balance Clarity with Prompt Length: Yes, structured prompts can sometimes be a bit longer. But the clarity they provide often leads to the AI understanding your request faster and more accurately. This means a more direct and useful answer on the first try, saving you precious time and iterations—a net win for efficiency.

Borrowing from Markup Concepts: When to Think "XML," "JSON," or "Markdown" in Your Prompts

While consumer AI tools don't typically have you writing full-fledged, validated XML or JSON code in the prompt box for the AI to parse (unless you're using specific API features, which are beyond our scope here), the principles behind these languages can be incredibly useful for structuring your requests.

• Markdown-like Structuring:

  • What it is: Using simple text formatting like headings (# Heading), bullet points (* Item), numbered lists (1. Item), bold (**bold**), and italics (*italic*) within your prompt to organize your thoughts, or requesting the AI to use this formatting in its output.

  • When to use it in a prompt:

    • To break down multi-step instructions for the AI.

    • To clearly delineate different sections of your input (e.g., context, task, constraints).

    • To ask the AI to generate content that's easy to read and already formatted for documents, notes, or even direct use in tools that support Markdown (like some wikis or design spec software).

  • Example Request for AI: "Please generate a list of accessibility considerations for a mobile banking app. Format the output as a Markdown bulleted list under the heading '## Accessibility Checklist'."

• XML-like Tagging (Conceptual):

  • What it is: Using descriptive, human-readable tags (like <tagname>content</tagname>) to label different parts of your prompt. The AI doesn't "validate" this XML, but it often uses these tags as strong contextual clues to understand the distinct components of your request.

  • When to use it in a prompt:

    • To assign a specific persona or role to the AI (e.g., <persona><role>Senior UX Researcher</role></persona>).

    • To define specific constraints or requirements for different parts of the task (e.g., <output_requirements><length>Under 100 words</length></output_requirements>).

    • When you have several distinct pieces of information that the AI needs to consider separately but in relation to each other.

  • Example in Prompt:

    Plaintext

<context>
  Our app is a language learning platform for busy professionals.
</context>
<task>
  Write three short, encouraging notification messages for users who haven't practiced in 3 days.
</task>
<tone_guide>
  Motivational but not pushy.
</tone_guide>

• JSON-like Structures (Conceptual):

  • What it is: Asking the AI to generate output that mimics the key-value pair structure of JSON, or providing examples in a similar format. This is useful for getting organized data-like text.

  • When to use it in a prompt:

    • When you need the AI to extract specific pieces of information and present them as clearly defined pairs (e.g., "Extract the product name, features, and price from the following text. Present it like: product_name: [Name], features: [List features], price: [Price].").

    • When you want the AI to generate a list of items where each item has multiple, distinct attributes you want to see (e.g., a list of user personas with name, goal, and frustration for each).

    • When you're conceptualizing data models and want the AI to help brainstorm fields.

  • Example Request for AI: "Generate three sample user personas for a fitness tracking app. For each persona, provide their 'name', 'primary_fitness_goal', and a 'key_challenge'. Please format this so each persona's details are clearly grouped, perhaps like a list of objects with these keys." (You could even suggest a JSON-like text structure).

The key is that these "formats" help the AI differentiate and understand the components and hierarchy of your request, leading to more nuanced and accurate responses.

Getting Started: Your Step-by-Step Guide to Structured Prompting

Ready to try this yourself? Here’s a practical roadmap for UX designers to begin leveraging structured prompting in everyday web-based AI tools:

1. Step 1: The Foundation - Clear Natural Language & Keen Observation

   • Action: For any design task (generating UI copy, brainstorming user flows, summarizing research), first try a clear, concise, and specific natural language prompt as you normally would.

   • Observe: Carefully note the AI's response. How well did it grasp your intent? Was the format what you needed? Was the tone appropriate? Where did it miss the mark?

   • Success Metric: You establish a baseline. You see what the AI does by default, identifying areas where more guidance could improve results.

2. Step 2: Level Up - Basic Output Formatting & Persona Setting

   • Action (Output Formatting): Start adding simple, direct instructions for how you want the output structured.

     • Examples: "List three creative ideas...", "Write this as a single concise paragraph.", "Format this information as a Markdown table with two columns: 'Feature' and 'Benefit'."

   • Action (Persona Setting): Explicitly tell the AI what role to adopt or what tone to use.

     • Examples: "You are a helpful UX writing assistant. Generate three options for this button label...", "Adopt a skeptical persona and critique the following design concept from a usability standpoint:..."

   • Success Metric: You'll see immediate improvements. The AI will adhere more closely to your desired output structure and adopt the specified persona or tone, making its responses more directly usable and reducing your editing time.

3. Step 3: Structure Complex Requests - Delimiters & Conceptual Tags

   • Action (Delimiters): For multi-part requests or when providing different types of information (context, task, constraints), use Markdown headings (### Part 1: User Problem ###), numbered lists for steps, or even simple visual separators like --- to break up sections of your prompt.

   • Action (Conceptual Tags): Experiment with wrapping key parts of your prompt in simple, descriptive XML-like tags directly in the chat interface. The AI uses these as strong contextual clues.

     • Copy-Pasteable Example (for generating UI text):

       Plaintext

<prompt_instructions>
  <persona>
    <role>Enthusiastic Productivity Coach</role>
    <tone>Welcoming, motivational, and clear</tone>
  </persona>
  <task>Write a short welcome message for a first-time user of 'TaskMaster', an app that helps them organize their daily tasks and achieve their goals.</task>
  <output_requirements>
    <style>One brief paragraph, 2-3 sentences maximum.</style>
    <key_message>Highlight ease of getting started and one key benefit (e.g., feeling organized).</key_message>
    <include_emoji>Optional: 1 relevant emoji if it fits the tone.</include_emoji>
  </output_requirements>
</prompt_instructions>

1. Success Metric: The AI will more reliably address all components of your complex prompts. It will better distinguish between background information, the core task, and stylistic constraints, leading to outputs that are more organized, comprehensive, and aligned with your multifaceted needs.

2. Step 4: Requesting Data-Like Structures (as Text)

   • Action: If you need content that looks like a specific data structure (e.g., for planning content models, defining user attributes, or just getting organized key-value information), explicitly ask for it. The AI will generate this as text, not validated code.

     • Example: "Generate a list of potential user settings for a new social media app's notification system. For each setting, provide a 'setting_name' (e.g., 'NewFollowerAlerts') and a 'brief_user_facing_description' of what it controls. Format it clearly so I can easily see these pairs."

     • Or, for a more JSON-like text output: "Provide the output as a JSON-like structure with a root key 'app_features' containing an array of objects. Each object should have 'feature_name' and 'user_benefit' keys. Give me 3 features for a travel planning app."

   • Success Metric: The AI outputs text that correctly mimics the requested data-like structure. This makes it easier for you to visualize information, transfer it to design documentation, or use it as a basis for discussions about data models with your team.

Decision Framework: Which "Structuring" Approach When?

How do you choose the best way to structure your prompt in a web UI? Here’s a quick guide:

• IF you need the AI to adopt a specific persona, tone, or style for its response (e.g., "Write like a seasoned UX mentor," "Explain this technical concept simply for a non-technical client," "Use an encouraging and supportive tone"):

  • THEN clearly state this role/tone requirement at the beginning of your prompt (e.g., Act as a [Your Desired Role]. Your tone should be [Desired Tone].) OR use simple, conceptual tags like <persona><role>Expert UX Copywriter</role><tone>Clear, concise, and user-focused</tone></persona>. The AI uses these as strong contextual cues to shape its language and approach.

• IF you need the AI's output to be in a common, easily described visual structure (like a bulleted list, a paragraph of a certain length, a Markdown table, or content organized into specific named sections):

  • THEN explicitly ask for that structure using natural language (e.g., Format your answer as a numbered list., Provide a summary in no more than three sentences., Organize the information into a "Potential Issues" section and a "Suggested Solutions" section.). For tables, directly asking Format as a Markdown table. is highly effective. Providing a small example of the structure you want can also be very helpful: e.g., Category: [Item1, Item2].

• IF your request involves multiple distinct steps, components, or pieces of background information that the AI needs to process or generate in a sequence or with clear separation:

  • THEN use clear delimiters like Markdown headings (### Step 1: Define the User ###, ### Step 2: Brainstorm Features ###), numbered lists for sequential instructions, or even simple visual separators like --- Next Section --- to separate these parts within your prompt. This helps the AI follow your logic and address each part of the request systematically.

• IF you need the AI to generate text that looks like a specific data structure (e.g., key-value pairs for a list of product features, or a simple JSON-like object for concept generation) perhaps for later manual use, to illustrate a data model, or to quickly organize complex information:

  • THEN describe the desired structure clearly and ask the AI to mimic it in its text output. For example: List the core components of a design system. Present them as: Component: [Name of Component], Description: [Brief explanation of its purpose]. Or, for something more complex: Generate a conceptual JSON object representing a user task flow for 'password reset'. Include keys for 'flow_name', 'user_goal', 'steps' (as an array of strings), and 'potential_friction_points' (as an array of strings). Remember, the AI will generate this as formatted text, not as programmatically validated data.

Next Steps: Experiment and Build Your Toolkit

The best way to get good at structured prompting is to practice.

1. Start Small: Pick one or two of the simpler techniques, like basic Markdown formatting for lists or defining a persona, and try them in your next AI interaction.

2. Observe and Iterate: Pay close attention to how the AI responds to your structured prompts. If it doesn’t nail it the first time, tweak your tags, clarify your instructions, or simplify the structure. Prompt engineering is often an iterative process.

3. Build a "Snippet Library": As you discover prompt structures that work well for specific UX tasks (like generating user stories with <actor>, <action>, <goal> tags, or a template for creating persona outlines), save them as text snippets. This personal toolkit will make you much more efficient over time.

4. Share with Your Team: If you find a great way to prompt for a common design task, share it! Helping your team level up their AI skills benefits everyone.

By consciously structuring your communication with AI, even in simple web interfaces, you transform these tools from unpredictable idea generators into more reliable and powerful design assistants. You’ll spend less time wrestling with generic outputs and more time leveraging AI to enhance your creativity and productivity as a UX designer. Happy prompting!

Return to the parent demonstration article.

Tags: Demo

William Trekell : Linkedin : Bluesky : Instagram : Feel free to stop by and say hi!