AI Prompt Generator

The AI Prompt Generator is a model-aware tool for building precise and repeatable prompts. It supports Universal use and model-specific versions for ChatGPT, Claude, and Gemini.

The tool helps you define a use case, objective, context, and constraints. You can specify the output format, including JSON with a schema.

You can also provide few-shot examples and set advanced controls like temperature, top_p, and max_tokens.

The tool generates all prompt variants at once. You can copy a prompt with one click or open your preferred chatbot directly.

Features of the tool

This section describes the core features of the AI Prompt Generator. These features help you create effective prompts for various AI models and tasks.

Use Case & Objective

This feature helps you clearly define the purpose of your prompt. It aligns the AI model with your specific goals for a targeted output.

• Specify Use Case: Choose from a list of predefined tasks. This selection tailors the tool's guidance and placeholders to your needs. Available use cases include:
  • Text Generation
  • Summarization
  • Classification
  • Information Extraction
  • Closed-book Q&A
  • RAG Q&A
  • Reasoning/Planning
  • Coding
  • Data Analysis/SQL
• Define Outcome and Success Criteria: Clearly state what a successful output looks like. This helps the model understand your expectations and deliver better results. For example, success for a summary might be "captures all key metrics and dates accurately."
• Set Audience, Tone, and Length Limits: Define the target reader and the desired tone of the response. You can set specific length constraints, such as a word count range or a maximum number of bullet points.

Context & Constraints

Provide the model with the necessary information and rules to follow. This improves the accuracy and relevance of the response.

• Paste Relevant Background: Add any background information the model needs to complete the task. This can include facts, company policies, or text excerpts. The tool clearly separates this context to prevent the model from drifting off-topic.
• Add Constraints: Set specific rules for the model. You can require it to include certain items, refuse to answer specific types of questions, or avoid certain topics. You can also enforce style requirements, like "use formal language only."

Output Formats (Markdown, Text, JSON with schema)

Choose the structure for the AI's response. This feature gives you control over how the final output is presented.

• Markdown or Plain Text: Select Markdown for responses that need formatting like headings, lists, and bold text. Choose plain text for simple, unformatted narrative output.
• JSON with Schema Enforcement: Select JSON for structured data output that can be used in other applications. You can paste a JSON schema to define the exact structure, data types, and required fields. The tool helps enforce this schema, increasing the reliability of the output for automated workflows.

Few-Shot Examples

This optional feature allows you to show the model exactly what you want. Providing examples is a powerful way to guide its tone, format, and structure.

• Provide 1–3 Input/Output Pairs: Add a few clear examples of the desired output for a given input. This helps the model learn the specific pattern you expect.
• Keep Examples Short and Focused: Your examples should be simple and demonstrate the structure you want. They do not need to be long. The goal is to teach the format, not provide extensive content.

Advanced Controls

Fine-tune the model's behavior for more specialized tasks. These controls offer greater command over the generation process.

• Staging: For high-quality, long-form content, you can use a multi-step process. The "Outline → Draft → Revise" staging option instructs the model to first create an outline, then write a draft based on it, and finally revise the draft for quality. For simpler tasks, use the "Single-turn" option.
• Parameters: Adjust model parameters to balance creativity and consistency.
  • Temperature: Controls randomness. Lower values (e.g., 0.2) produce more predictable outputs. Higher values (e.g., 0.8) produce more creative outputs.
  • Top_p: An alternative to temperature that controls the nucleus of probable words the model can choose from.
  • Max_tokens: Sets a limit on the length of the generated response.
• RAG Options: When using Retrieval-Augmented Generation, you can enforce stricter rules. Options include "Answer ONLY from provided context" and "Require citations (chunk IDs)." These ensure the model's answers are based only on the information you provide.

Multi-Model Outputs

The tool automatically creates prompts optimized for different AI models. This saves you time and improves performance across platforms.

• Universal: A general-purpose prompt designed to work well with most models.
• ChatGPT-optimized: A prompt tailored to the strengths of ChatGPT, often using a clear system role and direct instructions.
• Claude-optimized: A prompt formatted with XML-like tags, which helps Claude better understand the structure of the request.
• Gemini-optimized: A prompt that emphasizes structured output and clear schema definitions, playing to Gemini's strengths.

One-Click Actions

Streamline your workflow with simple, direct actions.

