Common Prompt Engineering Use Cases

Role: Act as an experienced Java technical writer.
Task: Create a detailed article about Java exception handling.
Audience: Write for beginner-level Java developers.
Coverage: Explain checked exceptions, unchecked exceptions, try-catch, finally, throw, throws, and custom exceptions.
Style: Use natural and easy-to-understand language.
Examples: Include practical Java examples for every major concept.
Structure: Use a title, introduction, concept sections, best practices, common mistakes, and conclusion.
Restriction: Avoid unnecessary repetition.
Output: Return the article in Markdown format.

Role: Act as a technical documentation analyst.
Task: Summarize the provided API documentation.
Focus: Preserve authentication rules, endpoint behavior, parameters, response formats, error codes, and rate limits.
Length: Keep the summary under 700 words.
Format: Organize the output using headings and bullet points.
Restriction: Do not introduce information that is not present in the source.
Source: [Paste API documentation here]

Role: Act as a Spring Boot mentor.
Task: Explain how dependency injection works in Spring Boot.
Audience: Explain it to a Java developer with one year of experience.
Coverage: Include constructor injection, setter injection, field injection, bean creation, and component scanning.
Example: Provide one practical code example using constructor injection.
Comparison: Explain why constructor injection is generally preferred.
Restriction: Do not assume knowledge of the Spring container internals.
Output: Use Markdown headings and point-to-point explanations.

Role: Act as an invoice data extraction system.
Task: Extract the required fields from the supplied invoice text.
Fields: Extract invoice number, invoice date, supplier name, customer name, subtotal, tax, total amount, currency, and payment due date.
Missing Data: Return null when a field is not available.
Output Format: Return valid JSON.
Restriction: Do not calculate or invent missing values.
Source: [Paste invoice text here]

{
  "invoiceNumber": "INV-2045",
  "invoiceDate": "2026-07-25",
  "supplierName": "ABC Technologies",
  "customerName": "XYZ Solutions",
  "subtotal": 50000,
  "tax": 9000,
  "totalAmount": 59000,
  "currency": "INR",
  "paymentDueDate": "2026-08-24"
}

Role: Act as a customer support classification system.
Task: Classify the supplied customer message.
Categories: Payment Issue, Delivery Issue, Product Defect, Refund Request, Account Issue, General Question.
Priority Levels: Low, Medium, High, Critical.
Rules: Use Critical only when there is a security risk, legal threat, major financial loss, or immediate safety concern.
Output Format: Return category, priority, confidence, and a one-line reason.
Customer Message: My payment was deducted twice, but the order was created only once.

Category: Payment Issue
Priority: High
Confidence: 0.96
Reason: The customer reports a duplicate financial transaction that requires prompt investigation.

Role: Act as a customer feedback analyst.
Task: Analyze the sentiment of the supplied review.
Output: Identify overall sentiment, emotions, product aspects mentioned, positive points, negative points, and customer intent.
Restriction: Base the analysis only on the review text.
Review: The application is useful and easy to navigate, but it becomes very slow when I upload large files.

Role: Act as a professional English-to-Marathi translator.
Task: Translate the supplied technical content into natural Marathi.
Audience: Write for beginner-level software development students.
Terminology: Keep Java, Spring Boot, API, class, object, and method in English.
Style: Use simple and conversational Marathi.
Restriction: Preserve the original meaning and structure.
Source: [Paste content here]

Role: Act as a professional business communication editor.
Task: Rewrite the supplied message in a polite and professional tone.
Meaning: Preserve the original request and urgency.
Length: Keep the message under 120 words.
Restriction: Do not sound demanding or apologetic.
Source: We already told you three times that the server is not working. Fix it immediately because our entire team is blocked.

The server issue is still affecting our team’s work despite our previous reports. Could you please prioritize the investigation and provide an update on the expected resolution? The issue is currently blocking the entire team, so prompt assistance would be appreciated.

Role: Act as a professional project coordinator.
Task: Draft an email requesting a project status update.
Recipient: The email will be sent to a software development team.
Context: The API integration milestone was expected to be completed yesterday.
Required Details: Ask for completed work, pending tasks, blockers, revised completion date, and required support.
Tone: Professional and collaborative.
Length: Keep the email concise.
Output: Include a clear subject line and email body.

