Question-Based Prompting

What is Java?
Explain it for a beginner.
Cover the JVM, platform independence, and common uses.
Use simple language and one practical example.

What is prompt engineering?

What is prompt engineering?
Explain it for a beginner who understands basic computer concepts.
Cover its purpose, main components, benefits, limitations, and one real-world example.
Organise the answer using headings and bullet points.

Explain why dependency injection improves testability.

Why does dependency injection improve testability?

Context: A Java Spring Boot API becomes slow when more than 500 users access it.
Question: What are the most likely causes of the performance problem?
Scope: Focus on database queries, connection pooling, memory usage, and thread handling.
Output: Provide a diagnostic checklist ordered from most likely to least likely.
Constraint: Do not suggest infrastructure upgrades until application-level causes are checked.

Why is my application slow?

Compare Java ArrayList and LinkedList for insertion, deletion, searching, memory use, and practical application.

How can prompt engineering improve the quality of AI-generated technical documentation?

Tell me about APIs.

What is a REST API?
Explain how clients and servers communicate through HTTP.
Cover resources, endpoints, methods, status codes, and JSON data.
Use a simple order-management example.
Write the answer for a beginner developer.

Question: How does garbage collection work in Java?
Audience: Beginner Java developer.
Include: Heap memory, reachable objects, garbage collectors, pauses, and memory leaks.
Example: Use one simple object lifecycle example.
Output: Use headings, bullet points, and a short summary.

Is Java platform-independent?
Does HTTP status code 404 represent a missing resource?
Which collection allows duplicate values: Set or List?
Is 17 a prime number?

Is Spring Boot good?

Is Spring Boot suitable for building a production REST API that requires dependency injection, database integration, validation, security, and automated testing?
Answer yes or no first.
Then provide three reasons.

Review the statement: Java supports multiple inheritance through classes.
Answer only True or False.
Add one sentence explaining the answer.

Based on the requirements, select one option: MySQL, MongoDB, or Redis.
Requirements: Relational transactions, foreign keys, complex joins, and structured reporting.
Return the selected option followed by a two-sentence reason.

Question: Can a Java interface contain default methods?
Answer format: Yes or No.
Explanation: One sentence.
Example: Include one valid method declaration.

What does JVM stand for?
Which HTTP method is commonly used to update an entire resource?
What is the default port used by a Spring Boot web application?
What is tokenisation in a language model?

What is dependency injection?

What is dependency injection in software development?
Define it in simple language.
Explain constructor injection and setter injection.
Include one short Java example.

What is Java, who created it, how does memory work, what is Spring Boot, and how do I deploy an application?

Part 1: What is Java and what problem was it designed to solve?
Part 2: Who originally developed Java?
Part 3: How does Java manage memory?
Part 4: What is the role of Spring Boot?
Part 5: What are the common ways to deploy a Spring Boot application?
Answer each part under a separate heading.

What is the latest long-term support version of Java as of August 2026?
Verify the information using an official source.
Mention the release date.

Question: What is the purpose of the Java Virtual Machine?
Include: Bytecode execution, memory management, security, and platform independence.
Length: 150 to 200 words.
Audience: Beginner developer.

Why does this SQL query become slow when the table grows?
What factors caused the application response time to increase?
How does this business strategy affect customer retention?
What weaknesses exist in this API design?

Analyse this code.

Analyse the following Java method.
Check time complexity, memory use, null handling, thread safety, readability, and possible exceptions.
Explain each issue separately.
Provide an improved version after the analysis.
Do not change the method’s intended behaviour.

Context: API response time increased from 300 milliseconds to 2.5 seconds after a new database filter was added.
Evidence: CPU usage is normal, memory usage is stable, and database query time increased from 100 milliseconds to 2 seconds.
Question: What is the most likely cause of the slowdown?
Output: Rank the three most likely causes.
Explain what evidence supports or weakens each cause.
Provide one verification step for every cause.