• Copy Prompt: Copy the generated prompt for the currently selected model with a single click.
• Open Chatbot: Open ChatGPT, Claude, or Gemini in a new browser tab. The tool also copies the prompt to your clipboard, so you can paste it if the website does not automatically prefill the input.

Built-in Guidance

The tool provides helpful tips and suggestions as you build your prompt.

• Dynamic Placeholders: The interface shows examples and placeholders that change based on your selected use case.
• Schema Suggestions: When you choose Information Extraction or Classification, the tool offers suggestions for structuring your JSON schema.

Fast, Secure Integration

The tool is designed for efficient and secure operation.

• API Key Integration: It uses the site’s secure API key pattern with OpenRouter for quick and protected connections.
• Performance: The tool operates quickly, balancing consistent results with creative freedom through its parameter controls.

How to use the AI Prompt Generator

Follow these steps to create a high-quality, effective prompt.

1. Select Use Case and fill Objective:
   • Start by choosing a use case from the dropdown menu (e.g., Text Generation, Summarization).
   • Write a clear objective. For example: "Write a 700–900 word blog post for small business owners. The post should have two real-world examples and a practical checklist at the end."
   • Specify the audience and tone (e.g., "Executives; concise, professional, friendly").
   • Set any length limits, such as "800–900 words" or "5 bullets max."
2. Add Context & Constraints:
   • Paste any relevant background information into the Context field. This could be product details, customer data, or excerpts from a source document.
   • Add specific rules in the Constraints field. For example: "Must cite two sources from the provided context. Avoid speculation. Refuse to answer if the information is insufficient."