Role: Act as a senior Java developer.
Task: Create a Spring Boot REST API for retrieving a user by ID.
Java Version: Use Java 21.
Framework: Use Spring Boot 3.
Architecture: Use controller, service, repository, entity, and DTO layers.
Database: Use Spring Data JPA.
Validation: Validate the user ID before processing.
Error Handling: Return HTTP 404 when the user is not found.
Response: Return a DTO instead of returning the entity directly.
Quality: Follow clean code and constructor injection practices.
Output: Provide each class separately with a brief explanation.

Role: Act as an experienced Java instructor.
Task: Explain the supplied Java Stream API code.
Explanation Level: Beginner friendly.
Coverage: Explain the input collection, filter operation, map operation, sorting, terminal operation, and final result.
Execution: Trace the data after every stream operation.
Complexity: Mention the approximate time and space complexity.
Output: Use point-to-point explanations.
Code: [Paste Java code here]

Role: Act as a senior Spring Boot debugging specialist.
Task: Identify the root cause of the supplied error.
Expected Behavior: The API should return user details using the provided user ID.
Actual Behavior: The API returns HTTP 500.
Environment: Java 21, Spring Boot 3.3, PostgreSQL.
Error Message: [Paste stack trace here]
Code: [Paste relevant code here]
Output: Explain the root cause, identify the exact failing line, provide corrected code, and suggest preventive measures.
Restriction: Do not recommend unrelated architectural changes.

Role: Act as a senior Java code reviewer.
Task: Review the supplied service class.
Review Criteria: Correctness, clean code, SOLID principles, transaction management, exception handling, logging, security, performance, and testability.
Severity Levels: Classify findings as Critical, High, Medium, or Low.
Output: For each issue, provide severity, affected code, explanation, impact, and corrected implementation.
Restriction: Do not suggest changes that add unnecessary complexity.
Code: [Paste service class here]

Role: Act as a software test engineer.
Task: Generate test cases for a user registration API.
Fields: Name, email, password, mobile number, and date of birth.
Rules: Email must be unique.
Rules: Password must contain at least eight characters, one uppercase letter, one lowercase letter, one number, and one special character.
Rules: The user must be at least eighteen years old.
Coverage: Include positive, negative, boundary, validation, security, and duplicate-data test cases.
Output Format: Use a table containing test case ID, scenario, input, expected result, priority, and test type.

Role: Act as a PostgreSQL database developer.
Task: Write a query to find the top five customers by total completed order value during the previous calendar month.
Tables: customers, orders, and order_items.
Relationship: orders.customer_id references customers.id.
Relationship: order_items.order_id references orders.id.
Calculation: Order value equals quantity multiplied by unit_price.
Filter: Include only orders with status COMPLETED.
Output: Return customer ID, customer name, completed order count, and total order value.
Quality: Avoid unnecessary subqueries and explain the indexes that could improve performance.

Role: Act as an API documentation writer.
Task: Create documentation for the supplied REST endpoint.
Format: Use Markdown.
Coverage: Include purpose, method, URL, authentication, headers, path parameters, request body, response fields, success example, error examples, and status codes.
Audience: Write for frontend developers integrating with the API.
Restriction: Document only behavior visible in the supplied code.
Code: [Paste controller and DTO code here]

Role: Act as a technical documentation specialist.
Task: Create a README file for the supplied Spring Boot project.
Coverage: Include project overview, features, prerequisites, installation, environment variables, database setup, build commands, run commands, API access, testing, deployment, and troubleshooting.
Audience: Write for developers cloning the repository for the first time.
Output: Return Markdown content.
Project Information: [Provide project details here]

Role: Act as a Java programming tutor.
Student Level: The student understands variables, operators, and conditional statements.
Learning Goal: Teach Java loops.
Method: Begin with a simple explanation and then explain for, while, and do-while loops.
Examples: Include one practical example for each loop.
Practice: Provide five exercises from easy to intermediate difficulty.
Interaction: Do not reveal exercise answers until the student submits an attempt.
Feedback: Explain mistakes without discouraging the student.

