Talk to Chatbots: How to Become a Prompt Engineer

Anushree Chatterjee

All things AI, particularly the super-smart “chatbots” we keep hearing about, are trending right now. It’s not just for developers or data scientists anymore. We, the people in software quality assurance, are finding these AI tools a boon to us. Think of it this way: They can not only help us brainstorm test cases and produce realistic test data, but also discover bugs earlier in our process. It is a game changer in the sense that it will speed up the testing, and it will tighten the net.

Now, you may be thinking, “That’s nice, but how am I supposed to talk to these machines so that I can get what I want?” Enter “Prompt Engineering.” Do not be fooled by the fancy name! Put simply, it’s the art of creating super clear and precise instructions – what we call “prompts” – to feed into an A.I. model.

Why is Prompt Engineering Needed?

You’ve probably heard buzzwords like “Natural Language Processing” (NLP) or “Large Language Models” (LLMs) thrown around. These chatbots are not “thinking” like humans. Instead, they are extraordinarily complex pattern-matching machines. They’re trained on vast data, and they learn how words and ideas are likely to play together. You need to tell these machines really well what you need from them. The act of telling them, of writing the perfect instructions so they’ll get you the best answer you possibly can get, is what we call Prompt Engineering.

So when you do give them a prompt, they’re taking everything they know into account and trying to predict what the most likely and relevant sequence of words would be, in order to respond to the prompt, based on all of that information. For us, the trick is to give enough context and clarity for them to select the correct patterns and get the right answer.

Here’s why you’re better off knowing prompt engineering:

• To Get What You Really Need: Without the right prompts, making a vague request to an AI for “test cases” is a poor idea that’ll give unsatisfactory results. However, with responsive engineering, you can request 15 edge-case test cases for the password reset function, specifically designed to highlight security vulnerabilities, and with expected error message for each case (formatted as a CSV).
• To Save Time: Think about the process of manually creating a large dataset of realistic user profiles. It’s tedious and error-prone. Through quick engineering, you get an AI to do it in seconds in perfect format, freeing you to focus on more complex, strategic testing work.
• To Target Specific Testing Needs: Want ideas for performance testing scenarios? Or help analyze a complex user story for ambiguities? Prompt engineering allows you to direct the AI’s power towards very specific areas of your testing process.
• To Reduce “Hallucinations” and Errors: By providing context, constraints, and clear instructions, you significantly reduce the chances of the AI giving you unhelpful or incorrect information. It helps the AI stay “on track.” Read: What are AI Hallucinations? How to Test?
• To Become More Efficient and Strategic: Instead of spending hours on repetitive tasks, you can use prompt engineering to offload those to AI, allowing you to focus on the critical thinking, exploratory testing, and complex problem-solving that only a human tester can do. It elevates your role from a task executor to a strategic orchestrator of testing efforts.

Use Cases for Prompt Engineering in QA

Let’s get down to how you can actually put prompt engineering to work in your day-to-day testing. You might find yourself needing prompt engineering to do the following:

Test Case Generation & Scenario Design

This is perhaps one of the most immediate and impactful uses. Manually writing out dozens, even hundreds, of test cases can be incredibly time-consuming. Instead, you can tell a chatbot, As a QA lead, generate 10 positive and five negative test cases for a user login functionality on an e-commerce website. Include steps, expected results, and consider valid/invalid credentials, forgotten password flow, and account lockout scenarios. Present as a table. The AI can quickly brainstorm a wide array of scenarios you might not immediately think of, covering both typical usage and tricky edge cases. It speeds up your test design significantly, helping you achieve broader test coverage faster. Read: All-Inclusive Guide to Test Case Creation in testRigor.

Test Data Generation

Generating realistic, diverse, or sensitive test data is a never-ending challenge. You don’t want to use actual numbers, and it’s a drag to create hundreds of unique values. Instead, a prompt like, Create a dataset of 20 unique customer profiles for a user registration form. Include fields for name (first, last), email (valid and invalid formats), phone number, and a strong password. Ensure a mix of realistic and edge-case data. In seconds, you have a pool of realistic test data, so you don’t waste time repeatedly populating spreadsheets with random values or, worse, rewriting database collections. This is invaluable when doing everything from form validation to performance testing. Read: How to do data-driven testing in testRigor (using testRigor UI).

Bug Identification & Report Summarization

While AI won’t magically find all your bugs, it can definitely assist in pinpointing potential issues and refining your bug reports. You might say, Analyze the following user story and code snippet. Identify potential vulnerabilities or logical errors that a tester should investigate. Also, suggest three detailed bug report titles based on common issues. The AI can act as a second pair of eyes, sometimes spotting subtle flaws or suggesting areas that warrant deeper investigation. It can also help you craft clearer, more impactful bug report titles, which is great for communication with developers.

Test Automation Scripting

