Writing Clear Instructions

Explain Java.

Explain the Java programming language to a beginner.
Cover its purpose, main features, JVM architecture, and common use cases.
Include one simple Hello World example.
Keep the explanation under 700 words.

Action
Subject
Scope
Requirements
Constraints
Output format
Completion condition

Summarize the provided customer feedback.
Identify the three most common complaints.
Group similar complaints together.
Include the number of mentions for each complaint.
Do not include customer names.
Present the result as a Markdown table.
Stop after listing the top three complaint categories.

I was wondering whether you might possibly be able to create something that explains inheritance in Java.

Explain inheritance in Java.

Could you please, if it is not too much trouble, take a look at the text below and maybe try to improve it in whatever way you think would be useful?

Improve the text below for clarity, grammar, and professional tone.

Create a technical explanation of dependency injection.
Target the explanation at junior Java developers.
Include one Spring Boot example.
Limit the response to 800 words.

Can you tell me something useful about databases?

Explain relational databases to a beginner.
Cover tables, rows, columns, primary keys, and foreign keys.
Include one simple customer-order example.
Keep the response under 600 words.

Make the response better.

Write a short explanation.

Write an explanation between 150 and 200 words.

Make it professional.

Use formal business language, complete sentences, and a neutral tone.

Explain it simply.

Explain the concept for a beginner who has no programming experience.
Avoid unexplained technical terminology.
Use one everyday analogy.

Compare it with the previous one and explain why it is better.

Compare the revised authentication design with the original session-based design.
Explain why the revised design provides better scalability and security.

Explain Spring Boot completely.

Explain the following Spring Boot concepts:
Auto-configuration
Starter dependencies
Embedded servers
Dependency injection
Application properties
REST controller creation
Limit the response to 1,200 words.

Give me an impressive project description.

Write a project description suitable for a Java developer resume.
Emphasize business impact, individual contribution, Spring Boot, REST APIs, database integration, and production support.
Use five bullet points.
Begin each bullet with an action verb.
Include measurable results where data is available.

Review the Java method for potential null pointer errors.

Explain microservices, compare them with monoliths, create Java code, review the code, make interview questions, design a project, and write a LinkedIn post.

Explain microservices architecture to an intermediate Java developer.
Cover service boundaries, independent deployment, communication, data ownership, and fault tolerance.
Limit the response to 1,000 words.

Based on the explanation, create ten microservices interview questions with answers.

Create a Spring Boot example containing two services that communicate through REST.

The main result I need is ________.

The main result I need is a security review of this API controller.

Review the provided API controller for security vulnerabilities.

Main action + exact subject + intended result

Summarize the incident report for senior management.
Refactor the method to reduce duplicate database queries.
Classify the support tickets by issue category.
Generate unit tests for the payment service.
Explain recursion to a beginner.
Compare JWT authentication with session-based authentication.

Review the SQL query for performance problems.

Identify full table scans.
Identify missing indexes.
Explain expensive joins.
Provide an optimized query.
Preserve the original result set.

Create interview questions about SQL normalization.

Refactor the Java method to improve readability.

Preserve existing behaviour.
Replace duplicated logic with a helper method.
Add concise comments only where necessary.
Explain the main changes after the code.

Primary task:
Secondary tasks:
Constraints:
Output format:

Primary task:
Analyze the provided exception log and identify the most likely root cause.
Secondary tasks:
List the evidence supporting the diagnosis.
Suggest three troubleshooting steps.
Mention any assumptions.
Constraints:
Do not invent missing log entries.
Do not claim certainty when the evidence is incomplete.
Output format:
Use the sections Diagnosis, Evidence, Troubleshooting Steps, and Assumptions.

Read the provided article.
Summarize its main argument.
Identify three unsupported claims.
Rewrite those claims using cautious language.

Java streams.

Explain Java streams.

Compare Java streams with traditional loops.

Refactor the provided loop using the Java Stream API while preserving its current output.

Explain how dependency injection works in Spring Boot.

Summarize the provided Spring Boot documentation.

Compare constructor injection with field injection.

Evaluate the controller against REST API design principles.

Refactor the controller to separate business logic from request handling.

Extract all endpoint paths and HTTP methods from the controller.

Take a look at the code and tell me what you think.

Review the code for correctness, readability, performance, and security problems.

Help me with this error.

Diagnose the error using the stack trace and provided source code.
Identify the probable root cause.
Provide a corrected implementation.

Review and improve and explain this code and tell me whether it is production-ready.

Review the code for correctness and security issues.
Refactor the code to resolve confirmed problems.
Explain each significant change.
Evaluate whether the revised version is production-ready.