Role: Act as a Java interview assessment creator.
Task: Generate twenty multiple-choice questions about Java exception handling.
Difficulty: Include six easy, eight intermediate, and six advanced questions.
Coverage: Checked exceptions, unchecked exceptions, try-catch, multi-catch, finally, throw, throws, custom exceptions, and exception propagation.
Options: Provide four options for every question.
Answer Distribution: Avoid making the same option correct repeatedly.
Explanation: Explain why the correct option is correct and why the other options are incorrect.
Restriction: Avoid ambiguous questions.
Output: Return structured JSON.

Role: Act as a senior Java interviewer.
Candidate Experience: Five years.
Interview Area: Spring Boot REST APIs.
Process: Ask one question at a time.
Difficulty: Start at intermediate level and increase difficulty based on answer quality.
Evaluation: Score each answer for technical accuracy, clarity, practical experience, and completeness.
Feedback: Explain missing points and provide a stronger sample answer.
Restriction: Do not ask the next question until the candidate answers the current question.

Role: Act as an ATS-focused technical resume writer.
Task: Rewrite the candidate’s project experience for a senior Java developer role.
Target Skills: Java, Spring Boot, REST APIs, microservices, PostgreSQL, Kafka, Docker, and AWS.
Requirement: Use strong action verbs and measurable achievements.
Restriction: Do not invent technologies, responsibilities, or metrics.
Length: Use five concise bullet points.
Candidate Information: [Paste actual experience here]
Job Description: [Paste job description here]

Role: Act as a customer support assistant for an online learning platform.
Task: Respond to users who cannot access a purchased course.
Process: Verify whether the user is signed in with the purchasing email, check payment status, check course activation status, and provide troubleshooting steps.
Escalation: Escalate the case when payment is successful but access remains unavailable after troubleshooting.
Tone: Be polite, calm, and solution-focused.
Restriction: Never request the user’s password, complete card number, or one-time password.

Role: You are the virtual assistant for CodeLangs AI.
Purpose: Help users find programming tutorials, interview tools, quizzes, and practice modules.
Supported Subjects: Java, Python, prompt engineering, Spring Boot, and software interviews.
Style: Use clear and beginner-friendly language.
Navigation: Recommend the most relevant page based on the user’s learning goal.
Restriction: Do not claim that a paid feature is free.
Fallback: When the requested information is unavailable, clearly say so and recommend the nearest relevant resource.

Role: Act as a digital marketing copywriter.
Task: Create a Facebook post promoting a free Java interview preparation platform.
Audience: Java developers preparing for technical interviews in India.
Features: MCQ tests, output prediction, interview questions, HR questions, managerial questions, and project-based questions.
Tone: Motivating and trustworthy.
Length: Keep the post between 100 and 150 words.
Call to Action: Encourage users to practise on the website.
Restriction: Do not make guaranteed job-placement claims.

Role: Act as a technical SEO content strategist.
Task: Create an SEO content outline for the topic Java Stream API.
Audience: Beginner and intermediate Java developers.
Search Intent: Informational and interview preparation.
Coverage: Include fundamentals, intermediate operations, terminal operations, collectors, parallel streams, performance, examples, mistakes, interview questions, and FAQ.
Restriction: Avoid keyword stuffing.
Output: Provide the primary keyword, secondary keywords, search intent, title, meta description, heading structure, and internal-link suggestions.

Role: Act as an e-commerce product copywriter.
Task: Create a product description for a wireless mechanical keyboard.
Audience: Programmers and professional writers.
Features: Bluetooth connectivity, USB-C charging, hot-swappable switches, white backlight, compact layout, and support for Windows and macOS.
Structure: Include a short overview, key benefits, feature list, compatibility, and ideal user profile.
Tone: Informative and professional.
Restriction: Do not claim features that are not supplied.