Analyse why the following Spring Boot endpoint may perform poorly.
Examine database access, object mapping, logging, network calls, and response size.
Mark each finding as Confirmed, Likely, or Possible.
Suggest a test that can verify every finding.

What is the difference between REST and GraphQL?
Compare ArrayList and LinkedList.
Which is more suitable for this project: MySQL or MongoDB?
How does zero-shot prompting differ from few-shot prompting?

Java or Python?

Compare Java and Python for developing a large banking application.
Evaluate performance, type safety, development speed, ecosystem, scalability, maintainability, and hiring availability.
Present the comparison in a table.
Recommend one language for the given use case.
Explain the trade-offs behind the recommendation.

Compare AWS, Azure, and Google Cloud for hosting a Java-based enterprise application.
Use the following weights:
Cost: 25 percent.
Managed Java services: 20 percent.
Security and compliance: 25 percent.
Global availability: 15 percent.
Operational simplicity: 15 percent.
Score each platform from 1 to 10 for every criterion.
Calculate the weighted score.
Explain any assumptions.

Compare constructor injection and field injection in Spring.
Evaluate testability, immutability, dependency visibility, framework coupling, and code maintainability.
Use a comparison table.
Recommend the preferred approach for production code.

Why is this API returning HTTP 500?
Why is the database connection pool becoming exhausted?
Why are users abandoning the payment page?
Why is the application consuming more memory over time?

How does database indexing affect query performance?

Why did this query remain slow after an index was added?

My code does not work. Why?

Environment: Java 21, Spring Boot 3, MySQL 8.
Expected behaviour: The API should save a new customer and return HTTP 201.
Actual behaviour: It returns HTTP 500.
Error: DataIntegrityViolationException caused by a duplicate email value.
Recent change: A unique constraint was added to the email column.
Question: What is causing the error and how should the API handle it?
Output: Explain the root cause, correction, validation approach, and suitable HTTP response.

Diagnose the cause of increasing memory usage in this Java service.
Known facts: Memory grows continuously for six hours, CPU remains normal, request traffic is stable, and memory drops only after restart.
Consider: Static collections, unclosed resources, caches, thread-local variables, and large object retention.
Rank the causes from most likely to least likely.
Provide a verification method for each cause.
Do not claim a root cause without evidence.

What would happen if a Java application ran without garbage collection?
How would the system behave if network latency increased by 500 milliseconds?
What might happen if a company removed all manual testing?
How would this architecture change if traffic increased ten times?

What if traffic increases?

Suppose the current REST API receives 1,000 requests per minute and traffic increases to 20,000 requests per minute.
The API uses one application instance, MySQL, and synchronous calls to two external services.
What performance and reliability problems are likely to appear?
Recommend architectural changes in priority order.
Explain which changes are required immediately and which can wait.

Assume the database size, request complexity, and business logic remain unchanged.
Only the number of concurrent users increases.
Analyse the likely impact on threads, connections, response time, and failure rate.

Evaluate three scenarios for an online learning platform.
Scenario 1: User traffic doubles.
Scenario 2: Database access becomes 50 percent slower.
Scenario 3: The payment provider becomes unavailable for ten minutes.
For each scenario, explain user impact, technical risk, detection method, and recovery plan.

What did this project teach us about requirement gathering?
Which decisions contributed most to the successful release?
What assumptions caused the original design to fail?
How could this answer be improved?

How did the project go?

Review the completed software project.
What worked well in planning, development, testing, and deployment?
What problems caused delays?
Which early warning signs were missed?
What three changes should the team make in the next project?
Base the answer only on the provided project notes.

Review your previous answer.
Identify any unsupported claims, missing steps, vague explanations, or conflicting statements.
Correct the issues.
Return the improved answer followed by a short change summary.

I studied Java Streams but still struggle to choose between map, filter, and flatMap.
Ask me five reflective questions that help identify where my understanding is weak.
Do not provide the answers until I respond.

Reflect on the failed application deployment.
Identify what the team knew before deployment, what assumptions were made, which checks were skipped, and what signals appeared after release.
End with five preventive actions for the next deployment.

