UX designers frequently work in ambiguous spaces, most notably the discovery phase. We collaborate closely with product managers to identify new problems, understand users’ goals and frustrations, and strategically develop solutions to address their needs. However, the best solutions aren’t always straightforward, and with AI being embedded in every new product and feature, it makes things a bit more challenging. Just as we get comfortable using AI, something changes or evolves. This makes AI features unpredictable and difficult to document requirements for.
Traditional product requirements documents (PRDs) outline the intended purpose, functionality, and behavior of a product, serving as a guideline for development teams and stakeholders. However, the ambiguity with AI’s behavior can create misalignment across the team and potentially a disastrous outcome.
To mitigate this risk, designers should adopt an iterative approach using prompt sets to define exactly how AI should behave and respond across different scenarios. Just as we ensure consistency in visual patterns and copy, we also shape how users interact with a product. This leads to how they will ultimately feel while using it.
The same applies to AI features, as designers play a key role in determining whether outputs align with the brand tone of voice, feel trustworthy, and provide genuine value. While engineers and PMs focus on feasibility and business rules, designers are uniquely positioned to own prompt sets, just as we do with our design files.
Prompt sets shouldn’t completely replace product requirements, though. A PRD still defines what the feature should accomplish, who it serves, its constraints, dependencies, business rules, and broader requirements. Prompt sets complement that documentation by making one particularly unpredictable part of the product more concrete: how the AI should behave across different situations.
And as AI products become more complex, a prompt and an ideal response aren’t always enough. Teams increasingly need to define acceptable and unacceptable behaviors, test the same scenario repeatedly, account for model and tool changes, and establish measurable criteria for deciding whether an AI experience is ready to ship. In that sense, a prompt set can evolve into a broader AI behavior and evaluation framework.
Let’s talk about why AI requirements need real interaction to become clear, how prompt-set prototypes reveal what works faster than documents, and how early testing aligns teams. You’ll see how prompt sets act as detailed use cases that enable quick iteration and foster collaboration across design, product, and engineering to clarify goals and deliver value efficiently.
Editor’s note: This article was updated in September 2026 to expand prompt sets into a broader framework for designing and evaluating AI behavior. We added guidance on model variability, structured evals, acceptance criteria, failure and adversarial testing, versioning across model changes, and designing for AI systems that can use tools and take actions. We also clarified how prompt sets can complement, rather than replace, traditional product requirements.
First, let’s talk about what a prompt set is. They are essentially a collection of curated written prompts paired with their expected responses, tone, and structure. They help define how an AI system should behave in specific scenarios and ensure that all use cases are covered. In a way, a prompt set is similar to a film script, which outlines the dialogue and execution details like stage directions.
For example, a customer support product may feature an AI assistant that helps support staff manage and resolve their tickets.
In a PRD, a requirement might be written “The AI should summarize support tickets.” Different team members may interpret this differently. Should the AI condense tickets into one sentence? Or should it generate a structured report? Not having specifics can slow down alignment and risk wasted effort.
A prompt set consists of a prompt and details of the expected response, like the tone, structure, and constraints of the output.
This functions as both a design spec and a test case for AI behavior, removing ambiguity and aligning the team on what a good outcome looks like. Instead of debating abstract requirements, teams can see exactly how the AI should respond and quickly spot gaps or issues. Sometimes, AI doesn’t respond the way we expect, so refining the prompt to be more direct or specific can help generate the proper response.
But don’t think of the expected response as a single “correct” answer. Unlike a traditional interface, the same AI prompt can produce different outputs across multiple runs. A model update, temperature setting, additional context, tool call, or seemingly minor prompt change can alter the result.
Instead, define the range of acceptable behavior. What information must the response contain? What must it never contain? What makes the response useful, accurate, safe, and appropriate for the user? When should the AI ask for clarification rather than answer? When should it refuse, escalate, or hand control back to the user?
This turns the prompt set from a collection of ideal examples into something closer to a behavioral specification: examples of what good looks like, what failure looks like, and the criteria the team can use to tell the difference.
How can designers use prompt sets in their design process? When it comes to building AI products, speed to market is essential for gaining market share over your competitors. Building features quickly and testing them with real customers allows you to gather feedback and refine your product as soon as possible.
Prompt sets make this early testing far easier than relying on lengthy product requirement documents. Prototyping real AI interactions can demonstrate outcomes that may be missed by requirements specs, ensuring that all edge cases are accounted for. Oftentimes, AI can produce responses that were not thought of or generate unexpected outputs. It can be difficult to define requirements without actually testing a prototype of the AI feature first. Also, having concrete examples of prompts and responses makes it easier for teams to align around and test out.
By testing out real prompts and expected responses, teams can see exactly how an AI feature behaves before committing to code. This shared reference point helps designers spot UX issues, PMs validate the vision, and engineers flag feasibility concerns early. With AI, even small changes to words or phrasing can dramatically shift results, which is why showing a working example almost always beats writing a long requirements document.
Here’s a step-by-step process for creating prompt sets and integrating them into your design workflow. This should be a collaborative effort between designers, product managers, and developers so the entire team can use, refine, and improve them over time.
Start by working closely with your product manager to identify the core scenarios your AI feature will handle. Focus on the most common and high-impact interactions. Depending on the context, some examples could include onboarding, troubleshooting, summarizing, or creative generation.
A great way to surface these is through a user journey workshop, where the team maps out every possible interaction a user might have with the feature. This helps you visualize gaps and spot overlooked scenarios. For a comprehensive overview of your user’s journey, make sure to account for edge cases, such as when the user requests something the AI can’t do, or when errors occur, so your prompts cover both ideal and failure states.
Don’t stop at ordinary edge cases. Include ambiguous requests, missing information, conflicting instructions, unexpected input formats, attempts to push the AI outside its intended role, and situations where an external tool or data source fails.
For an AI support assistant, for example, test what happens when the user provides incomplete account information, asks the assistant to perform an action it isn’t authorized to take, or when a connected system fails to return the information the AI needs. The goal isn’t only to document the ideal conversation. It’s to understand how the experience degrades when something goes wrong.
Once you’ve mapped out your user journeys, it’s time to draft your prompts for each scenario. When writing prompts, you should keep them specific and contextual, as the AI’s response will be based on the context that you give it. The more context you include in your prompt, the more specific and potentially helpful the response will be.
When describing the expected response, make sure to include the tone of voice that it has (typically based on your brand guidelines). You should also specify how the response should be formatted, whether you want a bullet point list, step-by-step instructions, a paragraph, or an email draft. Don’t forget to include any constraints, such as avoiding technical jargon, limiting word count, or ensuring inclusivity.
Here’s an example of an effective prompt set. Let’s say our AI assistant can help users troubleshoot problems with logging in.
Prompt set: “A user can’t log in to their account. Respond in a friendly, reassuring tone. Provide a clear step-by-step troubleshooting guide (max 5 steps) written at a non-technical reading level. If the issue might require contacting support, end with: ‘If these steps don’t work, our support team is happy to help.’”
This prompt is effective for many reasons. It gives the AI context about the problem, which is that the user can’t log in. It specifies the tone of voice, defines the structure of the response, and sets constraints. Including guardrails in the prompt set limits the chances of the AI surprising your users with an unexpected response.
Of course, prompts are never perfect to begin with. This is where testing them multiple times will help you refine and iterate your prompts to output consistent and relevant responses. You can either use real or simulated inputs, but the key is to test your prompts continuously and flag any bad responses. Involve your PMs, designers, and developers during the review process to ensure that the output is as expected and gather feedback on how the prompt can be improved.
As the feature matures, turn this testing into a repeatable evaluation, or eval. Create a representative set of inputs and run them against the AI whenever something important changes. Instead of asking whether an output simply “looks good,” define acceptance criteria for each behavior.
For example, a support-summary feature might require every response to identify the customer’s main issue, preserve important dates and account details, avoid inventing information, stay below a specified length, and recommend escalation when certain conditions appear. Some criteria can be checked automatically, while qualities such as clarity, tone, and usefulness may still require human review.
Run the same evaluation more than once, too. Generative AI is variable, so one successful output doesn’t prove that the behavior is reliable. What matters is whether the system performs acceptably across repeated runs and a representative range of inputs.
As you build out your library of prompt sets, treat it like a design system library. Store them in a shared document or design system asset so the entire team has quick, consistent access. This enables cross-functional teams to review, test, and refine prompt sets together.
Organize your prompt sets by use case or stage of the user journey, and give them a clear descriptive name, like “Support Summary Prompt”. This makes it easier for stakeholders to find prompts tied to a specific action or customer request. Just like a UI component, provide usage guidelines so team members know when and how to use it. Don’t forget to document the expected behavior to set standards for quality and consistency.
Each prompt set should also be version-controlled, maintaining a clear history so teams can review changes and roll back if the current version isn’t performing well. Assign an owner to each prompt set, who is responsible for maintaining it. The owner should have final approval of any change requests to the prompt sets to ensure the prompt remains effective.
Versioning shouldn’t stop with the prompt itself. Record which model, model version, system instructions, tools, and other important configuration the prompt was tested against. A prompt that behaves reliably with one model may behave differently after a model or tool update.
When any of these dependencies change, rerun the relevant evals before assuming the previous behavior still holds. This gives the team a clearer history of not just what wording changed, but what system produced the behavior users actually experienced.
To ensure smooth collaboration, many teams adopt a simple workflow:
This process mirrors the design process itself, as production work is drafted, reviewed, and iterated on until it meets the requirements.
As your prompt set library grows over time, encourage designers, PMs, engineers, and support teams to log issues or suggestions when a prompt doesn’t perform well. You can create a regular review cadence to evaluate and discuss how the most-used prompts can be improved. Make reviewing the prompts a cross-functional exercise, whether part of a design critique session or sprint reviews.
Prompt sets become even more important, and more complicated, when an AI system can do more than generate text. An AI assistant might search a knowledge base, retrieve customer information, update a ticket, schedule an appointment, or perform another action through connected tools.
In these experiences, don’t evaluate only the final response. Test the decisions the AI makes along the way. Did it choose the correct tool? Did it pass the right information? What happens if the tool fails or returns incomplete data? Does the AI ask for confirmation before taking an irreversible or high-impact action?
For agentic experiences, your behavior specification might therefore include the user’s request, the expected tool or action, conditions requiring confirmation, expected results, possible failure states, and the response the user should see afterward.
This expands the designer’s focus from “What should the AI say?” to “What should the AI do, under what conditions, and how should the user understand and control that behavior?”
Before using prompt sets, a requirements document might simply state something like, “AI should summarize tickets,” leaving engineers to interpret the instruction on their own. This often leads to misaligned outputs and extra iterations.
With prompt sets, the exact prompt and a sample output are documented upfront, ensuring everyone is aligned on expectations before any code is written. This not only reduces ambiguity but also allows teams to prototype AI features quickly, test responses early, and iterate on design and tone before integrating the model into the product.
By treating prompt sets as a lightweight prototyping tool, teams can validate AI behavior, refine user experiences, and foster cross-functional collaboration, ensuring designers, PMs, and engineers are all aligned on both functionality and user-facing outcomes. Success can be measured with clear UX metrics, such as task completion rate, time-to-resolution, reduction in errors, and user satisfaction scores. This way, teams not only prototype faster, but also know when a prompt set is delivering real value and can continuously work to improve it.
Prompt sets turn abstract AI requirements into concrete, testable behaviors. But as AI products become more capable, teams need to go beyond documenting prompts and ideal responses. They need representative test cases, failure states, acceptance criteria, repeated evals, and a record of the models and tools responsible for those behaviors.
This doesn’t make traditional product requirements obsolete. PRDs can define what the product needs to accomplish, while prompt sets and evals help teams determine whether the AI actually behaves as intended. Together, they give designers, PMs, and engineers a shared language for discussing an otherwise unpredictable part of the experience.
If you’re designing a generative or agentic AI feature, start with a small set of important user scenarios. Define what good and bad behavior look like, test them repeatedly, and keep expanding the set as you discover new failures. The goal isn’t to write the perfect prompt. It’s to build an AI experience whose behavior your team can understand, evaluate, and improve over time.
LogRocket's Galileo AI watches sessions and understands user feedback for you, automating the most time-intensive parts of your job and giving you more time to focus on great design.
See how design choices, interactions, and issues affect your users — get a demo of LogRocket today.
After years of designing and building digital products, I’m sharing 10 UX lessons that challenged my assumptions about minimalism, AI, familiarity, and more.
Brand archetypes can define your personality, but they don’t tell you what to say. The imagined speaker technique turns an abstract archetype into a real voice you can write through.
Finding the right UX research participants is hard, and AI has made verifying them even harder. Here’s how to recruit real users, screen for quality, and use synthetic participants without compromising your research.
Navigation menus aren’t always the fastest way forward. Explore how search, personalization, AI, and conversational interfaces are changing how users find what they need, and why traditional navigation still matters.
Learn more →