Role: Act as a product strategist for an educational technology startup.
Task: Generate ten interactive tool ideas for a programming education website.
Audience: Beginner and intermediate Java developers.
Business Model: The tools should support advertisement-based monetization.
Technical Constraint: Each tool must be buildable using HTML, CSS, JavaScript, and PHP without a paid API.
Value Requirement: Each idea must solve a specific learning or interview-preparation problem.
Output: For each idea, provide the tool name, user problem, core features, implementation difficulty, content requirement, and monetization suitability.
Restriction: Avoid duplicate variations of quizzes and flashcards.

Role: Act as a business analyst for an educational website.
Task: Analyze whether adding interactive programming tools can improve user engagement.
Factors: Session duration, repeat visits, learning value, development cost, content maintenance, SEO potential, and advertisement suitability.
Output: Provide assumptions, expected benefits, risks, measurement metrics, and a ninety-day validation plan.
Restriction: Clearly separate facts, assumptions, and recommendations.

Role: Act as a product data analyst.
Task: Analyze the supplied monthly website metrics.
Metrics: Users, sessions, page views, average engagement time, bounce rate, returning users, ad impressions, and revenue.
Analysis: Identify trends, anomalies, correlations, and weak-performing months.
Comparison: Compare every month with the previous month.
Output: Provide key findings, possible causes, required investigations, and recommended actions.
Restriction: Do not treat correlation as proof of causation.
Data: [Paste data here]

Role: Act as a structured data generator.
Task: Convert the supplied programming question into the required JSON schema.
Schema: Include id, question, options, correctAnswer, difficulty, category, and explanation.
Rules: options must contain exactly four strings.
Rules: correctAnswer must match one item from options.
Rules: difficulty must be Easy, Medium, or Hard.
Rules: Return only valid JSON.
Source: Which Java collection does not allow duplicate elements?

{
  "id": 1,
  "question": "Which Java collection does not allow duplicate elements?",
  "options": [
    "ArrayList",
    "LinkedList",
    "HashSet",
    "ArrayDeque"
  ],
  "correctAnswer": "HashSet",
  "difficulty": "Easy",
  "category": "Java Collections",
  "explanation": "HashSet implements the Set interface, which does not permit duplicate elements."
}

Role: Act as a project meeting assistant.
Task: Convert the supplied meeting transcript into structured meeting minutes.
Output Sections: Meeting objective, participants, key discussions, decisions, action items, owners, deadlines, unresolved questions, and risks.
Rule: Do not assign an owner or deadline unless explicitly mentioned.
Rule: Mark unclear statements as Needs Confirmation.
Source: [Paste transcript here]

Role: Act as a technical research assistant.
Task: Compare prompt engineering, retrieval-augmented generation, and fine-tuning.
Comparison Criteria: Purpose, required data, implementation cost, maintenance, latency, privacy, accuracy, ideal use cases, and limitations.
Evidence: Base conclusions on supplied sources.
Uncertainty: Clearly identify claims that require further validation.
Output: Include a comparison table and decision framework.
Sources: [Provide research sources here]

Role: Act as an internal company policy assistant.
Task: Answer the employee’s question using only the supplied policy excerpts.
Evidence: Cite the title or section of the policy used for the answer.
Missing Information: State that the answer is unavailable when the excerpts do not contain sufficient information.
Conflict Handling: Mention the conflict when two supplied policies provide different instructions.
Restriction: Do not use general knowledge to invent company policy.
Employee Question: Can unused annual leave be carried into the next calendar year?
Retrieved Context: [Insert relevant policy excerpts here]

Role: Act as a site reliability engineer.
Task: Analyze the supplied production logs.
Objective: Identify the first meaningful failure, affected component, likely root cause, secondary errors, and user impact.
Timeline: Arrange important events chronologically.
Evidence: Quote relevant log timestamps and messages.
Recommendations: Provide immediate mitigation, permanent correction, and monitoring improvements.
Restriction: Distinguish confirmed evidence from hypotheses.
Logs: [Paste logs here]

Role: Act as an application security reviewer.
Task: Review the supplied Spring Boot authentication code.
Framework: Use OWASP application security principles.
Focus: Authentication bypass, password handling, token validation, authorization, sensitive logging, exception leakage, and input validation.
Output: Classify findings by severity and provide remediation guidance.
Restriction: Do not provide offensive exploitation instructions.
Code: [Paste authentication code here]

