Constraints and Rules

Write an article about cloud computing.
Keep the article under 800 words.
Use simple English.
Include three practical examples.
Do not include promotional language.

Explain artificial intelligence.

Explain artificial intelligence to a beginner.
Keep the explanation between 400 and 500 words.
Use simple English.
Include one real-world example.
Avoid mathematical formulas.
End with a five-point summary.

Analyze the customer review.
Classify the sentiment as Positive, Neutral, or Negative.
Select only one sentiment label.
Do not create additional sentiment categories.
Return the confidence score as a percentage.
If the review is empty, return Invalid Input.

Act as a senior business analyst.
Summarize the following quarterly performance report.
Write for non-technical executives.
Keep the response under 300 words.
Include revenue, expenses, risks, and recommendations.
Do not introduce information that is absent from the report.
Use four clearly labeled sections.
Report:
[Insert report here]

Create interview questions about Java.

Create 20 Java interview questions.
Target developers with two to four years of experience.
Cover collections, exception handling, multithreading, and Java 8.
Include a concise answer after every question.
Use Easy, Medium, and Hard difficulty levels.
Return the result in Markdown format.

Explain Java collections.
Cover only List, Set, Queue, and Map.
Do not explain legacy collection classes.
Keep the focus on interview preparation.

Recommend a laptop for software development.
Focus on Java development, Docker, and local databases.
Exclude gaming-focused features.
Prioritize memory, processor performance, battery life, and build quality.

Summarize the medical document.
Do not provide a diagnosis.
Do not recommend prescription medication.
Clearly separate documented facts from general information.
Advise the reader to consult a qualified medical professional for treatment decisions.

Explain prompt engineering in no more than 150 words.
Write exactly five bullet points.
Keep each bullet point under 25 words.
Produce three paragraphs.
Limit the title to 60 characters.

Keep it short.

Keep the response between 120 and 150 words.

Return the result in Markdown format.
Use one main heading.
Use level-two headings for major sections.
Present comparisons in a table.
End with a checklist.

Analyze the support ticket.
Return valid JSON.
Use only the fields ticket_id, category, priority, summary, and recommended_action.
Do not include text outside the JSON object.

Explain REST APIs.
Include the definition of a resource.
Explain HTTP methods.
Include one GET request example.
Include one POST request example.
Explain common HTTP status codes.
End with three best practices.

Include important details.

Include authentication, rate limiting, pagination, error handling, and versioning.

Do not include historical background.
Do not use promotional language.
Do not mention competing products.
Do not include unsupported statistics.
Do not repeat the same example.
Do not generate personal information.
Do not use technical jargon without explanation.

Write the response in English.
Use simple vocabulary suitable for beginners.
Keep technical terms in English.
Explain every abbreviation when it first appears.
Do not mix languages in the same sentence.

Use British English spelling.
Use Indian currency formatting.
Write dates in the DD-MM-YYYY format.

Write in a professional and reassuring tone.
Avoid exaggerated claims.
Do not sound promotional.
Address the reader directly.

Make it sound good.

Use a professional, confident, and neutral tone.
Avoid slang, humour, and marketing language.

Write for beginners with no programming experience.
Write for senior Java developers.
Write for non-technical business managers.
Write for students preparing for interviews.
Assume the reader understands basic SQL.

Explain dependency injection to a beginner Java developer.
Assume the reader understands classes and interfaces.
Do not assume prior knowledge of Spring Framework.

Provide a conceptual explanation only.
Include implementation-level details.
Explain the internal execution flow.
Include time and space complexity.
Avoid mathematical derivations.
Explain both beginner and advanced perspectives.

Explain Java HashMap.
Cover hashing, buckets, collisions, resizing, and treeification.
Do not explain the complete source code implementation.
Include one practical usage example.

Organize the article in the following order:
Definition
Purpose
Working process
Syntax
Example
Advantages
Limitations
Best practices
Summary

Generate ten interview questions.
Include four options for each question.
Provide one correct answer.
Add one explanation for every answer.
Create three Easy, four Medium, and three Hard questions.

Use only the information provided in the source text.
Do not use external knowledge.
Base every conclusion on the supplied dataset.
Clearly mark any assumption.
Do not invent missing values.

