Tone and Writing Style

Write the response in a professional and respectful tone.
Avoid emotional or exaggerated language.
Keep the explanation confident but not aggressive.

Use a technical and instructional writing style.
Explain each concept step by step.
Use short paragraphs and descriptive headings.
Include practical examples after important concepts.

Use a friendly and encouraging tone.
Use a simple, instructional writing style.
Explain one concept at a time.
Avoid technical jargon unless it is defined.

Use a confident, helpful, and practical tone.
Avoid exaggerated marketing claims.
Present the company as knowledgeable and trustworthy.
Use clear language that is accessible to non-technical readers.

Please review the attached documentation and provide your observations regarding the proposed implementation.

Please review the document and share what you think about the proposed implementation.

Take a look at the document and let me know what you think.

Use a professional but approachable tone.
Avoid slang and overly casual expressions.
Do not make the response sound legalistic or bureaucratic.

This revolutionary solution will completely transform your workflow.

This solution can simplify several parts of your workflow and reduce repetitive work.

Use a positive and confident tone.
Keep emotional intensity moderate.
Avoid exaggerated words such as revolutionary, unbelievable, and life-changing.

This configuration prevents unauthorized requests from accessing the endpoint.

This configuration should prevent most unauthorized requests, assuming the authentication rules are correctly applied.

Use a confident tone for established facts.
Use cautious language for assumptions and uncertain conclusions.
Clearly distinguish verified information from recommendations.

Use an empathetic and reassuring tone.
Acknowledge the user’s frustration before explaining the solution.
Do not blame the user.
Focus on practical next steps.

The deployment failed because the environment variable is missing.

It appears that one possible reason for the deployment issue may be a missing environment variable.

Use a direct and professional tone.
State the main issue in the first sentence.
Avoid unnecessary introductions and indirect wording.

Validate the request body before processing the transaction.

You should consider validating the request body before processing the transaction.

We can improve reliability by validating the request body before processing the transaction.

Use an authoritative but respectful tone.
Give clear recommendations without sounding controlling.
Explain the reason behind each recommendation.

Use short and medium-length sentences.
Keep each sentence focused on one main idea.
Avoid sentences longer than 25 words where possible.

Keep paragraphs between two and four sentences.
Start a new paragraph when the topic changes.
Avoid large blocks of uninterrupted text.

Use simple English.
Define every technical term when it first appears.
Avoid unexplained abbreviations.
Use familiar real-world examples.

Use precise domain terminology.
Do not simplify established technical concepts unnecessarily.
Include implementation details, trade-offs, and edge cases.

Provide an intermediate-level technical explanation.
Explain the core mechanism and practical use cases.
Do not include mathematical derivations.
Include one implementation example.

Organize the response using descriptive headings.
Use numbered steps for procedures.
Use bullet points for features and rules.
Use a comparison table when discussing alternatives.

Address the reader directly using you.
Use active voice.
Avoid repeatedly using phrases such as users should or one must.

The configuration file should be updated before deployment.

Update the configuration file before deployment.

Prefer active voice.
Use imperative sentences for procedural steps.
Use passive voice only when the actor is unknown or unimportant.

Use standard software engineering terminology.
Define specialized terms at first use.
Avoid unnecessary business jargon and buzzwords.

Include one practical example for every major concept.
Use examples from web application development.
Keep each example directly related to the explanation.

Explain the model context window using a notebook analogy.
Clarify where the analogy stops being technically accurate.

Use Markdown formatting.
Use one main heading.
Use second-level headings for major sections.
Use bullet points for concise explanations.
Do not use decorative symbols or excessive emphasis.

Make it professional.

Use a professional and approachable tone.
Be confident, clear, and respectful.
Avoid slang, exaggerated claims, and corporate buzzwords.
Do not sound overly formal or impersonal.

Write clearly.

Use a clear instructional writing style.
Explain concepts in logical order.
Use short paragraphs and descriptive headings.
Define technical terms before using them.
Include practical examples where useful.
Avoid unnecessary repetition.