Role: Act as a support ticket routing system.
Task: Analyze the incoming ticket and select the correct department.
Departments: Billing, Technical Support, Account Security, Sales, and General Support.
Security Rule: Route suspected account compromise to Account Security with Critical priority.
Output: Return department, priority, summary, and required next action.
Ticket: [Insert customer message here]

Role: Act as a practical study planner.
Task: Create a four-week Spring Boot interview preparation plan.
Available Time: Two hours per day from Monday to Saturday.
Current Level: The learner understands Core Java and basic SQL.
Topics: Spring Core, Spring Boot, REST APIs, JPA, security, testing, microservices, and project questions.
Practice: Include concept study, coding, revision, and mock interviews.
Output: Provide a day-by-day schedule with measurable outcomes.
Restriction: Keep Sunday free for rest.

Role: Act as a software architecture advisor.
Task: Compare a modular monolith and microservices for the supplied project.
Project Context: A small team is building an education platform with authentication, payments, course management, quizzes, and analytics.
Criteria: Development complexity, deployment, scalability, cost, testing, data consistency, team size, fault isolation, and maintenance.
Output: Provide a comparison table, risks, recommendation, and conditions under which the recommendation should change.
Restriction: Do not recommend microservices only because the application may grow later.

Role: Act as a science-fiction short-story writer.
Task: Write a story about a software engineer who discovers that an AI debugging assistant is preventing failures before the code is written.
Setting: Pune in the year 2045.
Tone: Thoughtful and suspenseful.
Perspective: Third-person limited.
Length: Approximately 1,500 words.
Theme: Responsibility and unintended consequences.
Restriction: Avoid a predictable evil-AI ending.

Subject: A software developer working at a modern desk with multiple monitors.
Environment: A clean technology office with large windows overlooking Pune.
Composition: Medium-wide shot with the developer positioned slightly left of center.
Lighting: Soft morning light with realistic indoor shadows.
Style: Professional editorial photography.
Details: Display code editors and system diagrams on the monitors.
Restriction: Avoid visible brand logos, distorted hands, and unreadable foreground text.
Aspect Ratio: 16:9.

Role: Act as a prompt engineering specialist.
Task: Improve the supplied prompt.
Objective: Make the prompt clear, testable, and reusable.
Improvements: Add role, task, context, constraints, input definition, output format, and quality criteria.
Restriction: Preserve the user’s original objective.
Output: Return the improved prompt followed by a brief explanation of the changes.
Original Prompt: Write something about Java.

Role: Act as an experienced Java technical writer.
Task: Create a beginner-friendly introduction to Java programming.
Audience: Students with no previous programming experience.
Coverage: Explain Java, its main features, platform independence, JVM, JRE, JDK, basic application structure, and common use cases.
Examples: Include one simple Hello World example.
Structure: Use a title, introduction, concept sections, example, key points, and conclusion.
Style: Use natural and easy-to-understand language.
Length: Keep the article between 1,200 and 1,500 words.
Output: Return Markdown content.

Role: Act as a software test-data generator.
Task: Generate fifty fictional user registration records.
Fields: id, fullName, email, mobileNumber, city, dateOfBirth, and accountStatus.
Diversity: Include different Indian names and cities.
Validation: Every email and mobile number must be unique.
Status Values: ACTIVE, INACTIVE, and PENDING.
Privacy: Do not use real personal information.
Output: Return valid JSON.

Role: Act as a senior business analyst.
Task: Convert the supplied feature request into a structured requirement specification.
Sections: Business objective, actors, functional requirements, non-functional requirements, business rules, validations, error scenarios, dependencies, assumptions, acceptance criteria, and open questions.
Rule: Mark ambiguous requirements instead of resolving them without evidence.
Feature Request: Users should be able to purchase courses and access only the courses they have purchased.

Role: Act as an agile product owner.
Task: Create user stories for an online course purchasing feature.
Roles: Student, administrator, and support agent.
Format: Use As a, I want, so that.
Acceptance Criteria: Use Given, When, Then.
Coverage: Successful payment, failed payment, duplicate payment, course access, refund status, and unauthorized access.
Restriction: Keep each user story independently testable.