Summarize the contract using only the provided clauses.
Do not infer legal obligations that are not explicitly stated.
Quote clause numbers when mentioning important conditions.

Do not invent facts.
State uncertainty when information is incomplete.
Separate facts from assumptions.
Do not generate citations that were not provided.
Mention when a claim cannot be verified.
Use exact values from the input data.

Use only facts contained in the supplied document.
If the document does not contain the answer, return Information not available in the source.

Use active voice.
Keep sentences under 25 words.
Avoid unnecessary adjectives.
Use descriptive headings.
Do not repeat the conclusion.
Use parallel structure in bullet points.
Define technical terms before using them.

Use concise technical writing.
Prefer active voice.
Avoid filler phrases.
Keep each paragraph focused on one idea.
Do not use rhetorical questions.

Write the solution in Java 21.
Use only the standard library.
Do not use third-party dependencies.
Follow object-oriented design.
Validate all user input.
Handle exceptions explicitly.
Add concise single-line comments.
Include a main method that demonstrates the solution.

Return only the final answer.
Do not include an introduction.
Do not explain your reasoning.
Do not include text before or after the JSON object.
Return only the selected category name.

If the input is valid, return the calculated result.
If a required field is missing, return Missing Required Field.
If the value is negative, return Invalid Value.
Do not continue processing after a validation failure.

Prioritize factual accuracy over response length.
Prioritize user safety over task completion.
When brevity conflicts with clarity, choose clarity.
When source documents conflict, report the conflict instead of selecting one silently.

Design the solution for one million daily users.
Keep API response time below 300 milliseconds under normal load.
Minimize database queries.
Support horizontal scaling.
Avoid a single point of failure.
Use caching only for non-sensitive data.

Do not store passwords in plain text.
Use parameterized queries.
Validate and sanitize user input.
Apply role-based access control.
Do not expose internal error details.
Encrypt sensitive data in transit and at rest.

The code must run on Java 17 or later.
The page must support modern Chrome, Edge, and Firefox browsers.
Do not use experimental browser APIs.
The SQL must be compatible with MySQL 8.
The solution must run on Windows and Linux.

Return exactly five recommendations.
Use a numbered list.
Do not include more than one sentence per recommendation.

Prefer examples from web development.
Keep the explanation concise where possible.
Use analogies only when they improve clarity.

Include one practical example.
Use a comparison table.
Explain every technical term.
Provide a summary checklist.

Do not use complex mathematical notation.
Do not include external links.
Do not repeat the same explanation.
Do not generate unsupported claims.

Do not write a long answer.

Keep the response between 150 and 200 words.

Use exactly four bullet points.

Write a short, simple, professional response with examples and no unnecessary details.

Keep the response under 300 words.
Use simple English.
Maintain a professional tone.
Include two practical examples.
Remove information that does not support the main topic.

Write a short explanation.

Write between 150 and 200 words.

Make it beginner-friendly.

Write for readers with no prior knowledge.
Define every technical term when it first appears.
Use one everyday analogy.
Avoid mathematical notation.

Write an article about prompt engineering.
Target beginner-level readers.
Use Markdown format.
Keep the article under 1,000 words.
Include two practical examples.
End with a summary checklist.
Do not include promotional content.

Generate exactly 15 questions.
Keep every answer under 80 words.
Include four options per question.
Use one correct option per question.
Add a difficulty label to every item.

Classify the ticket priority.
Use only Low, Medium, High, or Critical.
Return exactly one priority value.
Do not create additional categories.

Extract the invoice number.
If no invoice number is present, return Not Found.
Do not guess or generate an invoice number.

Answer using only the supplied document.
Do not use general knowledge.
If the answer is missing, return Not Available in Document.
Do not infer unstated information.

Extract customer information from the text.
Do not include passwords, payment card numbers, or authentication tokens.
Return valid JSON using the required schema.

Add a category.
Include the classification.
Return the type.

Add a category.
Use one category from the allowed category list.
Return the category in the category field.