Tone: Specify the emotional and interpersonal quality.
Style: Specify the method of presentation.
Audience: Define the reader’s knowledge level and expectations.
Vocabulary: Define the complexity of language and terminology.
Structure: Define headings, paragraphs, lists, and sequence.
Voice: Specify active voice, passive voice, or narrative perspective.
Depth: Define how much explanation is required.
Restrictions: Identify language, phrases, or behaviors to avoid.

Tone: Professional, helpful, and confident.
Style: Technical, instructional, and point-to-point.
Audience: Junior Java developers preparing for interviews.
Vocabulary: Use standard Java terminology and define advanced terms.
Structure: Use headings, bullet points, examples, and a final checklist.
Voice: Prefer active voice and direct instructions.
Depth: Explain concepts at an intermediate level.
Restrictions: Avoid filler, repetition, vague advice, and exaggerated claims.

Role: Act as a senior technical documentation writer.
Task: Explain dependency injection in Spring Boot.
Audience: Java developers with one year of experience.
Tone: Professional, clear, and encouraging.
Writing style: Technical, instructional, and example-driven.
Output format: Use Markdown headings, bullet points, and Java examples.
Constraint: Avoid unnecessary framework history and unrelated design patterns.

Act as a senior technical writer.
Create documentation for a REST API authentication endpoint.
Use a neutral, precise, and professional tone.
Use a structured documentation style.
Include purpose, request format, response format, status codes, validation rules, and examples.
Use consistent terminology throughout the document.
Avoid promotional language and unnecessary explanations.

Explain Java interfaces to a beginner.
Use a friendly and encouraging tone.
Use simple English and short sentences.
Explain one concept at a time.
Define technical terms before using them.
Include a basic Java example.
Explain the example line by line.
Avoid advanced design patterns.

Compare event-driven architecture and request-response architecture.
Write for senior software architects.
Use an objective and analytical tone.
Use precise architectural terminology.
Discuss scalability, consistency, latency, failure handling, observability, and operational complexity.
Include trade-offs and suitable use cases.
Avoid introductory explanations of basic distributed-system concepts.

Write landing-page content for an online Java interview preparation platform.
Use a confident and motivating tone.
Use persuasive but honest language.
Focus on user benefits and practical outcomes.
Use short sections and clear calls to action.
Avoid false urgency, unrealistic guarantees, and exaggerated claims.

Write a customer support response for a failed payment complaint.
Use an empathetic and calm tone.
Acknowledge the inconvenience in the first paragraph.
Explain the likely cause in simple language.
Provide numbered troubleshooting steps.
Avoid blaming the customer.
Do not promise a refund unless the information confirms eligibility.

Summarize the project status for senior management.
Use a professional and decision-oriented tone.
Keep the response under 300 words.
Focus on progress, risks, business impact, decisions required, and next steps.
Avoid low-level implementation details.

Write an academic explanation of bias in large language models.
Use a formal and objective tone.
Present claims cautiously.
Distinguish established findings from interpretation.
Organize the discussion into causes, manifestations, evaluation methods, and mitigation approaches.
Avoid conversational expressions and unsupported conclusions.

Write a LinkedIn post about the importance of prompt testing.
Use a professional but conversational tone.
Begin with a strong observation.
Use short paragraphs.
Include one practical lesson and one clear takeaway.
Avoid clickbait and excessive hashtags.

Write an error message for an expired login session.
Use a calm and helpful tone.
Explain what happened in one sentence.
Tell the user exactly what to do next.
Keep the complete message under 25 words.
Avoid technical terms and blame-oriented language.

Use a professional, friendly, and confident tone.

Use a highly formal, casual, authoritative, and playful tone.

Use a professional and authoritative tone with light conversational warmth.
Prioritize clarity and credibility over humor.
Avoid slang and playful expressions.

Use a calm and supportive tone.
Explain the solution in numbered steps.
Use short paragraphs.

Do not sound dismissive.
Avoid corporate jargon.
Do not use exaggerated claims.
Avoid long introductory paragraphs.

Use a professional, calm, and supportive tone.
State the problem clearly.
Provide practical steps in logical order.
Avoid blame, sarcasm, exaggerated reassurance, and unnecessary apologies.