No, AI isn’t going to write all your automation code for you. But it can certainly give you a massive head start and act as a coding assistant. A prompt could be, Generate a Python Selenium script to automate the navigation to the 'Contact Us' page and verify the presence of the contact form. Use explicit waits. It can generate boilerplate code, suggest syntax, or even help debug snippets, speeding up the development of your automation scripts. Always remember to review and adapt the generated code, as it’s a starting point, not a final solution. However, you can use AI agents to generate test cases using plain English requirements/features/app description.

Requirement Analysis and Clarification

Misunderstood requirements are a leading cause of bugs. AI can help you dig deeper into user stories. A prompt like, Given the following user story, identify any ambiguities or missing details from a testing perspective. Ask three clarifying questions to ensure comprehensive testing. The AI can act as a critical reader, highlighting areas that are unclear or lack sufficient detail for effective testing. This helps you get clarifications early, preventing rework later.

Performance and Security Test Ideas

AI can change the way you think about non-functional testing. For example, Suggest five performance testing scenarios for a social media application's live feed feature. Consider concurrent users, data volume, and response times. Also, propose three security testing ideas related to user data privacy. Through this process, AI can generate new ideas for stress, load, or security vulnerability testing that you may not have thought of yourself, extending your test coverage beyond the obvious.

Prompt Engineering in Test Automation Tools

The above section lists how prompt engineering can work with chatbots. However, prompt engineering is even more powerful when you plug this into dedicated testing tools. A great example of this is testRigor.

testRigor is an AI-driven test automation tool that takes the idea of utilizing “talking to chatbots” for testing to the next level. The underlying principle of this tool is to enable testers to write and maintain automated tests in simple English, without having to write a single snippet of code or know large, complex locators like XPath. Which means your manual testers, BAs and even product managers can all play a direct role in test automation — a crucial alignment between technical and non-technical team members.

Here’s how testRigor helps:

• “Plain English” as Prompts: Under the hood, testRigor works by using your plain English instructions as its “prompts”. Instead of writing driver.findElement(By.xpath("//div[@class='login-button']")).click();, you’d simply write: click "Login button". The AI engine knows what to make of these plain English statements and implements those test steps accordingly.
• Focus on User Perspective: What makes testRigor’s approach so aligned with prompt engineering for testers is that you describe actions and validations exactly as an end-user would see them on the screen. You’re prompting the AI based on the visuals and text that an ordinary person interacts with, rather than hidden technical details. This greatly reduces test fragility and maintenance.
• Generative AI for Test Case Creation: testRigor goes a step further by incorporating generative AI. You can provide a high-level description of a feature or even paste it into manual test cases, and testRigor’s AI can intelligently suggest or even auto-generate detailed test steps in plain English format.
• Self-Healing Capabilities: Because testRigor focuses on visible elements and plain language, its tests are inherently more stable. If a developer changes a locator (like an XPath), but the visible text or button name remains the same, testRigor’s AI often “self-heals” and continues to find the element, drastically reducing the infamous “test maintenance” burden.
• Diverse Testing Capabilities through Simple Prompts: Beyond UI testing, testRigor allows you to interact with web, mobile, desktops, APIs, mainframes, databases, emails, SMS, and even handle complex scenarios like 2FA or CAPTCHAs, all through its plain English command structure.

Types of Prompts

Let us review the different types of prompts with examples:

The “Just Ask” (Zero-Shot Prompting)

• What it is: You simply ask your question or issue your directive outright, with no examples or preamble.
• How it works: “Summarize this article.”
• When to use it: This is good for basic knowledge questions or simple tasks where the AI pretty much already knows what you’re asking for.
• Think of it like: Asking a smart friend a very basic question.

The “Here’s an Example” (One-Shot Prompting)

• What it is: You give the AI one example of what you want, and then you ask it to do something similar.
• How it works: Here's how I want bug reports formatted: 'Bug: Login button not clickable. Steps: 1. Go to homepage. 2. Click login button. Expected: Login page loads. Actual: Nothing happens.' Now, generate a bug report for a broken search bar using this format.
• When to use it: This is super helpful when you need the AI to follow a specific style, format, or pattern. It shows the AI exactly what you expect.
• Think of it like: Showing your junior tester one perfectly written bug report and asking them to follow that exact template for the next one.

The “Here are a Few Examples” (Few-Shot Prompting)

• What it is: Similar to one-shot, but you provide multiple examples (say, 2 to 5) to help the AI truly grasp the pattern or style you’re after.
• How it works: You’d give it two or three example bug reports in your desired format, then ask for a new one. Or, Here are some examples of 'good' test data: [list of examples]. Now generate 10 more like these.
• When to use it: When the task is a bit more complex, or the desired output format is very specific, a few examples can significantly improve the AI’s understanding and accuracy. It helps solidify the pattern.
• Think of it like: Giving your junior tester a small collection of really good examples to learn from before they tackle a new task on their own.

The “Think Step-by-Step” (Chain-of-Thought Prompting)