Write exactly 200 words.
Use exactly ten paragraphs.
Use exactly two sentences in every paragraph.
Keep every sentence under ten words.
Include seven examples.
Avoid all technical terminology.

Act as a senior Java interviewer.
Create interview questions about Java multithreading.
Target candidates with three to five years of experience.
Cover thread lifecycle, synchronization, locks, executors, and concurrency utilities.
Generate exactly 20 questions.
Use Easy, Medium, and Hard difficulty levels.
Include a concise answer and explanation for every question.
Do not repeat the same concept.
Return the result in Markdown format.
Use a level-two heading for every question.

Explain the topic in complete technical detail.
Keep the response under 100 words.

Provide a concise technical overview in 300 to 400 words.
Focus on the definition, working process, benefits, and limitations.
Exclude historical background.

Return valid JSON.
Explain the result after the JSON.

Return valid JSON only.
Put the explanation inside the explanation field.
Do not include text outside the JSON object.

Write for complete beginners.
Use advanced technical terminology throughout.

Use necessary technical terms.
Define each technical term in simple language when it first appears.

Cover all major Spring Boot topics.
Generate only three questions.

Generate 30 questions.
Distribute them across configuration, dependency injection, REST APIs, data access, security, testing, and monitoring.

Use only the supplied text.
Add the latest industry statistics.

Use the supplied text for the main analysis.
Place externally verified statistics in a separate section.
Clearly identify every external fact.

Prioritize factual accuracy over completeness.
Prioritize valid JSON over explanatory prose.
Prioritize security requirements over implementation convenience.
When two requirements conflict, follow the requirement listed first.

Make the content useful and detailed.

Explain the definition, working process, advantages, limitations, and three practical use cases.

Write a professional article under 500 words with examples, a table, a summary, and simple explanations without repetition.

Write a professional article.
Keep the article under 500 words.
Use simple explanations.
Include two examples.
Include one comparison table.
End with a summary.
Do not repeat the same point.

Explain every concept in depth.
Keep the response to five bullet points.
Keep every bullet under ten words.

Do not be vague.
Do not be too technical.
Do not write too much.
Do not use irrelevant examples.

Define each concept precisely.
Write for beginner-level readers.
Keep the response between 500 and 700 words.
Use examples from common business applications.

Extract the customer phone number.

Extract the customer phone number.
If no phone number is present, return Not Found.
Do not infer or generate a phone number.

Return JSON with comments.

Return valid JSON.
Do not include comments.
Put explanatory information inside the description field.

Act as a technical content writer.
Write an article about zero-shot prompting.
Target readers who understand basic prompt engineering.
Explain the definition, working process, benefits, limitations, and use cases.
Keep the article between 1,000 and 1,200 words.
Use Markdown format.
Use one main heading and level-two section headings.
Include three practical prompt examples.
Keep every prompt instruction on a separate line.
Do not repeat the same explanation.
Do not include unsupported statistics.
End with a concise best-practices checklist.

Extract order information from the supplied text.
Return valid JSON only.
Use the fields order_id, customer_name, order_date, total_amount, currency, and status.
Use null when a value is not present.
Do not infer missing information.
Preserve the exact order identifier.
Format the date as YYYY-MM-DD.
Return total_amount as a numeric value.
Do not include Markdown or explanatory text.

Analyze the customer feedback.
Classify the sentiment as Positive, Neutral, or Negative.
Use exactly one sentiment category.
Return a confidence score between 0 and 100.
Include a one-sentence explanation.
Do not introduce categories outside the allowed list.
If the feedback is empty, return Invalid Input.

Act as a senior Java developer.
Create a REST API for managing employee records.
Use Java 21 and Spring Boot 3.
Use Spring Web, Spring Data JPA, and Bean Validation.
Use MySQL as the database.
Follow controller, service, repository, entity, and DTO layers.
Do not expose entity objects directly from controllers.
Validate all incoming request data.
Use a global exception handler.
Return appropriate HTTP status codes.
Add concise single-line comments only where required.
Do not use deprecated APIs.
Include unit tests for the service layer.

Summarize the supplied technical report.
Use only information contained in the report.
Keep the summary under 250 words.
Include the objective, key findings, risks, and recommendations.
Use four labeled sections.
Do not add external facts.
Do not copy long sentences from the source.
If a required section is missing, write Not Discussed in the Report.