Answer the technical questions.

Base each answer only on the provided documentation.
State when the documentation does not contain enough information.
Distinguish confirmed facts from assumptions.
Use concise technical language.

Use only the information provided in the reference text.
Cite the relevant section after each conclusion.
Do not treat assumptions as confirmed facts.
State Insufficient information when the evidence is incomplete.

Verify that every method name exists in the provided code.
Preserve the original public method signatures.
Check that the revised code compiles logically.
Mention any required imports.

Explain each concept for a beginner.
Define technical terms before using them.
Use one practical analogy for each major concept.
Avoid assuming knowledge of machine learning.

Ask one clarification question only when a required input is missing.
Otherwise, complete the task using the available information.
Do not request confirmation for minor formatting decisions.

Do not invent information that is not present in the source.

Present the extracted information in a three-column table.

Do not invent statistics.
Do not modify public API signatures.
Do not include personally identifiable information.
Do not use external knowledge.
Do not repeat the source text word for word.
Do not produce code that requires third-party libraries.

Summarize the customer complaint.

Summarize the customer complaint.
Remove names, email addresses, phone numbers, account numbers, and other identifying information.

Do not make mistakes.

Do not invent classes, methods, configuration properties, or dependencies that are not present in the provided project.

Do not write badly.

Do not use sentence fragments, unexplained abbreviations, or promotional language.

Do not guess missing values.
Mark missing values as Not provided.

Do not return a general explanation.
Return only the corrected SQL query and a brief change summary.

Do not silently change business rules.
Preserve existing business rules and flag any required behavioural change separately.

Do not be vague.
Do not be too technical.
Do not be too simple.
Do not be too long.
Do not be too short.
Do not repeat.
Do not miss anything.

Write 600 to 800 words for readers with basic programming knowledge.
Define advanced terms when first introduced.
Cover the six concepts listed below.
Avoid repeating the same explanation in multiple sections.

Generate test cases for the login API.

Generate test cases for the login API.
Include successful login, invalid password, unknown user, missing fields, locked account, expired password, and rate-limit scenarios.
Provide at least one test case for each scenario.
Stop after all seven scenarios have been covered.

Generate exactly 20 multiple-choice questions.
Include four options for each question.
Include one correct answer and one explanation for each question.

Review every public method in the class.
Report whether each method validates null input.
Complete the review only after all public methods have been assessed.

Write between 800 and 1,000 words.
Use no more than eight main sections.

Return the final JSON only after confirming that it is syntactically valid.
Ensure every object contains id, name, status, and createdAt.

The task is complete when:
The revised method preserves the original output.
Duplicate database calls are removed.
Null inputs are handled.
Unit tests cover successful and unsuccessful paths.

Explain everything about artificial intelligence.

Explain the following foundational AI concepts:
Machine learning
Supervised learning
Unsupervised learning
Neural networks
Large language models
Generative AI
Limit each concept to one paragraph and one example.

Hello, I hope you are doing well. I have been thinking about Java programming for a while, and I would really appreciate it if you could perhaps help me by creating a detailed explanation that is easy to understand and not too difficult but also useful and informative regarding exception handling in Java.

Explain Java exception handling to a beginner.
Cover checked exceptions, unchecked exceptions, try-catch-finally, throw, and throws.
Include one practical code example.
Use simple technical language.

Keep the answer short.
Do not make the answer long.
Be concise.
Avoid unnecessary detail.
Use as few words as possible.

Limit the response to 200 words.
Include only the definition, main benefits, and one example.

Explain JWT.

Explain JWT authentication to a junior backend developer.
Cover token structure, signing, validation, expiration, and common security risks.
Include one request-response flow example.
Limit the response to 700 words.

Explain dependency injection in Spring Boot.
Target the explanation at junior Java developers.
Cover constructor injection, field injection, and setter injection.
Explain why constructor injection is generally preferred.
Include one concise code example.
Limit the response to 800 words.

Review the provided Java service class.
Identify correctness, performance, security, and maintainability problems.
Reference the affected method for each problem.
Assign Critical, High, Medium, or Low severity.
Provide a corrected code example for Critical and High severity problems.
Do not invent dependencies that are not present in the project.
Present the result in a Markdown table followed by revised code.

Extract the following fields from each invoice:
Invoice number
Invoice date
Vendor name
Currency
Subtotal
Tax
Total amount
Return the result as a JSON array.
Use null when a field is missing.
Do not calculate values that are not explicitly shown.
Preserve the original currency notation.