What is dependency injection?

Why is constructor injection usually preferred?
Can you show a Spring Boot example?
How does dependency injection improve testing?
What problems can occur when too many dependencies are injected?
How is dependency injection different from the service locator pattern?

Explain the database connection pooling point in more detail.

Show a practical Java example of constructor injection.

Explain the same concept using a real-world analogy.

How can I verify that this is the actual root cause?

What evidence would prove that this conclusion is wrong?

Apply this recommendation to a Spring Boot microservice.

Convert the explanation into a step-by-step checklist.

Explain more.

In your previous answer, you mentioned that excessive object creation increases garbage collection pressure.
Explain how object allocation rate affects pause frequency.
Include one example and one monitoring metric.

Create a Java application.

Before answering, check whether the request contains enough information.
If any critical detail is missing, ask up to three focused clarifying questions.
Do not make major assumptions.
After receiving the answers, provide the final solution.

Can you provide more information?

Which database should the application use: MySQL, PostgreSQL, MongoDB, or no database?

I can design the API after confirming one detail.
Should user authentication use sessions, JWT tokens, or an external identity provider?

Why is Java clearly better than Python for every software project?

Don’t you agree that remote work always reduces productivity?

Why is microservice architecture better than monolithic architecture?

Compare microservice and monolithic architectures.
Explain the situations in which each approach is suitable.
Evaluate scalability, deployment, testing, operational complexity, and team structure.

Why did the developer’s poor coding cause the system failure?

What factors may have contributed to the system failure?
Consider code defects, requirements, testing, deployment, infrastructure, monitoring, and operational processes.

Build the strongest possible argument in favour of using Java for this project.
Then build the strongest argument against using Java.
Finish with a balanced conclusion.

Why are older developers unable to learn modern frameworks?

What factors may affect how quickly developers learn a new framework?
Consider prior experience, available training, project complexity, learning time, and quality of documentation.
Do not make assumptions based on age.

Find reasons proving that our marketing strategy is successful.

Evaluate whether the marketing strategy is successful.
Use conversion rate, acquisition cost, retention, revenue, and engagement.
Include evidence that supports and challenges the conclusion.
State when the available data is insufficient.

Based on these three positive customer comments, explain why the product is successful.

Evaluate customer satisfaction using positive, neutral, and negative feedback.
Explain whether the available sample is large and balanced enough to support a conclusion.

Should we improve performance by adding more servers or increasing database memory?

What options could improve application performance?
Consider code optimisation, database queries, caching, connection pooling, scaling, and infrastructure resources.
Rank the options after identifying the actual bottleneck.

Evaluate the claim that AI-generated code always increases developer productivity.
Present evidence supporting the claim.
Present evidence challenging the claim.
Explain the conditions under which productivity may increase or decrease.
End with a balanced conclusion.
Do not treat the claim as universally true.

Explain microservices, compare them with monoliths, design an architecture for an e-commerce platform, identify security risks, create APIs, choose a database, and provide deployment steps.

Part 1: Explain microservice architecture in simple language.
Part 2: Compare microservices with monolithic architecture.
Part 3: Identify the main services required for an e-commerce platform.
Part 4: Describe communication between the services.
Part 5: Recommend a database strategy.
Part 6: Identify major security risks.
Part 7: Define the main REST API endpoints.
Part 8: Provide a high-level deployment plan.
Answer each part under a separate heading.

Step 1: Ask me about the business purpose of the application.
Step 2: After I answer, ask about expected users and traffic.
Step 3: Ask about security and compliance requirements.
Step 4: Ask about budget and hosting preferences.
Step 5: Use my answers to propose the architecture.

Main question: How should we improve API performance?
Subquestion 1: Where is the current bottleneck?
Subquestion 2: What evidence supports that conclusion?
Subquestion 3: Which improvements address the bottleneck?
Subquestion 4: What are the risks of each improvement?
Subquestion 5: How should improvements be tested?
Subquestion 6: Which metrics should be monitored?