Create 20 multiple-choice questions about prompt engineering.
Use Easy, Medium, and Hard difficulty levels.
Include four options for every question.
Use exactly one correct answer.
Add a concise explanation for the correct answer.
Cover prompt structure, context, constraints, examples, and output formatting.
Do not repeat questions or concepts.
Do not use trick questions with multiple valid answers.
Return the result in Markdown format.

Analyze the job application.
Return valid JSON only.
Use the fields candidate_name, experience_years, primary_skill, eligibility, and reason.
Return experience_years as a number.
Use Eligible or Not Eligible for eligibility.
Use null for missing values.
Do not infer information that is not present.
Do not include text outside the JSON object.

{
    "candidate_name": "Anita Sharma",
    "experience_years": 4,
    "primary_skill": "Java",
    "eligibility": "Eligible",
    "reason": "The candidate meets the minimum Java experience requirement."
}

Review the supplied source code.
First identify compilation errors.
Next identify runtime risks.
Then identify security weaknesses.
Finally recommend improvements.
Do not rewrite the complete application.
Include only issues supported by the supplied code.
Assign each issue a severity of Low, Medium, High, or Critical.
Provide a corrected code fragment for High and Critical issues.

Use the database search tool before answering product availability questions.
Do not claim that a product is available without checking the database.
Use the calculator tool for financial calculations.
Do not calculate tax rates from memory.
Ask for confirmation before performing irreversible actions.
Do not expose internal tool outputs to the user.
If a tool fails, report the failure clearly and avoid guessing.

Answer using only the retrieved context.
Cite the document identifier for every major claim.
Do not use prior knowledge when the retrieved context is incomplete.
If the answer is not present, return Insufficient Information.
Report conflicting information from different documents.
Prefer the most recent document when versions differ.
Do not invent document references.

Teach exception handling in Java.
Target beginner-level learners.
Explain checked and unchecked exceptions.
Include one syntax example.
Include one real-world example.
Include three common mistakes.
End with five practice questions.
Do not introduce custom exception design until the basic concepts are explained.
Define every new technical term.

Act as a Java technical interviewer.
Generate 25 interview questions about the Collections Framework.
Target candidates with three years of experience.
Cover List, Set, Queue, Map, iterators, concurrency, and performance.
Include a direct interview answer for every question.
Add important follow-up questions.
Use Easy, Medium, and Hard difficulty levels.
Do not repeat the same concept.
Keep every answer under 150 words.
Use practical examples where relevant.

Task:
Summarize the customer feedback.
Rules:
Use only the supplied feedback.
Keep the summary under 100 words.
Mention the main complaint.
Mention the requested improvement.
Do not expose personal information.
Customer Feedback:
<feedback>
The application is useful, but the checkout page becomes slow when multiple items are added.
</feedback>

Role:
Act as [role or persona].
Task:
Perform [specific task].
Context:
Use the following background information: [context].
Input:
Process the following input: [input data].
Constraints:
Keep the response between [minimum] and [maximum] words.
Use [language and tone].
Include [required content].
Exclude [prohibited content].
Use only [allowed information sources].
Do not infer missing information.
Rules:
Follow the required processing order.
Use only the allowed category values.
Handle missing input using the defined fallback response.
Prioritize accuracy over brevity.
Output Requirements:
Return the response in [format].
Use the fields or sections [required structure].
Do not include text outside the required output.
Validation:
Verify that every required field is present.
Verify that all values follow the allowed format.
Verify that no prohibited content is included.

Act as a prompt engineering instructor.
Explain constraints and rules in effective prompts.
Target beginner and intermediate learners.
Cover definitions, types, importance, common mistakes, and best practices.
Keep the article between 1,500 and 2,000 words.
Use Markdown format.
Use one main heading and level-two section headings.
Include at least five practical prompt examples.
Keep every prompt instruction on a separate line.
Do not split a single instruction across multiple lines.
Do not use repetitive examples.
Do not include unsupported claims.
Use clear technical language.
Explain every advanced term.
End with a validation checklist.