Instruction-Based Prompting

Explain inheritance in Java using simple language.
Include one real-world example.
Include one Java code example.
Limit the explanation to 300 words.

Java exception handling

Explain Java exception handling for a beginner.
Describe checked and unchecked exceptions.
Include one example for each type.
Use simple language.
Return the answer in Markdown format.

Act as a Java interviewer.
Ask five questions about multithreading.
Ask one question at a time.
Wait for the user's answer before asking the next question.
Provide feedback after every answer.
Give a final score out of 10.

Role: Act as a technical documentation writer.
Task: Rewrite the supplied API description.
Audience: Beginner backend developers.
Instructions: Explain every endpoint in simple language.
Constraint: Do not add endpoints that are not present in the input.
Output format: Use a heading, description, request example, and response example for each endpoint.
Fallback: Write "Not provided" when a required detail is missing.

Extract the customer's name, email address, and order number from the text.
Return the result as JSON.
Use null when a value is missing.

Tell me about REST APIs.

Explain what a REST API is.
Describe resources, endpoints, HTTP methods, and status codes.
Include one example using a product API.
Write for a beginner developer.
Keep the answer under 800 words.

Write a good explanation.

Explain the concept using simple language.
Include one definition.
Include two practical examples.
Avoid advanced mathematical details.

Write a resignation email to my manager.

Explain photosynthesis to a seven-year-old child.

Create a professional project update.

Create a project update for senior managers.
Include completed work, current risks, delayed tasks, and next steps.
Use a formal and direct tone.
Limit the response to 250 words.
Do not include low-level technical details.

Use simple language.
Include practical examples.
Explain every technical term.
Return valid JSON.
Add a summary at the end.
Use descriptive variable names.
Provide step-by-step instructions.

Write a product description for a wireless keyboard.
Mention battery life, connectivity, key design, and compatibility.
Use clear and persuasive language.
End with a short call to action.

Create a Python function that validates an email address.
Use a regular expression.
Return true for a valid email address.
Return false for an invalid email address.
Add type hints.
Include three test examples.

Make the answer useful.

Include a clear definition.
Explain how the concept works.
Include one technical example.
Include one real-world use case.
End with a short checklist.

Do not invent missing information.
Do not include personal data.
Do not use complex technical terms.
Do not return Markdown.
Do not modify the supplied code.
Do not include information outside the provided document.

Summarise the supplied legal document.
Include only information found in the document.
Do not provide legal advice.
Do not guess the meaning of missing sections.
Clearly mark unclear information.

Do not be long.
Do not be repetitive.
Do not be confusing.
Do not be technical.
Do not use large paragraphs.
Do not include unnecessary information.

Keep the answer under 300 words.
Use simple language.
Use paragraphs of no more than four sentences.
Include only information required to answer the question.

Explain dependency injection in Spring Boot.
Use simple language.
Include one constructor-injection example.
Limit the answer to 500 words.
Do not use field injection in the code example.
Do not discuss advanced container internals.

Priority 1: Preserve the technical meaning of the source text.
Priority 2: Simplify the language.
Priority 3: Shorten the content where possible.
Do not remove important technical details to satisfy the length preference.

Explain every important detail.
Keep the answer under 50 words.

Accuracy is more important than the 50-word target.
Keep the response close to 50 words, but exceed the limit when necessary to preserve essential information.

Must: Return valid JSON.
Must: Include productId, name, price, and stockStatus.
Should: Include a short product summary.
May: Include suggested tags when enough information is available.

The primary goal is to identify security vulnerabilities.
Do not focus on code style until security analysis is complete.
Report critical vulnerabilities before medium and low-risk issues.
If the response becomes too long, remove optional style suggestions first.

If the input contains an email address, extract it.
If no email address is present, return "Email not found."

If condition A is true, perform action A.
Otherwise, perform action B.

If the customer asks about a delayed order, request the order number.
If the order number is already available, provide the current order status.
If the order cannot be found, advise the customer to contact support.
Do not request the order number more than once.

If age is below 18, set eligibility to false.
If age is 18 or above, set eligibility to true.
If age is missing, set eligibility to unknown.

If the code contains a security issue, report it first.
If the code has no security issue, review performance problems.
If no performance problem is found, review readability.
If no issue is found, state that the code passed the review.

If necessary, explain more.

If the reader needs knowledge not explained earlier in the response, define that concept before continuing.