Summarize the provided incident report for senior management.
Focus on business impact, root cause, recovery actions, and preventive measures.
Exclude low-level debugging details.
Use the sections Executive Summary, Impact, Cause, Resolution, and Prevention.
Limit the response to 500 words.

Analyze the provided SQL query for performance problems.
Identify unnecessary joins, full table scans, inefficient filters, and missing indexes.
Provide an optimized query that returns the same result set.
Explain each significant change.
Do not change the business logic.
Mention any assumptions about table size or indexing.

Generate exactly 15 Java multithreading interview questions.
Create five easy, five medium, and five hard questions.
Provide a concise answer and practical explanation for each question.
Avoid duplicate concepts.
Cover thread lifecycle, synchronization, locks, executors, race conditions, deadlocks, and virtual threads.
Number the questions from 1 to 15.

Design REST endpoints for an online course enrollment system.
Include course listing, course details, enrollment creation, enrollment cancellation, and enrollment history.
Specify the HTTP method, endpoint path, request body, response body, and expected status codes.
Use resource-oriented endpoint names.
Do not include authentication implementation.
Present the result in a Markdown table.

Rewrite the provided email in a professional and respectful tone.
Preserve all dates, names, amounts, and requested actions.
Remove emotional or accusatory wording.
Keep the email between 150 and 200 words.
Return only the revised email.

Write about Java.

Make this code better.

Create some interview questions.

Explain it properly.

Give me a complete tutorial.

Check whether this is correct.

Make it short but detailed.

Analyze the data and do the needful.

Help with this Java code.

Review this Java code.

Diagnose why this Java code throws a NullPointerException.

Explain this.

Explain the purpose of the synchronized keyword in the provided Java method.

Analyze the logs.

Analyze the logs and identify the most likely cause of the database connection failure.

Focus on connection-pool exhaustion, database availability, authentication failure, timeout settings, and network errors.

Base the diagnosis only on the provided logs.
Distinguish confirmed evidence from possible causes.
State when additional information is required.

Do not invent log entries.
Do not claim a root cause as confirmed without supporting evidence.

Use the sections Most Likely Cause, Supporting Evidence, Alternative Causes, and Next Checks.

Provide one primary diagnosis, up to three alternative causes, and five ordered troubleshooting steps.

Check my API and tell me if it is good and make it secure.

Review the provided Spring Boot REST controller for security vulnerabilities.
Check authentication, authorization, input validation, sensitive-data exposure, exception handling, injection risks, and insecure logging.
Identify the affected endpoint and code location for each issue.
Assign Critical, High, Medium, or Low severity.
Explain the security impact of each confirmed issue.
Provide corrected code for Critical and High severity issues.
Preserve existing endpoint paths and response contracts.
Do not invent project configuration that is not provided.
Present findings in a Markdown table followed by revised code.
The review is complete after every public endpoint has been assessed.

Explain microservices nicely.

Explain microservices architecture to an intermediate Java developer.
Cover service boundaries, independent deployment, inter-service communication, decentralized data ownership, service discovery, fault tolerance, and observability.
Include one e-commerce example.
Explain two advantages and two disadvantages.
Limit the response to 1,000 words.

Optimize this method.

Optimize the provided Java method to reduce database calls and unnecessary object creation.
Preserve its public signature and current result.
Do not introduce third-party libraries.
Explain the time and space complexity before and after optimization.
Return the revised method followed by a concise explanation.

Write a blog about prompt engineering.

Write a beginner-friendly article titled Introduction to Prompt Engineering.
Explain what a prompt is, how language models interpret instructions, why context matters, and how constraints improve output.
Include three weak-versus-improved prompt examples.
Use Markdown headings and bullet points.
Write between 1,200 and 1,500 words.
Avoid promotional claims and unnecessary repetition.

Give Java questions.

Generate exactly 20 Java Collections Framework interview questions.
Include eight easy, seven medium, and five hard questions.
Provide a concise answer and practical explanation for each question.
Cover List, Set, Queue, Map, iterators, sorting, concurrency, and performance.
Do not repeat the same concept.
Number the questions from 1 to 20.

Why is this not working?

Diagnose why the provided Spring Boot application fails during startup.
Use the stack trace, configuration, and source code provided below.
Identify the most likely root cause.
Quote the relevant error message.
Provide ordered correction steps.
Mention any missing information that prevents a confirmed diagnosis.
Do not suggest unrelated configuration changes.