Use a clear educational style similar to a high-quality technical handbook.
Begin with a simple definition.
Progress from basic concepts to practical implementation.
Use precise examples and concise summaries.

Write like an expert.

Write the answer using the following style.
Start with a direct definition.
Explain the importance in two short paragraphs.
Present the process as numbered steps.
End with a practical checklist.
Keep the language professional and beginner-friendly.

Preferred style sample:
Dependency injection allows an object to receive its dependencies from an external source. This reduces tight coupling and makes the code easier to test.
Match the clarity and sentence length of the sample.
Do not copy its subject matter.

Use plain and direct language.
Prefer use over utilize.
Prefer help over facilitate.
Avoid words such as revolutionary, cutting-edge, seamless, and game-changing.
Use technical terminology only when it improves precision.

Keep most sentences between 10 and 20 words.
Use one main idea per sentence.
Prefer active voice.
Avoid repeated sentence openings.
Do not use rhetorical questions.
Use transition words only when they improve logical flow.

Begin with a one-paragraph overview.
Divide the explanation into five logical sections.
Use a comparison table for key differences.
Include one practical example.
End with a five-point checklist.
Do not include a separate conclusion section.

Maintain the same professional and beginner-friendly tone throughout this conversation.
Use the same terminology for repeated concepts.
Keep explanations point-to-point.
Do not increase technical complexity unless requested.

Use a conversational style for explanations.
Switch to a concise documentation style when generating final code comments.
Use a formal style when creating the final report.

Adapt the tone to the user’s situation.
Use a neutral tone for factual questions.
Use an empathetic tone for complaints or frustrations.
Use a concise and urgent tone for security warnings.
Keep the writing professional in all cases.

Role: Act as a senior Java technical educator.
Task: Explain Java exception handling.
Audience: Developers with basic Java knowledge.
Tone: Professional, clear, patient, and encouraging.
Writing style: Technical, instructional, and point-to-point.
Structure: Begin with a definition, explain the exception hierarchy, describe checked and unchecked exceptions, show syntax, provide examples, list best practices, and end with interview questions.
Vocabulary: Use standard Java terminology and define advanced terms.
Voice: Prefer active voice and direct explanations.
Formatting: Use Markdown headings, bullet points, tables, and properly indented Java examples.
Constraints: Avoid unnecessary history, repeated definitions, vague advice, and unrelated framework examples.

Explain microservices professionally.

Explain microservices to backend developers with two years of experience.
Use a professional, neutral, and analytical tone.
Use a technical and comparison-based writing style.
Begin with a precise definition.
Explain service boundaries, independent deployment, communication, data ownership, resilience, and observability.
Compare microservices with a modular monolith.
Include benefits, trade-offs, failure scenarios, and suitable use cases.
Use descriptive headings and a final decision checklist.
Avoid promotional language and oversimplified claims.

Use a professional but conversational tone.
Use direct language and varied sentence structure.
Avoid filler phrases, corporate jargon, and repeated conclusions.
Include practical examples that sound realistic.

Use a formal, casual, friendly, authoritative, humorous, serious, emotional, neutral, and highly persuasive tone.

Use a professional and friendly tone.
Keep humor minimal.
Prioritize clarity and credibility.

Use a calm and professional tone.

Present the answer as a Markdown table.

Use natural sentence variation.
Avoid repetitive transitions and formulaic conclusions.
Use context-specific examples.
Do not overuse phrases such as moreover, furthermore, and in conclusion.
Keep the wording direct and conversational.

Do not be formal.
Do not be casual.
Do not be verbose.
Do not be too short.
Do not use jargon.
Do not oversimplify.

Use a professional and approachable tone.
Keep the response between 500 and 700 words.
Use standard technical terms and define specialized terminology.
Explain concepts clearly without removing important technical detail.

Use a conversational style in the introduction.
Use a direct instructional style for the implementation steps.
Use a concise cautionary tone for security warnings.
Use a neutral summary style in the conclusion.

Write at an intermediate technical level.
Assume the reader understands Java syntax, HTTP, and relational databases.
Explain Spring-specific concepts.
Do not explain basic programming constructs.