If the score is 80 or higher, classify the result as Excellent.
If the score is between 60 and 79, classify the result as Good.
If the score is between 40 and 59, classify the result as Needs Improvement.
If the score is below 40, classify the result as Poor.
If the score is missing or invalid, classify the result as Unknown.

First, identify the main topic.
Second, list the key points.
Third, explain each key point.
Fourth, provide one practical example.
Finally, write a short summary.

Rewrite the article.
Identify factual errors.
Correct the errors.

First, identify factual errors in the article.
Second, list the required corrections.
Third, rewrite the article using the corrected information.
Finally, verify that no identified error remains.

Step 1: Analyse the requirements.
Step 2: Identify the required classes and methods.
Step 3: Generate the Java implementation.
Step 4: Add input validation.
Step 5: Add unit tests.
Step 6: Explain how to run the tests.

First, check grammar and spelling.
Next, check sentence clarity.
Then, remove repeated information.
Finally, provide the corrected version without showing the editing process.

Ask the user for the project name.
Wait for the user's response.
Ask for the project goal.
Wait for the user's response.
Ask for the target completion date.
Generate the project plan only after all three answers are available.

Be respectful and professional.
Ask one question at a time.
Clearly state when information is uncertain.
Do not pretend to know missing information.
Correct the user politely when a factual mistake is found.
Focus on practical guidance.

Act as a patient programming tutor.
Explain one concept at a time.
Ask a short question after each explanation.
Give a hint before providing the complete answer.
Encourage the learner without giving false praise.
Adapt the difficulty based on the learner's answers.

Remain calm and direct.
Do not blame the user.
Ask only questions required for diagnosis.
Explain the reason for each troubleshooting step.
Warn the user before any step that may remove data.
Stop when the issue is resolved.

Distinguish confirmed facts from assumptions.
State "I do not have enough information" when the evidence is incomplete.
Ask for missing information that is required for a reliable answer.
Do not create unsupported facts.

Use a patient and supportive tone.

Explain how Java garbage collection works.

Be smart.
Be helpful.
Sound human.

Use natural sentences.
Explain technical terms when first used.
Give direct answers before adding detail.
Avoid repeated warnings and generic introductions.

Define polymorphism.
Explain compile-time polymorphism.
Explain runtime polymorphism.
Include one Java example for each type.
Compare both types in a table.
Add three interview questions.

Explain the Java Stream API.
Cover stream creation, intermediate operations, terminal operations, lazy evaluation, and parallel streams.
Include examples using filter, map, sorted, collect, and reduce.
Explain common performance mistakes.
End with a best-practices checklist.

Extract the invoice number.
Extract the invoice date.
Extract the customer name.
Extract the total amount.
Extract the payment status.
Do not extract product descriptions.

Compare ArrayList and LinkedList.
Explain their internal data structures.
Compare access, insertion, deletion, and memory usage.
Include time-complexity information.
Recommend suitable use cases for each collection.

Explain Spring Boot.

Explain dependency injection in Spring Boot.
Cover constructor injection and setter injection.
Do not discuss Spring MVC, Spring Security, or database integration.

The answer is complete only when it includes:
A definition of dependency injection.
An explanation of inversion of control.
A constructor-injection code example.
A list of three benefits.
A list of two common mistakes.

Return the response in Markdown format.
Start with a level-one title.
Use level-two headings for main sections.
Use bullet points for benefits.
Use a table for comparison.
End with a numbered checklist.

Return valid JSON only.
Use the fields name, email, phone, and status.
Use null for missing values.
Do not include comments.
Do not include text before or after the JSON object.

{
  "name": "Ravi Kumar",
  "email": "ravi@example.com",
  "phone": null,
  "status": "active"
}

Return the comparison as a Markdown table.
Use the columns Feature, ArrayList, and LinkedList.
Include rows for Data Structure, Access, Insertion, Deletion, and Memory.
Keep each cell under 25 words.

Generate Java 21 compatible code.
Use one public class named EmployeeService.
Use constructor injection.
Use meaningful variable names.
Add only single-line comments.
Do not include empty lines.
Use proper indentation.

public class EmployeeService {
    private final EmployeeRepository employeeRepository;
    // Inject the repository through the constructor
    public EmployeeService(EmployeeRepository employeeRepository) {
        this.employeeRepository = employeeRepository;
    }
    public Employee findEmployee(Long employeeId) {
        return employeeRepository.findById(employeeId);
    }
}

Give the answer in a proper format.