Primary task:
Perform [action] on [subject].
Objective:
Produce [specific result].
Context:
Use the following background information: [context].
Required content:
Include [required item 1].
Include [required item 2].
Include [required item 3].
Required behaviour:
Follow [behaviour rule 1].
Follow [behaviour rule 2].
Prohibited behaviour:
Do not [prohibited action 1].
Do not [prohibited action 2].
Output format:
Present the result as [format].
Completion condition:
The task is complete when [measurable condition].

Primary task:
Review the provided Java payment service for correctness and reliability problems.
Required checks:
Check null handling.
Check transaction boundaries.
Check duplicate payment risks.
Check exception handling.
Check thread-safety.
Check sensitive-data logging.
Required behaviour:
Reference the affected method for every finding.
Distinguish confirmed defects from possible risks.
Preserve the existing public API.
Prohibited behaviour:
Do not invent classes or configuration not included in the input.
Do not change business rules without explicitly identifying the change.
Output format:
Present findings in a Markdown table.
Include severity, location, problem, impact, and recommendation.
Provide revised code after the table.
Completion condition:
Complete the review after assessing every public method.

Summary
Findings Table
Revised Code
Assumptions
Remaining Risks

Analyze the provided customer feedback from the last quarter.
Identify the five most frequently mentioned problems.
Group semantically similar complaints into one category.
Count the number of comments in each category.
Include one representative paraphrased example for each category.
Do not include customer names or contact information.
Do not invent causes that are not stated in the feedback.
Present the result in a table ordered by frequency.
End with three recommended product actions based on the findings.
The analysis is complete after all feedback records have been classified.

Explain recursion to a learner with basic knowledge of variables, methods, and conditional statements.
Define recursion and base case.
Explain how the call stack behaves.
Include one everyday analogy.
Include one Java factorial example.
Trace the execution for factorial of 4.
Mention infinite recursion and stack overflow.
Avoid advanced mathematical terminology.
Limit the response to 900 words.

Continue the project explanation.

Continue the explanation of the online payment project from the API Integration section.
Cover payment initiation, callback validation, retry handling, and reconciliation.

Create high-quality questions.

Create questions that test conceptual understanding, practical application, debugging ability, and production experience.
Avoid definition-only questions.

Explain every detail in fewer than 100 words.

Summarize the three most important points in fewer than 100 words.

I am preparing for an interview next month, and I have worked with Java for several years, and I have read many questions, but I need some help because interviews can be difficult, so perhaps you can create questions about concurrency.

Generate 20 Java concurrency interview questions for a developer with three years of experience.
Focus on practical debugging and production scenarios.

Analyze this code.

Analyze this code for defects.
Return a table containing line reference, defect, impact, severity, and correction.

Be concise.
Keep it short.
Do not make it long.
Avoid excessive details.

Limit the response to 300 words.

Explain REST APIs, generate code, test it, create questions, and write social media content.

First prompt: Explain REST API design principles.
Second prompt: Generate a Spring Boot implementation.
Third prompt: Create test cases for the implementation.
Fourth prompt: Generate interview questions from the completed example.

Highest priority:
Preserve the current business behaviour.
Required:
Remove duplicate queries.
Improve null handling.
Optional:
Suggest naming improvements.

Prioritize factual accuracy over brevity.
When required details exceed the target length, exceed the limit rather than omit critical safety information.

When a required value is unavailable, use Not provided.
Do not estimate or infer missing financial figures.

List assumptions before using them.
Do not use assumptions that materially change the business logic.
Request clarification when a missing fact prevents a reliable answer.

Correct grammar and improve readability.
Preserve the original meaning, dates, names, amounts, and commitments.
Do not add new promises or claims.

Use only the supplied policy document.
Do not use general legal knowledge.
Cite the relevant section for each answer.

Role:
Act as a senior Java code reviewer.
Primary task:
Review the provided Spring Boot order service for reliability and maintainability problems.
Context:
The service creates orders, reserves inventory, processes payment, and publishes an order-created event.
Required checks:
Check transaction consistency.
Check duplicate order prevention.
Check payment failure handling.
Check inventory rollback.
Check exception handling.
Check thread-safety.
Check logging of sensitive information.
Required behaviour:
Base findings only on the provided code.
Distinguish confirmed defects from possible risks.
Explain the business impact of each issue.
Reference the affected class and method.
Prohibited behaviour:
Do not invent missing infrastructure.
Do not change public API contracts.
Do not silently change business rules.
Output format:
Start with a five-sentence executive summary.
Present findings in a Markdown table.
Use the columns Severity, Location, Finding, Impact, and Recommendation.
Provide revised code for Critical and High severity findings.
End with a list of assumptions and unresolved risks.
Completion condition:
The review is complete after every public method and every external interaction have been assessed.