Role: Act as a Java career mentor.
Task: Recommend the next learning topics for the learner.
Current Skills: Core Java, collections, exception handling, SQL, and basic Spring Boot.
Goal: Prepare for a backend developer role.
Available Time: Three months.
Preference: Focus on practical project development.
Output: Provide prioritized topics, reasons, project exercises, and expected outcomes.
Restriction: Do not recommend unrelated technologies.

Role: Act as an internal compliance assistant.
Task: Review the supplied expense request against the company travel policy.
Output: Identify compliant items, non-compliant items, missing evidence, and required approvals.
Evidence: Cite the relevant policy section for every conclusion.
Restriction: Do not approve or reject the request when the policy is ambiguous.
Policy: [Insert policy text here]
Expense Request: [Insert expense details here]

Role: Act as a form data preparation assistant.
Task: Map the supplied user information to the application form fields.
Rules: Preserve exact names and dates.
Rules: Return null for unavailable values.
Rules: List contradictory information under validationIssues.
Output: Return valid JSON.
User Information: [Insert information here]
Form Schema: [Insert field definitions here]

Role: Act as a web accessibility content specialist.
Task: Write meaningful alternative text for the supplied image description.
Context: The image appears in an article explaining Java application architecture.
Requirement: Describe the information conveyed by the diagram, not decorative details.
Length: Keep the alternative text under 150 characters when possible.
Image Description: A diagram showing browser, REST controller, service, repository, and database connected in sequence.

Java request flow from the browser through controller, service, and repository layers to the database.

Role: Act as a senior software architect.
Task: Design an online examination platform.
Step 1: Identify actors and use cases.
Step 2: Define functional and non-functional requirements.
Step 3: Propose the application architecture.
Step 4: Design the database entities and relationships.
Step 5: Define the main REST APIs.
Step 6: Identify security risks and controls.
Step 7: Provide a phased implementation plan.
Restriction: State assumptions explicitly.
Output: Keep every step in a separate section.

Role: Act as an appointment scheduling assistant.
Task: Help the user schedule a meeting.
Process: Collect meeting purpose, participants, duration, date range, and time-zone information.
Availability: Check calendar availability before suggesting a slot.
Confirmation: Ask for explicit confirmation before creating the event.
Conflict Rule: Never schedule over an existing busy event.
Privacy: Do not reveal one participant’s unrelated calendar details to another participant.

Role: Define the expertise or behavior the model should adopt.
Task: Describe the exact action the model must perform.
Context: Provide relevant background information.
Input: Clearly identify the data the model should process.
Audience: Define who will use or read the output.
Requirements: List all mandatory content and behavior.
Constraints: Define restrictions, boundaries, and prohibited actions.
Examples: Provide examples when the required pattern may be unclear.
Output Format: Specify Markdown, JSON, table, code, or another format.
Quality Criteria: Explain how a successful response should be evaluated.
Missing Information: Define what the model should do when required information is unavailable.

Explain Java.

Explain Java to a beginner by covering its purpose, major features, JVM, JRE, JDK, platform independence, application structure, and common use cases.

Role: Act as an experienced prompt engineering educator and technical writer.
Task: Create a detailed article about zero-shot prompting.
Audience: Write for beginners who understand basic artificial intelligence concepts.
Objective: Help readers understand what zero-shot prompting is, how it works, when to use it, and where it may fail.
Coverage: Include definition, working process, prompt structure, practical examples, advantages, limitations, common mistakes, best practices, comparison with one-shot and few-shot prompting, and real-world applications.
Examples: Include examples for summarization, classification, code generation, information extraction, and question answering.
Style: Use human-like, natural, and technically accurate language.
Structure: Use a title, introduction, point-to-point sections, comparison table, best practices, FAQ, and conclusion.
Code Format: Display each prompt instruction on a separate line.
Code Format: Do not split one instruction across multiple lines.
Code Format: Do not include empty lines inside examples.
Restriction: Avoid generic wording and unnecessary repetition.
Restriction: Do not present unsupported claims as facts.
Output: Return copy-paste-ready Markdown content.