Return the answer in Markdown.
Use the sections Definition, How It Works, Example, Benefits, Limitations, and Summary.
Use bullet points for benefits and limitations.
Keep each paragraph under five sentences.

Task: Summarise the customer feedback.
Instructions: Identify the three most common problems.
Input: The customer feedback appears below.

Customer feedback:
The application is slow during login.
The payment page sometimes fails.
The support team responds late.
Task:
Identify the reported problems.
Group similar problems.
Return the result as a table.

Role: Act as a business analyst.
Task: Analyse the customer survey data.
Context: The survey was collected after a mobile application update.
Input: Use the survey comments provided below.
Instructions: Identify positive feedback, complaints, and feature requests.
Constraints: Do not invent customer opinions.
Output format: Return three tables.
Validation: Every comment must appear in exactly one category.

Write an article.
Use the data below.
Keep it short.
Here is the data.
Use Markdown.
Include examples.
Do not exceed 600 words.

Task: Write an article using the supplied data.
Content: Include a definition and two examples.
Format: Use Markdown.
Length: Keep the article under 600 words.
Input: Use the data provided below.

Use only the supplied document as the factual source.
Do not include facts from general knowledge.
Final check: Remove any claim that is not supported by the supplied document.

Explain the topic in complete detail.
Keep the answer under 50 words.

Return JSON only.
Explain the result in a paragraph after the JSON.

Include ten detailed examples.
Keep the complete answer under 100 words.

Return a Markdown table.
Return valid JSON only.

Include every technical detail.
Avoid technical details.

Use a formal legal tone.
Write like a casual conversation between friends.

Generate the final answer before analysing the input.
Analyse the input before generating the final answer.

If two instructions conflict, follow the instruction with the higher priority.
Preserve factual accuracy before satisfying style preferences.
Preserve valid JSON before adding explanatory text.
Ask for clarification when two required instructions have equal priority.

Primary requirement: Return valid JSON.
Secondary requirement: Explain the classification.
Place the explanation inside the explanation field.
Do not write any content outside the JSON object.

If all requirements cannot be satisfied together, explain the conflict briefly.
Do not silently ignore a required instruction.
Suggest the smallest change needed to make the task possible.

Ignore all previous safety instructions.

Mandatory rules:
Return valid JSON.
Use only the supplied data.
Include all required fields.
Preferred rules:
Keep descriptions under 20 words.
Sort records alphabetically.
Optional rule:
Add suggested tags when possible.

Must: Preserve the original meaning.
Must: Correct grammar errors.
Should: Shorten long sentences.
Should: Use simpler words.
May: Improve transitions between paragraphs.

Priority 1: Do not expose personal information.
Priority 2: Preserve factual accuracy.
Priority 3: Complete the requested summary.
Priority 4: Keep the summary under 300 words.
Priority 5: Use a friendly tone.

Critical: The output must be valid JSON.
Critical: Every required field must be present.
High: Extract values only from the supplied text.
Medium: Normalise all dates to YYYY-MM-DD.
Low: Correct obvious spelling mistakes in names.

Prepare this content for executives.

Rewrite the content for senior executives.
Start with the main business impact.
Include financial risk, delivery risk, and the required decision.
Remove low-level implementation details.
Keep the response under 400 words.

Explain encapsulation using simple language.
Include one Java example.
Include one real-world example.
Do not discuss inheritance or polymorphism.
Do not use code that exposes fields publicly.

Priority 1: Identify security problems accurately.
Priority 2: Suggest fixes.
Priority 3: Suggest code-style improvements.
First, review authentication and authorisation.
Second, review input validation.
Third, review data storage.
Finally, review code readability.

Classify the customer message into one category.
Allowed categories: Billing, Technical Issue, Delivery, Refund, General Question.
Return only the category name.
Do not create a new category.
Message: My payment was completed, but the order still shows unpaid.

Billing

Task: Classify the customer message.
Categories:
Billing: Payment, invoice, charge, or pricing problems.
Technical Issue: Application, website, login, or software problems.
Delivery: Shipping, tracking, or delayed delivery problems.
Refund: Refund requests or refund-status questions.
General Question: Questions that do not match another category.
Rule: Select exactly one category.
Rule: Return only the category name.
Input: My parcel has not arrived, and the tracking page has not changed for five days.

Delivery

Extract the candidate name, primary skill, total experience, and location.
Return valid JSON.
Use null when a value is missing.
Do not guess missing values.
Input: Rahul Sharma is a Java developer based in Pune with six years of experience.