3. Choose Output Format:
   • Select Markdown or Text for articles, emails, or other narrative content.
   • Choose JSON for structured data. If you need a strict format, paste a JSON schema. You can also add a priming stub (e.g., {"key":) to guide the model.
4. Add Few-Shot Examples (optional):
   • Provide one to three simple input-output pairs. This shows the model the exact format and tone you want. For example, for sentiment classification, an example could be: Input: "The service was slow." -> Output: {"sentiment": "Negative"}.
5. Set Advanced Controls:
   • For complex content, consider using the "Outline → Draft → Revise" staging option.
   • Adjust parameters like temperature. Use a low temperature (e.g., 0.2) for factual, deterministic outputs. Use a higher temperature (e.g., 0.7) for creative tasks.
   • If using RAG, enable "ONLY use context" and "Require citations" to ensure factual accuracy.
6. Generate Prompts:
   • Click the generate button. The tool will create four versions of your prompt: Universal, ChatGPT-optimized, Claude-optimized, and Gemini-optimized.
   • Use the tabs to switch between the different versions and compare them.
   • Use the "Copy" or "Open" buttons below the prompt preview to use your generated prompt.

Examples

Here are some examples of how to use the AI Prompt Generator for different tasks.

• Example A: Blog Post (Text Generation)
  • Objective: "Write an 800–900 word article for small business owners on the benefits of accounting automation. Include two real-world examples and a checklist at the end."
  • Context: Include key product benefits, information about target customer personas, and competitive advantages.
  • Format: Markdown.
  • Output: The model will generate a well-structured blog post with clear headings, paragraphs, and a final checklist, ready for publishing.
• Example B: Information Extraction (JSON)
  • Objective: "From the provided invoice text, extract the invoice_number, date (in YYYY-MM-DD format), and total as a number. If any field is missing, set its value to null."
  • Format: JSON. Paste a schema that defines the fields, types, and sets additionalProperties:false to prevent extra fields.
  • Rationale: This prompt ensures you receive reliable, structured data that can be easily processed by other software, such as an accounting system.
• Example C: RAG Q&A
  • Objective: "Answer the user's question using ONLY the provided document chunks. Cite the chunk IDs for each piece of information used. If the answer cannot be found in the context, say 'I do not have sufficient context to answer this question.'"
  • RAG Toggles: Turn ON both "ONLY use context" and "Require citations."
  • Output: The model will provide a concise answer based strictly on the supplied text, including citations like [chunk_3], or it will state that the information is not available.

How to generate prompts for ChatGPT

ChatGPT performs well with clear system roles, direct instructions, and stable parameters.

Core Pattern

• Keep a short system role: Start your prompt with a simple role definition, such as "You are a helpful assistant. Follow all instructions precisely."
• Make output constraints explicit: Tell the model exactly what you want. For example, "Return only valid JSON; do not include explanations or commentary," or "Use Markdown headings for sections and bullet points for lists."
• Use lower temperature: For predictable and factual outputs, set the temperature between 0.1 and 0.3.

Use Cases

• Text Generation: Be very specific about the structure. For example: "The article must have an introduction, three H2 sections, and a conclusion." Also, clearly define the audience, tone, and word count.
• Summarization: Specify the exact number of bullet points, and instruct the model to include key metrics or dates. Add the constraint "Do not add any new information not present in the original text."
• Classification: Provide clear definitions for each label. Include rules for how to handle ambiguous cases. You can also require the model to provide a brief rationale for its choice.
• Information Extraction (JSON): Provide a complete JSON schema. Instruct the model to use null for any missing fields and forbid it from inventing values.
• RAG Q&A: Enforce a strict "Only from context" rule and an "insufficient info" refusal policy. Require citations if you need to trace the source of the information.
• Coding: Specify the programming language, version, and any style guides (like PEP 8 for Python). Ask for tests to be included and request the output as a minimal diff or patch if applicable.

Example (ChatGPT JSON extraction)

System: You are a precise extraction assistant. Return only valid JSON. Do not include any commentary.

User: Extract the required fields from the text provided below. Use this schema:
{
"type": "object",
"properties": {
"invoice_number": {"type": "string"},
"date": {"type": "string", "pattern": "^\\d{4}-\\d{2}-\\d{2}$"},
"total": {"type": "number"}
},
"required": ["invoice_number"],
"additionalProperties": false
}

If a field is missing from the text, set its value to null.

Text: <<<
...paste invoice text here...
>>>

How to generate prompts for Claude

Claude works best with prompts that are highly structured using XML-like tags. This format clearly separates different parts of the instruction.

Core Pattern

• Use XML-like tags for sections: Wrap each part of your prompt in tags like <OBJECTIVE>, <CONTEXT>, <CONSTRAINTS>, <OUTPUT_FORMAT>, and <EXAMPLES>. This helps Claude process the request accurately.
• Avoid Markdown in instructions for plain text output: If you want a plain text response, do not use Markdown formatting within your instruction tags.
• Specify refusal behavior: Clearly instruct the model on what to do if it cannot fulfill the request, especially for RAG tasks.

Use Cases

• Reasoning/Planning: Provide a limited number of steps for the model to follow and require a final answer in a single line to keep the output concise.
• Classification: Include label definitions inside tags and ask for a short rationale for the classification.
• RAG Q&A: Use tags to provide context and add explicit instructions to cite chunk IDs and refuse to answer if the context is insufficient.
• Coding: Use tags to separate constraints, file paths, and acceptance criteria for the code generation task.

Example (Claude structured prompt)

<OBJECTIVE>
Summarize the attached report for an executive audience. The summary must be exactly 5 bullet points.
</OBJECTIVE>

<CONTEXT>
<<<
...paste source text here...
>>>
</CONTEXT>

<CONSTRAINTS>
- Do not introduce any new information that is not in the context.
- You must keep all dates and financial metrics mentioned in the text.
</CONSTRAINTS>

<OUTPUT_FORMAT>
- The output should be plain text.
- Use a maximum of 5 bullet points.
- Each bullet point should be 25 words or less.
</OUTPUT_FORMAT>

How to generate prompts for Gemini

Gemini is very effective at producing structured output, especially when given clear schema constraints.

Core Pattern

• Specify a strict output schema: When you need JSON output, provide a clear schema. This helps Gemini generate a valid and predictable response.
• Emphasize refusal policy: Clearly define what the model should do if it lacks sufficient context to provide a complete answer.
• Use system-style guidance: Frame your instructions with clear roles, steps, and format requirements.

Use Cases

• Information Extraction: Provide a JSON schema and a priming stub. Insist that the model returns only valid JSON with no extra text.
• RAG Q&A: Require citations and enforce the rule to "answer ONLY from provided context."
• Data/SQL: Include the database schema in your prompt. Require the model to generate a single SELECT query. For safety, forbid DML statements (like UPDATE or DELETE) and ask it to include a LIMIT clause.

Example (Gemini JSON with refusal)

System: You are a structured-output assistant. Your response must be only valid JSON that matches the following schema.
Schema:
{
"type": "object",
"properties": {
"title": {"type": "string"},
"bullets": {
"type": "array",
"items": {"type": "string"}
}
},
"required": ["title", "bullets"],
"additionalProperties": false
}

If the information in the context is insufficient to generate the output, you must return: {"title": null, "bullets": []}.

User: Use the context below to produce a JSON object that is compliant with the schema.

Context: <<<
...paste your context here...
>>>

Best Practices

Follow these best practices to improve the quality and consistency of your prompts.

Universal

• Be Specific: Clearly define the task, audience, tone, constraints, and desired length. The more specific you are, the better the result.
• Segment Your Prompt: Separate the different parts of your prompt, such as the role, instructions, context, examples, and output format.
• Validate Structured Outputs: When you require JSON, explicitly instruct the model to "return only valid JSON."

Text Generation

• Define Structure: Demand a specific structure with sections, headings, or paragraph counts. You can also set a maximum sentence or bullet point length.
• Request a Checklist: For actionable content like blog posts, ask the model to include a practical checklist at the end.

Summarization

• Set Limits: Specify the number of bullet points or a maximum word count per bullet to control the length and detail of the summary.
• State "No New Info": Explicitly add a constraint that the summary must not contain any information that was not in the original text.

Classification

• Provide Definitions: Give clear definitions for each label and provide rules for how to handle tie-breaker situations.
• Request Rationale: Ask the model to provide a short, one-sentence justification for its classification choice.

Information Extraction

• Use a Strict Schema: For JSON output, provide a strict schema and a primed stub to guide the model.
• Handle Nulls Correctly: Instruct the model to use null for missing information and never to invent data.

RAG Q&A

• Ensure Faithfulness: Use the constraint "ONLY from provided context" to prevent hallucinations.
• Require Citations: Ask the model to cite chunk IDs so you can verify the source of its information. Instruct it to refuse to answer if the context is insufficient.

Reasoning/Planning

• Keep it Brief: Limit the number of reasoning steps and require a one-line final answer to avoid overly long responses.
• Discourage Verbose Output: Instruct the model to avoid a long chain-of-thought explanation in the final output unless you specifically ask for it.

Coding

• Set Boundaries: Specify the programming language, version, style guide, and tests. You can also ask for the output as a minimal diff.
• Add Constraints: Forbid the model from making unrelated changes and ask it to consider edge cases.

Data/SQL

• Prioritize Safety: Instruct the model to generate SELECT queries only. Require a LIMIT clause to prevent large, slow queries. Include schema references.
• Explain Ambiguities: Prompt the model to note any assumptions it makes if the request is ambiguous.

Frequently Asked Questions (Faqs)

Does the tool guarantee URL prefill in ChatGPT, Claude, or Gemini?

This is not guaranteed because some sites may ignore URL query parameters. However, the tool always copies the prompt to your clipboard, so you can paste it immediately.

Which models are supported?

The tool generates four prompt variants by default: a Universal prompt, a ChatGPT-optimized prompt, a Claude-optimized prompt, and a Gemini-optimized prompt.

Do I need to include examples?

Examples are optional but highly recommended. Providing one to three concise few-shot examples can significantly improve the consistency of the output's format and tone.

How do I make sure I get strict JSON?

Select the JSON output format, paste a complete schema, and add a priming stub. Also, include the instruction: "Return only valid JSON. No commentary."

How can I avoid hallucinations in RAG?

Enable the "ONLY use context" toggle, require citations, and instruct the model to refuse to answer when the context is insufficient.

How do I get consistent results from my prompts?

For consistency, use a lower temperature (between 0.1 and 0.3), set the max tokens to control length, and add strong output formatting rules.

Can I enforce a refusal policy?

Yes. Add a constraint like "If the information provided is insufficient to answer, explicitly say so." You can also use the built-in RAG toggles for this.

How should I handle long context documents?

Paste only the most relevant sections or chunks of the document. Set a strict refusal policy for when information is not in the provided context. For long-form content generation, consider using the "Outline → Draft → Revise" staging feature.

What is the best way to craft model-specific prompts?

• ChatGPT: Use a concise system role and give explicit formatting instructions.
• Claude: Use XML-like tags to structure the different sections of your prompt.
• Gemini: Provide a strict schema for structured output and a clear refusal policy.

Why are the prompts separated by tabs?

The tabs allow you to easily compare the Universal prompt with the model-specific variants. This helps you choose and copy the exact one you need for your task.