• What it is: This is a good one for pushing your AI to do harder stuff, particularly when it comes to reasoning or multiple steps. You ask the AI to “show its work.”
• How it works: You add phrases such as “Let’s think step by step,” “Walk me through your reasoning”, or “Explain your thought process before you state the answer.”
• When to use it: Best used for intricate logic, mathematical problems (even simple ones in your test context), or when you want the AI to tell you logically how it reached a certain test case, or why it marked a particular vulnerability. It exposes the “thinking” of the AI.
• Think of it like: Making your junior tester not only tell you the correct answer, but to tell you the steps they took to get to the answer, each task they carried out.

The “Act Like a…” (Role-Playing Prompting)

• What it is: You assign a specific persona or role to the AI, which helps it tailor its responses and tone.
• How it works: “Act as a senior QA engineer. Given this user story, what are the top 3 risks from a testing perspective?” or You are a performance testing expert. Suggest 5 load scenarios for a new banking application.
• When to use it: When you want the AI to respond from a particular point of view, using specialized knowledge or tone. This helps ensure the output is relevant to your specific needs as a tester.
• Think of it like: Asking a colleague who specializes in a certain area (like security or performance) for their specific insights.

The “Give Me the Format” (Structured Output Prompting)

• What it is: You explicitly tell the AI the exact format you want its response in, beyond just saying “bullet points.”
• How it works: Return the test cases as a JSON object with keys: 'test_id', 'description', 'steps', 'expected_result'. Or, Provide a Markdown table with columns for 'Scenario', 'Test Data', and 'Expected Outcome'.
• When to use it: Essential when you need the AI’s output to be machine-readable, ready to be pasted into a spreadsheet, a test management tool, or used directly in automation scripts.
• Think of it like: Giving your junior tester a precise template or a pre-defined Excel sheet structure to fill out their findings.

Best Practices & Tips for Becoming a Prompt Engineer

Prompt engineering isn’t so much about remembering complex words; it’s more about getting good at conversing with a very smart, but quite literal, machine. Here’s how to get the most out of your search:

Be Clear, Concise, and Unambiguous

This is your golden rule. AI doesn’t pick up on hints or subtle tips. If you need test cases for a login page, ask something like Generate five positive test cases and five negative test cases for a user login functionality using positive and negative valid and invalid username and password matching. The negative scenarios should include account lockout and 'forgot password' flows.

Provide Ample Context

What if you had to test a feature, and knew nothing about the application in question, or the role of the user? You’d be lost. Chatbots are the same. Provide background before you make your main request. For example, Our app is an e-commerce app. I require test data for the customer registration form as well. The more specific information the AI has, the better it can parse your unique needs and provide an appropriately tailored response.

Iterate and Refine

Your first prompt won’t always be perfect, and that’s completely normal. Think of it as a dialogue, not a one-off command. If the AI’s response isn’t quite right, don’t start over. Follow up instead. “That’s good, but can you make it more concise?” or “Expand on point number three and add more detail about expected error messages.” It’s a continuous process of adjusting and improving. You guide the AI closer to your desired outcome with each interaction.

Use Examples (Few-Shot Prompting)

Sometimes, showing is better than telling. If you have a very specific format or style in mind, give the AI an example. Here's an example of how I want test cases formatted: [Example Test Case]. Now, generate five more in this exact format. This is incredibly powerful for guiding the AI on structure, tone, or specific data patterns, ensuring consistency in its output.

Define Your Desired Output Format

This is crucial for testers who need structured information. Don’t leave it to chance. Be explicit: List the test cases in bullet points, Return the data as a JSON object, Format the bug report ideas as a Markdown table, or Provide the code in Python. You’ll get information that’s immediately usable, whether you’re copying it into a test management tool or feeding it into an automation script.

Set Boundaries and Limitations

Use proper verbs to describe what you need from the AI if it needs to summarize, or elaborate, or write an essay with X paragraphs. For example, Summarize the key test scenarios in no more than 100 words. or Provide three distinct test ideas, but do not include code snippets. This helps the AI stay focused and prevents it from generating overly long or irrelevant responses.

Understand AI Model Limitations

This is perhaps the most important tip. AI is an amazing tool, but it’s not infallible. AI can “hallucinate,” meaning it can confidently make up information that sounds plausible but is completely false. It can also produce biased or outdated information depending on its training data. Always verify the output from an AI. Don’t blindly trust it. Use it as a powerful assistant, not a replacement for your own critical thinking and expertise. Your human judgment as a tester is still paramount.

Experiment and Learn

The best way to get good at prompt engineering is to simply start doing it. Try different phrasings. See how varying levels of detail change the output. Keep a “prompt journal” where you note down successful prompts and the types of results they generated. The more you experiment, the more intuitive it will become to “speak” the AI’s language effectively.

Conclusion

The best way to learn about prompt engineering and AI’s role in testing is to dive in. Prompt engineering is the bridge that connects our human testing needs with the vast capabilities of AI. By mastering this skill, you’ll go from just “talking” to chatbots to truly guiding them to become powerful extensions of your testing toolkit.

“We spent so much time on maintenance when using Selenium, and we spend nearly zero time with maintenance using testRigor.”

Keith Powe VP Of Engineering - IDT