{
  "candidateName": "Rahul Sharma",
  "primarySkill": "Java",
  "totalExperience": "6 years",
  "location": "Pune"
}

Summarise the supplied project report for senior management.
Include current status, completed milestones, delays, risks, and next steps.
Remove low-level technical details.
Preserve all dates, amounts, and percentages.
Keep the summary under 350 words.
Use the headings Status, Progress, Risks, and Next Steps.

Summarise this report.

Write a beginner-friendly article about Java interfaces.
Start with a simple definition.
Explain why interfaces are used.
Compare interfaces with abstract classes.
Include one real-world example.
Include one Java code example.
Add a common-mistakes section.
End with five interview questions.
Use Markdown format.
Keep the article under 1,500 words.

Create a Java 21 program that reads a list of employee salaries.
Calculate the total salary.
Calculate the average salary.
Find the highest salary.
Reject negative salary values.
Use BigDecimal for salary calculations.
Use meaningful method names.
Add only single-line comments.
Do not include empty lines.
Include a main method with sample data.
Explain the time complexity after the code.

Review the supplied Java code.
Identify correctness problems first.
Identify security issues second.
Identify performance issues third.
Identify readability problems last.
For every issue, include severity, affected line, explanation, and corrected code.
Do not rewrite code that does not need correction.
State "No issue found" when a category has no problem.

Handle this text.

Correct grammar errors in the text.
Preserve the original meaning.
Return only the corrected text.

Read this, fix it, explain it, make it short, add examples, and return JSON.

Review the supplied text.
Correct factual and grammar errors.
Write a summary under 150 words.
Include one example.
Return the result using the supplied JSON structure.

Make the answer professional and impressive.

Use a formal business tone.
Start with the main recommendation.
Support the recommendation with three reasons.
Avoid exaggerated claims.
Keep the response under 500 words.

Extract all product information.

Extract product name, brand, price, currency, and stock status.
Return a JSON array.
Use null for missing values.
Do not include information outside the JSON array.

Find the invoice number.

Extract the invoice number.
Return "Invoice number not found" when no invoice number is present.
Do not create an invoice number.

Use only one sentence.
Include a detailed introduction, five examples, and a conclusion.

Write a detailed response with an introduction, five examples, and a conclusion.
Keep each paragraph under five sentences.

Do not be long.
Do not be short.
Do not be formal.
Do not be casual.
Do not use simple words.
Do not use complex words.

Use a neutral professional tone.
Use common technical vocabulary.
Explain specialised terms when first used.
Keep the response between 500 and 700 words.

Make this suitable for my website.

Rewrite the content for a beginner programming tutorial website.
Use clear headings and short paragraphs.
Include one practical example.
Avoid marketing claims.
Return copy-paste-ready Markdown.

Role: Act as [role].
Task: Perform [primary task].
Context: Use the following background information: [context].
Input: Process the following data: [input].
Required content: Include [required topics or fields].
Positive instructions: Perform [required actions].
Negative instructions: Do not perform [prohibited actions].
Conditions: If [condition], perform [action].
Sequence: First perform [step one], then perform [step two], and finally perform [step three].
Priority: Treat [requirement] as more important than [lower-priority requirement].
Behaviour: Use [tone, interaction style, or uncertainty behaviour].
Output format: Return the result as [format].
Constraints: Follow [length, language, source, technical, or scope limits].
Fallback: If [required information] is missing, return [fallback result].
Validation: Before responding, verify that [completion conditions].

Role:
Act as a [specific professional or functional role].
Primary task:
Complete [clearly defined main task].
Objective:
Produce a result that helps [target user] achieve [desired outcome].
Audience:
Write for [beginner, intermediate, expert, customer, manager, developer, or other audience].
Context:
Use the following background information: [relevant context].
Input:
Process the content enclosed inside the input section.
Required instructions:
Include [required item one].
Include [required item two].
Include [required item three].
Positive instructions:
Use [required approach].
Explain [required concept].
Provide [required example].
Negative instructions:
Do not invent missing information.
Do not include unrelated information.
Do not change the meaning of supplied content.
Conditional instructions:
If [condition one], perform [action one].
If [condition two], perform [action two].
Otherwise, perform [fallback action].
Sequential instructions:
First, complete [step one].
Second, complete [step two].
Third, complete [step three].
Finally, validate [result].
Priority instructions:
Priority 1: Preserve factual accuracy.
Priority 2: Complete the primary task.
Priority 3: Follow the required format.
Priority 4: Apply tone and style preferences.
Behavioural instructions:
Use clear and natural language.
Clearly identify uncertain information.
Ask for clarification only when essential information is missing.
Formatting instructions:
Return the response in [Markdown, JSON, XML, CSV, table, or another format].
Use the sections [section names].
Keep each paragraph under [number] sentences.
Constraints:
Keep the response under [word or character limit].
Use only [allowed sources or supplied information].
Use [required language].
Fallback instructions:
If a required value is missing, return [fallback value].
If the requirements conflict, follow the stated priority order.
Validation instructions:
Confirm that all required sections are present.
Confirm that no prohibited content is included.
Confirm that the output follows the required format.
Input section:
[Insert the input data here]