Role: Act as a [role or expertise].
Task: Create [required content or response].
Audience: Write for [target audience and knowledge level].
Tone: Use a [tone characteristic], [tone characteristic], and [tone characteristic] tone.
Writing style: Use a [style characteristic], [style characteristic], and [style characteristic] writing style.
Vocabulary: Use [simple, intermediate, advanced, or domain-specific] vocabulary.
Voice: Prefer [active or passive] voice and use [first-person, second-person, third-person, or impersonal] perspective.
Structure: Organize the response using [headings, steps, bullets, tables, examples, or checklists].
Depth: Explain the topic at a [basic, intermediate, detailed, or expert] level.
Examples: Include [number and type of examples].
Avoid: Do not use [unwanted language, tone, structures, or content].
Output requirement: Return the response in [required format].

Act as an experienced technical content writer.
Create a detailed article about [topic].
Write for [target audience].
Use a professional, clear, and approachable tone.
Use a technical, instructional, and point-to-point writing style.
Begin with a precise introduction.
Explain concepts in logical order.
Use descriptive headings and concise paragraphs.
Define important technical terms.
Include practical examples where relevant.
Use active voice.
Avoid robotic wording, filler content, and unnecessary repetition.
End with best practices, common mistakes, and a summary.
Return the complete article in Markdown format.

Write a response to [customer situation].
Use an empathetic, calm, and respectful tone.
Acknowledge the customer’s concern.
Explain the situation in plain language.
Provide clear next steps.
Keep paragraphs short.
Avoid blame, defensive language, and unsupported promises.
End with a helpful and professional closing.

Prepare an executive summary about [subject].
Use a professional, neutral, and decision-oriented tone.
Use a concise and analytical writing style.
Focus on business impact, key findings, risks, decisions, and next steps.
Use short paragraphs and bullet points.
Avoid implementation-level details unless they affect a decision.
Keep the response within [word limit].

Explain [topic] to a complete beginner.
Use a friendly, patient, and encouraging tone.
Use simple English and short sentences.
Introduce one concept at a time.
Define technical terms immediately.
Use a familiar real-world analogy.
Include one basic practical example.
Explain the example step by step.
Avoid advanced terminology and unnecessary exceptions.

Global tone: Professional, clear, and respectful.
Introduction style: Conversational and accessible.
Technical explanation style: Precise and analytical.
Procedure style: Direct and step-by-step.
Warning style: Concise and cautionary.
Summary style: Brief and action-oriented.

Use a neutral tone when presenting facts.
Use a cautious tone when discussing uncertain outcomes.
Use an authoritative tone when describing mandatory security controls.
Use an encouraging tone when presenting learning recommendations.
Clearly label assumptions and limitations.

The introduction must be under 100 words.
Each paragraph must contain no more than four sentences.
Each major section must include at least one example.
Technical terms must be defined at first use.
The response must not contain promotional claims.
The conclusion must contain exactly five actionable recommendations.

Use beginner-friendly language without removing important technical details.
Simplify sentence structure, not the underlying concepts.
Clearly identify exceptions and limitations.
Do not replace precise terminology with inaccurate analogies.

The application failed to start because port 8080 is already in use. Stop the process using that port or configure the application to use another port.

The application cannot start because another process is already using port 8080. Stop that process or choose a different port, then start the application again.

The application startup failed because port 8080 is currently occupied by another process. Terminate the conflicting process or update the server port configuration before restarting the application.

This issue is usually straightforward to fix. Another process is using port 8080, so stop that process or change the application’s port and try again.

Dependency injection supplies an object’s dependencies externally, reducing coupling and improving testability.

Dependency injection allows a class to receive the objects it needs from an external source. Instead of creating dependencies internally, the class accepts them through a constructor, method, or framework container.

Dependency injection separates object creation from object usage. This reduces direct coupling, improves test isolation, and supports configuration-based component replacement, although it may introduce container complexity and less-visible runtime wiring.

A class often needs other objects to perform its work. Dependency injection gives those objects to the class instead of making the class create them itself. This makes the code easier to change and test.