Solve the problem in four stages.
Stage 1: Identify missing information.
Stage 2: Analyse possible causes.
Stage 3: Rank the causes using available evidence.
Stage 4: Recommend actions only for the highest-ranked causes.
Clearly separate each stage.

Context: [Provide relevant background information.]
Question: [Write the main question.]
Scope: [Define what should and should not be covered.]
Audience: [Define the knowledge level of the reader.]
Include: [List the required points.]
Exclude: [List unwanted content.]
Output format: [Define headings, bullets, table, JSON, code, or another format.]
Length: [Define the expected length.]
Validation: [Explain how uncertain or missing information should be handled.]

Context: I am learning Java concurrency for interview preparation.
Question: How does synchronisation prevent race conditions?
Scope: Focus on synchronized methods, synchronized blocks, and shared mutable state.
Audience: Intermediate Java developer.
Include: One unsafe example, one corrected example, and common mistakes.
Exclude: Advanced lock-free algorithms.
Output format: Headings, code examples, and a final comparison table.
Length: 800 to 1,000 words.
Validation: Clearly identify any simplified explanations.

Topic: [Subject to explore.]
Question: How or why does [topic] affect [target area]?
Context: [Relevant background.]
Cover: [Required concepts.]
Audience: [Target reader.]
Example: [Type of example required.]
Output: [Required structure.]
Constraint: [Length or scope restriction.]

Topic: Database indexing.
Question: How does database indexing improve query performance?
Context: The reader understands basic SQL but not database internals.
Cover: Index lookup, table scanning, selectivity, composite indexes, and write overhead.
Audience: Beginner backend developer.
Example: Use a customer table with one million rows.
Output: Step-by-step explanation with a final checklist.
Constraint: Avoid deep mathematical details.

Question: [Question with a limited answer.]
Allowed answers: [Yes or No, True or False, or listed options.]
Decision criteria: [Rules used to select the answer.]
Explanation: [Required explanation length.]
Uncertainty rule: [What to do when information is insufficient.]

Question: Is Redis suitable as the primary database for a banking ledger?
Allowed answers: Yes, No, or Insufficient Information.
Decision criteria: Durability, transaction requirements, audit history, and relational consistency.
Explanation: Maximum five sentences.
Uncertainty rule: Do not assume missing compliance requirements.

Question: What is [concept]?
Include: [Required factual points.]
Audience: [Reader level.]
Date requirement: [Relevant date when information may change.]
Source requirement: [Official or trusted sources when needed.]
Output: [Format and length.]
Uncertainty rule: State when a fact cannot be verified.

Question: What is the Java Virtual Machine?
Include: Bytecode execution, memory management, runtime security, and platform independence.
Audience: Beginner Java developer.
Date requirement: Not applicable.
Source requirement: Use standard Java terminology.
Output: 300 words with headings.
Uncertainty rule: Avoid implementation-specific claims unless identified.

Context: [Situation being analysed.]
Evidence: [Available facts, logs, metrics, or observations.]
Question: [Analytical question.]
Criteria: [Areas to examine.]
Required reasoning: [Cause, impact, pattern, or relationship.]
Output: [Structure.]
Assumption rule: Separate evidence from assumptions.
Validation: Provide a way to test each conclusion.

Context: A Spring Boot API became slow after a new release.
Evidence: CPU is normal, memory is stable, database query duration increased, and no network errors are present.
Question: What changes are most likely responsible for the slowdown?
Criteria: SQL queries, indexes, transaction scope, object mapping, and logging.
Required reasoning: Rank causes by likelihood.
Output: Table with cause, evidence, confidence, and verification step.
Assumption rule: Do not present missing information as fact.
Validation: Include one test for every possible cause.

Compare: [Option A] and [Option B].
Use case: [Real situation.]
Criteria: [Shared comparison criteria.]
Priorities: [Most important requirements.]
Output: [Table, scorecard, or written comparison.]
Recommendation: [Whether a final recommendation is required.]
Trade-offs: Explain what is gained and lost with each option.
Missing information: Identify details that could change the recommendation.