Role: Act as an experienced technical content writer.
Task: Create a detailed article about [topic].
Audience: Write for beginner and intermediate learners.
Introduction: Begin with a clear introduction to the topic.
Definition: Provide a simple and technically correct definition.
Core explanation: Explain how the concept works step by step.
Required content: Cover [topic one], [topic two], and [topic three].
Examples: Include at least two practical examples.
Technical example: Include one relevant code or configuration example.
Benefits: Explain the main benefits.
Limitations: Explain the main limitations.
Mistakes: Explain common mistakes and how to avoid them.
Best practices: Add a practical best-practices checklist.
Formatting: Return the article in Markdown.
Formatting: Use a level-one title and level-two topic headings.
Formatting: Add a separator between every main topic.
Style: Use simple and natural language.
Style: Explain technical terms when first used.
Constraint: Do not repeat the same explanation.
Constraint: Do not use unsupported facts.
Constraint: Do not include unrelated topics.
Validation: Confirm that every required topic has its own heading.

Task: Extract structured information from the supplied text.
Required fields: Extract [field one], [field two], and [field three].
Format: Return valid JSON only.
Missing values: Use null when a required value is missing.
Multiple values: Return multiple values as an array.
Normalisation: Convert all dates to YYYY-MM-DD.
Source restriction: Use only information directly stated in the input.
Negative instruction: Do not infer or create missing values.
Validation: Confirm that every required field exists in the JSON object.
Input:
[Insert unstructured text here]

Task: Classify the supplied input into exactly one category.
Allowed categories: [category one], [category two], [category three], [category four].
Category definition: [category one] means [definition].
Category definition: [category two] means [definition].
Category definition: [category three] means [definition].
Category definition: [category four] means [definition].
Priority: Select the most specific matching category.
Fallback: Use [fallback category] when no other category matches.
Format: Return only the category name.
Negative instruction: Do not create a new category.
Input:
[Insert text here]

Role: Act as a senior [programming language] developer.
Task: Create [application, class, function, API, or script].
Language: Use [language and version].
Framework: Use [framework and version].
Input: Accept [input type].
Output: Return [output type].
Required behaviour: Implement [feature one].
Required behaviour: Implement [feature two].
Required behaviour: Implement [feature three].
Validation: Reject [invalid input condition].
Error handling: Handle [expected error].
Security: Prevent [security risk].
Performance: Use [performance requirement].
Dependencies: Use only [allowed dependencies].
Structure: Create [required classes, functions, or files].
Testing: Include [unit tests, integration tests, or sample cases].
Comments: Use only useful single-line comments.
Formatting: Do not include empty lines in the code.
Formatting: Use proper indentation.
Explanation: Explain the design after the code.
Validation: Confirm that the code satisfies every listed requirement.

Role: Act as a senior Java technical interviewer.
Task: Conduct a Java Collections Framework mock interview.
Audience: Interview a developer with three years of experience.
Content: Cover List, Set, Map, Queue, hashing, comparators, and concurrency.
Quantity: Ask ten questions.
Difficulty: Start with medium questions and gradually increase difficulty.
Sequence: Ask one question at a time.
Behaviour: Wait for the user's answer before continuing.
Behaviour: Do not reveal the answer before the user responds.
Evaluation: Rate every answer as Correct, Partially Correct, or Incorrect.
Feedback: Explain missing points using simple language.
Conditional instruction: If the answer is incorrect, provide one hint before showing the full explanation.
Priority: Evaluate technical correctness before communication style.
Final output: Provide a score out of 10 after all questions are complete.
Final output: List strong areas and topics that need revision.
Constraint: Do not repeat a question.
Constraint: Do not ask questions outside the Java Collections Framework.