Compare: REST and GraphQL.
Use case: Public product catalogue used by web and mobile applications.
Criteria: Query flexibility, caching, versioning, performance, security, and development complexity.
Priorities: Simple operations, stable response time, and easy monitoring.
Output: Comparison table followed by a recommendation.
Recommendation: Select the more suitable default approach.
Trade-offs: Explain limitations of the selected approach.
Missing information: Identify conditions that could change the recommendation.

Environment: [Technical or operational environment.]
Expected behaviour: [What should happen.]
Actual behaviour: [What currently happens.]
Symptoms: [Errors, metrics, or observations.]
Recent changes: [Code, configuration, infrastructure, or process changes.]
Troubleshooting completed: [Actions already taken.]
Question: What are the most likely causes?
Output: Rank causes by likelihood.
Verification: Provide a test for each cause.
Correction: Recommend actions only after verification.

Environment: Java 21, Spring Boot 3, PostgreSQL, Docker.
Expected behaviour: The application should start within 20 seconds.
Actual behaviour: Startup takes more than two minutes.
Symptoms: The logs pause while database migrations run.
Recent changes: Twenty new migration scripts were added.
Troubleshooting completed: Network connectivity and database credentials were verified.
Question: What are the most likely causes of the slow startup?
Output: Rank causes by likelihood.
Verification: Provide a test for each cause.
Correction: Recommend safe optimisation steps.

Current situation: [Existing state.]
Changed condition: Suppose [specific condition changes].
Fixed assumptions: [Conditions that remain unchanged.]
Question: What is likely to happen?
Evaluate: [Performance, cost, risk, user impact, or another area.]
Time period: [Immediate, short-term, or long-term.]
Output: [Scenario analysis format.]
Uncertainty: State assumptions and confidence.

Current situation: An application serves 5,000 daily users from one server.
Changed condition: Suppose daily users increase to 100,000 within three months.
Fixed assumptions: Application features and request complexity remain unchanged.
Question: What technical problems are likely to appear?
Evaluate: CPU, memory, database connections, storage, network traffic, and availability.
Time period: First week and first three months.
Output: Risk table followed by a scaling plan.
Uncertainty: State which recommendations require measurement.

Event or decision: [What is being reviewed.]
Available information: [Notes, results, feedback, or metrics.]
Question: What can be learned from this experience?
Examine: [Successes, failures, assumptions, and missed signals.]
Evidence rule: Base conclusions on the provided information.
Output: Lessons learned and action items.
Future use: Explain how the lessons should change the next attempt.

Event or decision: Release of a new payment feature.
Available information: The feature passed testing but failed under production traffic.
Question: What can be learned from this release?
Examine: Test coverage, load testing, monitoring, rollback planning, and communication.
Evidence rule: Separate known facts from possible causes.
Output: Five lessons and five preventive actions.
Future use: Convert the actions into a pre-release checklist.

Previous point: [Quote or identify the relevant part.]
Follow-up question: [Ask for expansion, correction, evidence, or application.]
Required depth: [Basic, intermediate, or advanced.]
Include: [Required details.]
Output: [Preferred structure.]
Constraint: Do not repeat the full previous answer.

Previous point: You stated that database indexes can slow write operations.
Follow-up question: Why do indexes increase insert and update cost?
Required depth: Intermediate.
Include: Index maintenance, page changes, and transaction overhead.
Output: Step-by-step explanation with one SQL example.
Constraint: Do not repeat the general definition of an index.

Review the request before answering.
Identify missing information that materially affects the result.
Ask no more than [number] clarifying questions.
Ask one detail per question.
Provide selectable options when useful.
Do not ask for information already provided.
Do not begin the main task until critical requirements are clear.

Review my request to build a REST API before generating code.
Identify missing information that affects architecture or implementation.
Ask no more than five clarifying questions.
Ask one detail per question.
Include options for language version, database, authentication, and deployment.
Do not ask for information already provided.
Do not generate the project until the critical requirements are clear.

Claim or topic: [Statement being evaluated.]
Evaluate the claim without assuming it is correct.
Present evidence supporting the claim.
Present evidence challenging the claim.
Identify missing information.
Explain alternative interpretations.
Separate facts, assumptions, and opinions.
End with a balanced conclusion.
Avoid emotionally loaded language.

Claim or topic: AI coding assistants always reduce software development time.
Evaluate the claim without assuming it is correct.
Present evidence supporting the claim.
Present evidence challenging the claim.
Consider code quality, review time, debugging, security, developer experience, and task complexity.
Separate facts, assumptions, and opinions.
End with the conditions under which the claim is more or less likely to be true.

Main goal: [Overall task.]
Break the task into logical parts.
Identify dependencies between the parts.
Complete each part in the correct order.
Use a separate heading for every part.
Do not skip a part.
State assumptions before using them.
End with a completion checklist.

Main goal: Design a secure online examination platform.
Break the task into requirements, users, architecture, database, APIs, authentication, exam security, monitoring, testing, and deployment.
Identify dependencies between the parts.
Complete each part in the correct order.
Use a separate heading for every part.
Do not skip a part.
State assumptions before using them.
End with a completion checklist.

How does software work?

How does a Java web application process an HTTP request from the browser to the database and back?
Explain each major component in order.

Explain Java, Python, cloud computing, AI, databases, and cybersecurity.

Create a separate beginner overview for Java, Python, cloud computing, AI, databases, and cybersecurity.
Limit each overview to 150 words.
Explain how the subjects are connected.

Which database should I use?

Which database is suitable for an online examination platform with structured questions, user accounts, test results, transactions, and reporting?
Compare PostgreSQL, MySQL, and MongoDB.

Which programming language is best?

Which programming language is most suitable for building a high-traffic banking API?
Evaluate Java, C#, Go, and Python using performance, ecosystem, maintainability, security, and developer availability.

Is this architecture efficient?

Evaluate whether this architecture is efficient in terms of response time, infrastructure cost, scalability, maintenance effort, and failure recovery.

Why did the deployment fail?

Analyse the deployment failure using the provided logs, environment changes, error messages, and timeline.
Separate confirmed findings from possible causes.

Explain why our new design is better.

Compare the old and new designs using performance, security, maintainability, development effort, and operating cost.
State whether the new design is better based on those criteria.

Tell me the exact cause of this error.

Identify the most likely causes of this error.
Rank them using the available evidence.
State what additional information is needed to confirm the root cause.

Is this API fast?

Can this API meet a response-time target of 300 milliseconds for 95 percent of requests under 1,000 concurrent users?

Identify any incorrect assumptions in the question before answering.

Focus on application-level performance.
Do not recommend changing cloud providers.
Do not discuss frontend optimisation.

Role: Act as a senior Java performance engineer.
Context: A Spring Boot API processes customer orders and stores data in PostgreSQL.
Problem: Response time increased from 400 milliseconds to 3 seconds after a new reporting feature was released.
Evidence: CPU usage is below 50 percent, memory is stable, database query time increased, and no external service failures were recorded.
Main question: What are the most likely causes of the performance regression?
Subquestion 1: Which evidence supports each possible cause?
Subquestion 2: What additional data is required to confirm the cause?
Subquestion 3: Which diagnostic tests should be performed first?
Subquestion 4: What safe corrections can be applied after confirmation?
Scope: Focus on SQL queries, indexes, transaction boundaries, connection pooling, object mapping, and reporting logic.
Exclude: Do not recommend adding servers until application and database causes are investigated.
Output: Provide a ranked diagnostic table followed by a step-by-step investigation plan.
Accuracy rule: Separate confirmed facts, likely causes, assumptions, and missing information.
Completion rule: End with a checklist that an engineer can follow during troubleshooting.