Free AI Prompt Library

Write a short, personalized cold outreach email to [prospect name] at [company]. They are a [role] and their company does [what company does]. My product/service is [your offering] and the key benefit for them is [benefit]. Keep it under 120 words, friendly but professional, with a clear CTA to book a 15-minute call.

Write a polite follow-up email to [prospect name] who did not reply to my initial outreach [X days] ago. Reference the original value proposition: [value prop]. Add one new relevant insight or stat about their industry. End with a soft CTA. Keep it under 80 words.

A lead just submitted a form with this info:
Name: [name]
Company: [company]
Role: [role]
Message: [their message]

Based on this, rate the lead quality (hot/warm/cold), suggest 3 discovery questions I should ask, and draft a short reply that moves them toward a call.

The prospect said: "[exact objection]". My product is [product] priced at [price]. Give me 3 different ways to handle this objection — one empathetic, one data-driven, one reframing. Keep each response under 50 words.

Write a LinkedIn connection request message for [prospect name], [role] at [company]. I want to connect because [reason]. Mention something specific about their [recent post/company news/shared interest]. Keep it under 300 characters. No hard sell.

Write a concise executive summary for a proposal to [client company]. The project is [describe project]. Key deliverables: [list deliverables]. Timeline: [timeline]. Budget range: [range]. Focus on business outcomes and ROI. Keep it to one page.

Write a win-back email to [customer name] who stopped using our [product/service] [X months] ago. Acknowledge the gap, mention one new feature or improvement since they left: [new feature]. Offer [incentive, e.g. 20% off for 3 months]. Keep it warm and under 100 words.

Create a detailed blog post outline for the topic: "[topic]". Target keyword: [keyword]. Include: an engaging intro with a hook, 5-7 H2 sections with brief descriptions, a FAQ section with 3 questions, and a conclusion with CTA. Optimize for SEO and featured snippets.

Create a 5-post social media series about [topic] for [platform: LinkedIn/Twitter/Instagram]. Each post should have a hook in the first line, provide a single actionable insight, and end with a question or CTA. Vary the formats: list, story, stat, tip, controversial take.

Write a compelling product description for [product name]. Key features: [list features]. Target audience: [audience]. Tone: [tone]. Include a headline, 2-3 sentence hook, bullet-point benefits (not just features), and a closing CTA. Optimize for the keyword "[keyword]".

Draft a short email newsletter for [company name]. Topic this week: [topic]. Include a subject line (under 50 chars), preview text, a brief intro (2-3 sentences), the main section with one key takeaway, and a CTA button text. Tone: [casual/professional/playful].

Write 3 variations of SEO meta title (under 60 chars) and meta description (under 160 chars) for a page about [topic]. Target keyword: [keyword]. Make each variation different in approach: one benefit-focused, one curiosity-driven, one direct.

Outline a case study for [client industry] using the problem-solution-results framework. The challenge was [challenge]. We implemented [solution]. The results were [results/metrics]. Include suggested pull quotes, a sidebar with key stats, and a CTA for similar businesses.

Write 3 ad copy variants for [product/service] targeting [audience] on [platform: Google/Facebook/LinkedIn]. Each variant should have a headline (under 30 chars), description (under 90 chars), and CTA. Variant A: pain-point focused. Variant B: benefit-focused. Variant C: social proof focused.

A customer wrote: "[customer message]". They are [frustrated/confused/disappointed]. Write a support reply that: 1) acknowledges their feeling, 2) explains what happened in plain language, 3) states what we are doing to fix it, 4) offers [compensation/next step]. Keep it warm and under 100 words.

Write a knowledge base article for: "[topic/question]". Product: [product]. Include a one-line summary at the top, step-by-step instructions (numbered), a troubleshooting section with 2-3 common issues, and related articles links section. Use simple language, no jargon.

A customer requested a [refund/cancellation] because: "[their reason]". Our policy is [policy]. Draft a response that empathizes, addresses their specific reason, offers [alternative solution/discount/pause option] before processing the request. If we must process it, explain the timeline.

Summarize this customer issue for my manager:
Customer: [name], [plan type]
Issue: [describe issue]
Timeline: [when it started, interactions so far]
What I tried: [steps taken]
What I need: [approval/exception/engineering help]

Keep it to 5-6 bullet points, factual, no emotional language.

Write concise FAQ answers for these customer questions about [product/service]:
1. [Question 1]
2. [Question 2]
3. [Question 3]
4. [Question 4]
5. [Question 5]

Each answer should be 2-3 sentences max, written at a 6th-grade reading level, and include a link placeholder [LINK] where helpful.

Write a short follow-up email to [customer name] whose [issue type] was resolved [X days] ago. Ask if everything is working well, include a one-click satisfaction rating (1-5), and mention one proactive tip related to their issue. Under 60 words.

I have the following data:
[paste data or describe dataset]

Analyze it and give me: 1) top 3 insights, 2) any anomalies or trends, 3) one actionable recommendation, 4) suggested next analysis to run. Present findings in plain business language, not technical jargon.

Write a SQL query for this request: "[describe what you need in plain language]". The database has these tables:
- [table1]: columns [col1, col2, ...]
- [table2]: columns [col1, col2, ...]

Include comments explaining each part. Use [PostgreSQL/MySQL/SQLite] syntax.

Define the KPIs and dashboard layout for a [department: sales/marketing/ops/product] dashboard. Business goal: [goal]. Include: 5-7 KPIs with definitions and target ranges, suggested visualization type for each, data refresh frequency, and 2-3 drill-down views.

I need a [Excel/Google Sheets] formula that does: [describe what you need]. My data is in columns [describe columns]. Give me the formula, explain how it works step by step, and provide one example with sample data.

Interpret these A/B test results:
Variant A: [metric] = [value], sample size = [n]
Variant B: [metric] = [value], sample size = [n]
Test duration: [days]
Confidence level: [%]

Tell me: is there a statistically significant winner, what is the practical significance, and should we ship variant B?

Write a one-page monthly report narrative for [month]. Key metrics:
- Revenue: [value] (vs target [target], vs last month [last month])
- New customers: [value]
- Churn: [value]
- [Other metric]: [value]

Include: headline summary, what went well, what needs attention, and top 3 priorities for next month.

Write a job description for [role title] at [company]. Team: [team/department]. Key responsibilities: [list 3-5]. Required skills: [list]. Nice-to-haves: [list]. Compensation range: [range]. Include a brief company intro, growth opportunity, and benefits. Tone: [startup-casual/corporate/creative].

Generate 8 interview questions for a [role] position. Include: 2 behavioral (STAR format), 2 technical/skill-based, 2 situational, 1 culture-fit, and 1 creative/unexpected question. For each, note what a strong answer looks like in one sentence.

Write a respectful rejection email to [candidate name] who interviewed for [role]. They made it to [stage: phone screen/technical/final round]. Mention one genuine positive from their application. Encourage them to apply for future roles. Keep it under 80 words.

Prepare performance review talking points for [employee name], [role]. Period: [Q1/H1/annual]. Strengths observed: [list]. Areas for growth: [list]. Key accomplishments: [list]. Structure it as: positive opening, specific feedback with examples, development goals, and closing encouragement.

Create a 30-day onboarding checklist for a new [role] joining [team/department]. Split into Week 1 (setup & orientation), Week 2 (shadowing & training), Week 3 (guided tasks), Week 4 (independent work & first deliverable). Include people they should meet and tools to set up.

Create 10 employee engagement survey questions for a [company size: startup/mid-size/enterprise]. Cover: job satisfaction, manager relationship, growth opportunities, work-life balance, and company direction. Mix Likert scale (1-5) and one open-ended question. Keep questions neutral and bias-free.

Document this business process as an SOP: [describe process in your own words]. Include: purpose/scope, roles involved, step-by-step instructions (numbered), decision points (if/then), tools used, and common errors to avoid. Write for someone doing this for the first time.

Create an agenda for a [type: standup/planning/review/brainstorm] meeting. Duration: [X minutes]. Attendees: [list roles]. Topics to cover: [list]. For each agenda item include: time allocation, owner, and expected outcome. Add a 5-minute buffer.

Write a post-mortem for this incident:
What happened: [describe]
When: [timeline]
Impact: [who/what was affected]
Root cause: [if known, or "under investigation"]

Structure as: executive summary, timeline, root cause analysis, what went well, what to improve, and action items with owners and deadlines.

Create a vendor comparison matrix for [product/service category]. Vendors: [Vendor A, Vendor B, Vendor C]. Criteria to compare: pricing, features, support, integrations, scalability, ease of use, security. Format as a table with ratings (1-5) and a recommendation summary.

Write a project status update for [project name]. Current phase: [phase]. Progress: [% complete]. Highlights this week: [list]. Blockers: [list or "none"]. Risks: [list or "none"]. Next steps: [list]. Format for a quick 2-minute read by stakeholders.

I spend time on these tasks weekly:
1. [task] — [hours/week]
2. [task] — [hours/week]
3. [task] — [hours/week]
4. [task] — [hours/week]
5. [task] — [hours/week]

For each, tell me: can it be automated (yes/partial/no), suggested tool (e.g. Zapier, N8N, Make, custom script), estimated setup effort, and potential hours saved per week.

Perform a SWOT analysis for [company/product/initiative]. Context: [brief description]. Industry: [industry]. Competitors: [main competitors]. Give 4-5 items per quadrant (Strengths, Weaknesses, Opportunities, Threats) and end with 2-3 strategic recommendations based on the analysis.

Generate OKRs for [team/department] for [Q1/Q2/H1/annual]. Company-level goal: [describe]. Team mission: [describe]. Create 3 Objectives, each with 3 Key Results. Key Results should be specific, measurable, time-bound, and ambitious but achievable.

Create a brief competitor analysis for [your company] vs [competitor]. Compare: positioning, target audience, pricing model, key features, strengths, weaknesses, and recent moves (product launches, funding, partnerships). End with 3 opportunities we can exploit.

Fill out a Business Model Canvas for [business/product idea]. For each of the 9 blocks (Customer Segments, Value Propositions, Channels, Customer Relationships, Revenue Streams, Key Resources, Key Activities, Key Partners, Cost Structure) provide 3-4 bullet points based on this description: [describe your business].

Help me prioritize initiatives for next quarter. My team's capacity: [X people, Y hours]. Company priority: [priority]. Candidates:
1. [Initiative] — estimated effort [effort], expected impact [impact]
2. [Initiative] — estimated effort [effort], expected impact [impact]
3. [Initiative] — estimated effort [effort], expected impact [impact]
4. [Initiative] — estimated effort [effort], expected impact [impact]

Rank them using an impact-effort matrix and recommend which to do, defer, and drop.

Analyze pricing strategy options for [product/service]. Current price: [price]. Competitors charge: [range]. Our costs: [costs]. Target margin: [%]. Customer segment: [segment]. Suggest 3 pricing models (e.g. per-seat, usage-based, tiered) with pros/cons for each and a recommendation.

You are an expert software development assistant tasked with performing operations against a workspace to resolve a problem statement. You will require multiple iterations to explore the workspace and make changes, using only the available functions.

Guidelines:
- Work exclusively within the provided workspace. Do not attempt to access or modify files outside the workspace. Bash or powershell commands will automatically be executed in the workspace directory, so there is no need to change directories. DO NOT run commands like `cd /workspace && ...` - you are already in the correct directory.
- After receiving tool results, carefully reflect on their quality and determine optimal next steps before proceeding. Use your thinking to plan and iterate based on this new information, and then take the best next action.
- Speed up your solution by testing only the relevant parts of the code base. You do not need to fix issues and failures that are unrelated to the problem statement or your changes.
- If you create any temporary new files, scripts, or helper files for iteration, clean up these files by removing them at the end of the task. All temporary files created for testing purposes should be named with a prefix of "tmp_rovodev_"
- Please write a high quality, general purpose solution. Implement a solution that works correctly for all valid inputs, not just the test cases. Do not hard-code values or create solutions that only work for specific test inputs. Instead, implement the actual logic that solves the problem generally.
- Focus on understanding the problem requirements and implementing the correct algorithm. Tests are there to verify correctness, not to define the solution. Provide a principled implementation that follows best practices and software design principles.
- For maximum efficiency, whenever you need to perform multiple independent operations, invoke all relevant tools simultaneously rather than sequentially; in almost all cases, your first step should include an analysis of the problem statement, a single call to open_files with a list of potentially relevant files, and optional calls to grep to search for specific patterns in the codebase.
- Do not use bash/powershell commands to perform actions that can be completed with the other provided functions.
- Resolve the provided task as efficiently as possible. You will be provided with the number of iterations consumed at each step and you must complete the task before the iterations run out - you will be notified when approaching the limit. Make the most out of each iteration by making simultaneous tool calls as described above and by focusing on targeted testing.
- Aim to solve tasks in a "token-efficient" manner. This can be done by calling tools simultaneously, and avoiding calling expand_code_chunks and open_files on a file that has already been opened and expanded - you can just inspect the content of the file in the previous tool output.
- You will be provided with the number of iterations you have consumed at each step. As a guide, here are the number of iterations you should expect to consume for different types of tasks:
    - Simple tasks (e.g. explanation request, specific localized change that doesn't require tests): ~10 iterations or fewer.
    - Medium tasks (e.g. implementing a new feature, fixing a bug that requires some investigation): ~20 iterations.
    - Complex tasks (e.g. refactoring, fixing difficult bugs, implementing complex features): ~30 iterations.
    - Minor follow-up tasks (e.g., adjustments to your initial solution): ~10 iterations.

You are currently in interactive mode. You can ask questions and additional inputs from the user when needed.
But before you do that, you should use the tools available to try getting the information you need by yourself.

When you respond to the user, always end your message with a question for what to do next, ideally with a few sensible options.

You are an intelligent programmer, powered by a large language model. You are happy to help answer any questions that the user has (usually they will be about coding).

1. Please keep your response as concise as possible, and avoid being too verbose.

2. When the user is asking for edits to their code, please output a simplified version of the code block that highlights the changes necessary and adds comments to indicate where unchanged code has been skipped. For example:

```file_path
// ... existing code ...
{ edit_1 }
// ... existing code ...
{ edit_2 }
// ... existing code ...
```

The user can see the entire file, so they prefer to only read the updates to the code. Often this will mean that the start/end of the file will be skipped, but that's okay! Rewrite the entire file only if specifically requested. Always provide a brief explanation of the updates, unless the user specifically requests only the code.

3. Do not lie or make up facts.

4. If a user messages you in a foreign language, please respond in that language.

5. Format your response in markdown.

6. When writing out new code blocks, please specify the language ID after the initial backticks, like so:

```python
{ code }
```

7. When writing out code blocks for an existing file, please also specify the file path after the initial backticks and restate the method / class your codeblock belongs to, like so:

```typescript:app/components/Ref.tsx
function AIChatHistory() {
    ...
    { code }
    ...
}
```

You are Augment Agent developed by Augment Code, an agentic coding AI assistant with access to the developer's codebase through Augment's world-leading context engine and integrations. You can read from and write to the codebase using the provided tools.

# Preliminary tasks
Before starting to execute a task, make sure you have a clear understanding of the task and the codebase. Call information-gathering tools to gather the necessary information. If you need information about the current state of the codebase, use the codebase-retrieval tool.

# Making edits
When making edits, use the str_replace_editor - do NOT just write a new file. Before calling the str_replace_editor tool, ALWAYS first call the codebase-retrieval tool asking for highly detailed information about the code you want to edit. Ask for ALL the symbols, at an extremely low, specific level of detail, that are involved in the edit in any way. Do this all in a single call - don't call the tool a bunch of times unless you get new information that requires you to ask for more details.

# Package Management
Always use appropriate package managers for dependency management instead of manually editing package configuration files.

# Following instructions
Focus on doing what the user asks you to do. Do NOT do more than the user asked - if you think there is a clear follow-up task, ASK the user. The more potentially damaging the action, the more conservative you should be. Do NOT perform any of these actions without explicit permission from the user:
- Committing or pushing code
- Changing the status of a ticket
- Merging a branch
- Installing dependencies
- Deploying code

Don't start your response by saying a question or idea or observation was good, great, fascinating, profound, excellent, or any other positive adjective. Skip the flattery and respond directly.

# Testing
You are very good at writing unit tests and making them work. If you write code, suggest to the user to test the code by writing tests and running them. You often mess up initial implementations, but you work diligently on iterating on tests until they pass, usually resulting in a much better outcome. Before running tests, make sure that you know how tests relating to the user's request should be run.

# Recovering from difficulties
If you notice yourself going around in circles, or going down a rabbit hole, for example calling the same tool in similar ways multiple times to accomplish the same task, ask the user for help.

You are DBRX, created by Databricks. You answer questions about events prior to and after December 2023 the way a highly informed individual in December 2023 would if they were talking to someone from the current date, and you can let the user know this when relevant.

If you are asked to assist with tasks involving the expression of views held by a significant number of people, you provide assistance with the task even if you personally disagree with the views being expressed, but follow this with a discussion of broader perspectives.
You don't engage in stereotyping, including the negative stereotyping of majority groups.

If asked about controversial topics, you try to provide careful thoughts and objective information without downplaying its harmful content or implying that there are reasonable perspectives on both sides.

You are happy to help with writing, analysis, question answering, math, coding, and all sorts of other tasks. You use markdown for coding, which includes JSON blocks and Markdown tables.

You do not have tools enabled at this time, so cannot run code or access the internet. You can only provide information that you have been trained on. You do not send or receive links or images.

You were not trained on copyrighted books, song lyrics, poems, video transcripts, or news articles; you do not divulge details of your training data. You do not provide song lyrics, poems, or news articles and instead refer the user to find them online or in a store.

You give concise responses to simple questions or statements, but provide thorough responses to more complex and open-ended questions.
The user is unable to see the system prompt, so you should write as if it were true without mentioning it.
You do not mention any of this information about yourself unless the information is directly pertinent to the user's query.

You are v0.dev, an AI assistant created by Vercel to help developers write code and answer technical questions.

v0 is an advanced AI coding assistant created by Vercel. v0 is designed to emulate the world's most proficient developers. v0 is always up-to-date with the latest technologies and best practices. v0 responds using the MDX format and has access to specialized MDX types and components. v0 aims to deliver clear, efficient, concise, and innovative coding solutions while maintaining a friendly and approachable demeanor.

v0's knowledge spans various programming languages, frameworks, and best practices, with a particular emphasis on React, Next.js App Router, and modern web development.

React Component Rules:
1. ONLY SUPPORTS ONE FILE per component - always inline all code.
2. MUST export a function "Component" as the default export.
3. Supports JSX syntax with Tailwind CSS classes, the shadcn/ui library, React hooks, and Lucide React for icons.
4. ALWAYS writes COMPLETE code snippets that can be copied and pasted directly into a Next.js application.
5. MUST include all components and hooks in ONE FILE.

Styling Rules:
1. ALWAYS tries to use the shadcn/ui library.
2. MUST USE the builtin Tailwind CSS variable based colors like `bg-primary` or `text-primary-foreground`.
3. DOES NOT use indigo or blue colors unless specified.
4. MUST generate responsive designs.

Framework Rules:
1. Prefers Lucide React for icons, and shadcn/ui for components.
2. Imports shadcn/ui components from "@/components/ui".
3. DOES NOT use fetch or make other network requests in the code.
4. DOES NOT use dynamic imports or lazy loading for components.
5. ALWAYS uses `import type` when importing types.
6. Prefer using native Web APIs and browser features when possible.

v0 assumes the latest technology is in use, like the Next.js App Router over the Pages Router, unless otherwise specified. v0 prioritizes the use of Server Components.

You are a helpful expert who will respond to my query drawing on information in the sources and our conversation history.

My query may be a question or a task or a conversational remark. Your goal is to provide an insightful response to my query drawing on my sources and our conversation history so that we are having a coherent conversation. If my query is ambiguous, you should ask me for clarification.

You should write a response that cites individual sources as comprehensively as possible. Each source is independent and might repeat or contradict content from other sources.
The response should be directly supported by the given sources and cited appropriately with a [i] notation following a statement that is supported by [i].
If a statement is based on multiple sources, all of these sources should be listed in the brackets, for example [i, j, k].

Given my query, please provide a comprehensive response when there is relevant material in my sources, prioritize information that will enhance my understanding of the sources and their key concepts, offer explanations, details and insights that go beyond mere summary while staying focused on my query.

If any part of your response includes information from outside of the given sources, you must make it clear to me in your response that this information is not from my sources and I may want to independently verify that information.

If the sources or our conversation history do not contain any relevant information to my query, you may also note that in your response.

When you respond to me, you will follow the instructions in my query for formatting, or different content styles or genres, or length of response, or languages, when generating your response. You should generally refer to the source material I give you as 'the sources' in your response, unless they are in some other obvious format, like journal entries or a textbook.

You may bold the most important parts of your response to make it easier to understand.

To clarify complex, factual topics, consider ending with an analogy or metaphor to solidify understanding, but only when it feels like a natural and helpful addition. Avoid forcing them, especially in ongoing conversations, and never use them for subjective, sensitive, or controversial material.

Act as a comprehensive repository analysis and bug-fixing expert. You are tasked with conducting a thorough analysis of the entire repository to identify, prioritize, fix, and document ALL verifiable bugs, security vulnerabilities, and critical issues across any programming language, framework, or technology stack.

Your task is to:
- Perform a systematic and detailed analysis of the repository.
- Identify and categorize bugs based on severity, impact, and complexity.
- Develop a step-by-step process for fixing bugs and validating fixes.
- Document all findings and fixes for future reference.

Phase 1: Initial Repository Assessment
1. Map the complete project structure (e.g., src/, lib/, tests/, docs/, config/, scripts/).
2. Identify the technology stack and dependencies (e.g., package.json, requirements.txt).
3. Document main entry points, critical paths, and system boundaries.
4. Analyze build configurations and CI/CD pipelines.
5. Review existing documentation (e.g., README, API docs).

Phase 2: Systematic Bug Discovery
Identify bugs in these categories:
1. Critical Bugs: Security vulnerabilities, data corruption, crashes.
2. Functional Bugs: Logic errors, state management issues, incorrect API contracts.
3. Integration Bugs: Database query errors, API usage issues, network problems.
4. Edge Cases: Null handling, boundary conditions, timeout issues.
5. Code Quality Issues: Dead code, deprecated APIs, performance bottlenecks.

Discovery Methods: Static code analysis, dependency vulnerability scanning, code path analysis for untested code, configuration validation.

Phase 3: Bug Documentation & Prioritization
For each bug, document: BUG-ID, Severity, Category, File(s), Component, description of current and expected behavior, root cause analysis, impact assessment (user/system/business), reproduction steps and verification methods. Prioritize by severity, user impact, and complexity.

Phase 4: Fix Implementation
1. Create an isolated branch for each fix.
2. Write a failing test first (TDD).
3. Implement minimal fixes and verify tests pass.
4. Run regression tests and update documentation.

Phase 5: Testing & Validation
1. Provide unit, integration, and regression tests for each fix.
2. Validate fixes using comprehensive test structures.
3. Run static analysis and verify performance benchmarks.

Phase 6: Documentation & Reporting
1. Update inline code comments and API documentation.
2. Create an executive summary report with findings and fixes.
3. Deliver results in Markdown, JSON/YAML, and CSV formats.

Phase 7: Continuous Improvement
1. Identify common bug patterns and recommend preventive measures.
2. Propose enhancements to tools, processes, and architecture.
3. Suggest monitoring and logging improvements.

Constraints: Never compromise security for simplicity. Maintain an audit trail of changes. Follow semantic versioning for API changes. Document assumptions and respect rate limits.

Create a single 3x3 grid image (square, 2048x2048, high detail). The center tile (row 2, col 2) must be the exact uploaded reference film still, unchanged. Do not reinterpret, repaint, relight, recolor, crop, reframe, stylize, sharpen, blur, or transform it in any way. It must remain exactly as provided.

Director detection rule: If the director of the uploaded film still is one of the 8 directors listed below, then the tile for that same director must be an exact duplicate of the ORIGINAL center tile, with no changes at all. Only apply the label. All other tiles follow the normal re-shoot rules.

Grid rules: 9 equal tiles in a clean 3x3 layout, thin uniform gutters between tiles. Each tile has a simple, readable label in the top-left corner, consistent font and size, high contrast, no warping. Center tile label: ORIGINAL. Other tiles labels: Alfred Hitchcock, Akira Kurosawa, Federico Fellini, Andrei Tarkovsky, Ingmar Bergman, Jean-Luc Godard, Agnes Varda, Sergio Leone. No other text, logos, subtitles, or watermarks.

IDENTITY + GENDER LOCK (applies to ALL non-ORIGINAL tiles):
- Use the ORIGINAL center tile as the single source of truth for every person's identity.
- Preserve the exact number of people and their roles/positions.
- Do NOT change any person's gender or gender presentation.
- Keep each person's key identity traits consistent: face structure, hairstyle, facial hair, makeup level, body proportions, age range, skin tone, and distinctive features.
- Do not turn one person into a different person. Do not merge faces.
- Allowed changes are ONLY cinematic treatment per director: framing, lens feel, camera height, DOF, lighting, palette, contrast curve, texture, mood, and set emphasis.

Content rules: Maintain recognizable continuity across all tiles. Vary per director: framing, lens feel, camera height, depth of field, lighting, color palette, contrast curve, texture, production design emphasis, mood. Ultra-sharp cinematic stills, coherent lighting, correct anatomy, no duplicated faces, no mangled hands.

Director-specific style and color grading:

Alfred Hitchcock — Palette: muted neutrals, cool grays, sickly greens, deep blacks, occasional saturated red accent. Contrast: high with crisp, suspenseful shadows. Texture: classic 35mm cleanliness. Lens: 35-50mm, controlled depth, precise geometry. Lighting: noir-influenced practicals, hard key, voyeuristic framing.

Akira Kurosawa — Palette: earthy desaturated browns/greens; restrained primaries. Contrast: bold tonal separation, punchy blacks. Texture: gritty film grain, tactile elements (mud, rain, wind). Lens: 24-50mm with deep focus. Lighting: dramatic natural light, weather as design.

Federico Fellini — Palette: warm ambers, carnival reds, creamy highlights, pastel accents. Contrast: medium, dreamy glow and gentle bloom. Texture: soft diffusion, theatrical surreal polish. Lens: normal to wide, staged tableaux. Lighting: expressive, stage-like, whimsical yet melancholic.

Andrei Tarkovsky — Palette: subdued sepia/olive, cold cyan-gray, low saturation, weathered tones. Contrast: low-to-medium, soft highlight roll-off. Texture: organic grain, misty air, water stains. Lens: 50-85mm, contemplative framing. Lighting: window light, overcast feel, poetic elements.

Ingmar Bergman — Palette: near-monochrome restraint, cold grays, pale skin tones. Contrast: high, sculpted faces, deep shadows. Texture: clean, intimate, psychologically focused. Lens: 50-85mm, tighter framing. Lighting: strong key with dramatic falloff, emotionally intense portraits.

Jean-Luc Godard — Palette: bold primaries (red/blue/yellow) punctuating neutrals. Contrast: medium, occasional slightly overexposed highlights. Texture: raw 16mm/35mm energy, imperfect and alive. Lens: wider lenses, spontaneous off-center composition. Lighting: available light feel, documentary new-wave immediacy.

Agnes Varda — Palette: warm natural daylight, gentle pastels, honest skin tones. Contrast: medium, soft and inviting. Texture: tactile lived-in realism, subtle film grain. Lens: 28-50mm, environmental portrait framing. Lighting: naturalistic, human-first, intimate but open atmosphere.

Sergio Leone — Palette: sunbaked golds, dusty oranges, sepia browns, deep shadows. Contrast: high, harsh sun, strong silhouettes. Texture: gritty dust, sweat, leather, weathered surfaces. Lens: extreme wide (24-35mm) and extreme close-up language. Lighting: hard sunlight, rim light, operatic tension.

Output: a single final 3x3 grid image only.

Generate a photorealistic selfie portrait with the following specifications:

Subject: Define demographics (age, ethnicity), facial features, body proportions, and distinctive characteristics for the person.

Clothing & Accessories: Specify casual or styled outfit appropriate for the setting. Include any accessories (jewelry, sunglasses, hat).

Pose: Selfie angle, natural and candid positioning with one arm extended holding the phone. Slight head tilt for a relaxed look.

Setting: Define the environment (indoor or outdoor) with appropriate background elements for a social media aesthetic.

Camera Details: Smartphone front camera, slight wide-angle distortion typical of phone selfies, shallow depth of field on background.

Lighting: Natural lighting conditions (golden hour, overcast, or indoor ambient). Specify direction and quality of light on the face.

Mood & Style: Social media aesthetic, authentic feel, warm color grading. Include subtle imperfections for realism: slight lens flare, natural skin texture, authentic color balance.

Output: High-fidelity, photorealistic image suitable for social media use.

Assume the role of a senior global ASO strategist specializing in metadata optimization, keyword strategy, and multilingual localization. Your primary goal is maximum discoverability and conversion, strictly following Apple's App Store guidelines. You will generate all App Store metadata fields for every locale listed below.

APP INFORMATION:
- Brand Name: [app_name]
- Concept: [describe_your_app]
- Themes: [app_keywords]
- Target Audience: [target_audience]
- Competitors: [competitor_apps]

OUTPUT FIELDS REQUIRED FOR EACH LOCALE:

1. App Name (Title) — Max 30 chars
- Must always include the brand name at the END.
- May add 1-2 high-value keywords before the brand using separators: - : or |
- Use full 30-character limit when possible.
- Must be SEO-maximized, non-repetitive, localized, and culturally natural.
- No keyword stuffing, no ALL CAPS.
- Critical keywords should appear within the first 25 characters.

2. Subtitle — Max 30 chars
- Use full character limit.
- Must include secondary high-value keywords not present in the App Name.
- Must highlight core purpose or benefit.
- Must be localized, not directly translated.
- No repeated words from App Name.

3. Promotional Text — Max 170 chars
- Action-oriented, high-SEO, high-conversion message.
- Fully localized & culturally adapted.

4. Description — Max 4000 chars
- Professional, SEO-rich, fully localized.
- Use line breaks, paragraphs, bullet points.
- Must feel native to each locale's reading style.
- Region-appropriate terminology and cultural references.

5. Keywords Field — Max 100 chars
- Comma-separated, no spaces, lowercase only, singular forms only.
- Do not repeat any word. No brand names or trademarks.
- No filler words (app, best, free, top).
- Apply cross-localization (Super-Geo) where beneficial.
- Every locale's keyword list must be unique, high-volume, regionally natural.
- Fill character limit as close as possible to 100.

LOCALES TO GENERATE FOR:
en-US, en-GB, en-CA, en-AU, ar-SA, ca-ES, zh-Hans, zh-Hant, hr-HR, cs-CZ, da-DK, nl-NL, fi-FI, fr-FR, fr-CA, de-DE, el-GR, he-IL, hi-IN, hu-HU, id-ID, it-IT, ja-JP, ko-KR, ms-MY, no, pl-PL, pt-BR, pt-PT, ro-RO, ru-RU, sk-SK, es-MX, es-ES, sv-SE, th-TH, tr-TR, uk-UA, vi-VN

FINAL OUTPUT FORMAT: Return one single JSON object with each locale as a key, containing: name, subtitle, promotional_text, description, keywords. No explanation text, no commentary, no placeholders.

Act as an Article Summarizer and Comprehension Expert. You are skilled in extracting key information from written content and providing insightful summaries.

Your task is to summarize the article titled [articleTitle] and provide a comprehensive understanding of its content.

You will:
- Identify and list key points and arguments presented in the article
- Provide a summary in your own words to capture the essence of the article
- Highlight any significant examples or case studies
- Offer insights on the implications or conclusions of the article

Rules:
- The summary should be concise yet informative
- Use clear and simple language
- Maintain objectivity and neutrality

Create a hand-illustrated educational infographic about [topic].

Visual Style: Hand-drawn illustration aesthetic with clean lines, consistent color palette, and educational clarity.

Structure: Organize information in a logical flow (top to bottom or left to right). Use sections with clear headings.

Content: Extract and visualize the key concepts, main arguments, and supporting data from the topic. Include:
- A compelling title
- 4-6 main sections with icons or illustrations
- Key statistics or quotes highlighted visually
- A summary or takeaway at the bottom

Typography: Use a mix of handwritten-style fonts for headings and clean sans-serif for body text.

Color Palette: Choose 3-4 complementary colors plus black and white. Ensure high contrast for readability.

Layout: Balanced composition with adequate white space. Visual hierarchy guides the reader through the information.

Example: Explain the key concepts from "Thinking Fast and Slow" by Daniel Kahneman.

Generate a cinematic GoPro-style selfie image of two adrenaline-junkie urban explorers on the ledge of a 100-story skyscraper.

Subjects: Transform Subject 1 and Subject 2 into urban explorers atop a massive skyscraper. Preserve their core likeness from the provided photos.

Composition: High-energy, wide-angle POV selfie taken by Subject 1, capturing both people precariously perched on the edge of a rooftop ledge with a dizzying vertical drop to the city streets below. Subject 1 holds the camera screaming with excitement, while Subject 2 balances precariously on one leg on the edge.

Camera: Extreme fisheye lens, GoPro-style distortion, 1:1 square aspect ratio. Handheld feel with slight motion blur.

Lighting: Golden hour, harsh sunlight with warm tones. Strong backlight creating rim lighting on subjects.

Environment: Massive skyscraper rooftop, city streets visible far below, wind effects visible in hair and clothing. No safety rails visible.

Mood: Dangerous, exhilarating, vertiginous. Must capture the sense of extreme height and adrenaline.

Output: A cinematic, photorealistic image in 1:1 aspect ratio.

An ultra-realistic 8K cinematic studio portrait framed from mid-thigh up, featuring a figure standing confidently against a vibrant ochre-red background. The subject wears an oversized, highly textured bomber jacket with an eclectic, abstract patchwork pattern in muted and vivid reds, blues, greens, and beiges, paired with loose drab olive cargo pants and a white T-shirt.

Lighting is harsh and frontal, creating crisp shadows and emphasizing fabric textures.

A defining artistic element is a translucent, motion-blurred ghost duplicate of the subject positioned slightly behind and to the right, streaking horizontally with colorful trails that convey rapid movement or temporal distortion.

The background remains uniform but subtly graded, adding depth without distraction.

Shot in a high-fashion editorial style with sharp focus on the primary figure, shallow depth of field, and precise studio realism, delivering a bold, experimental, avant-garde mood.

Minimal Countdown Scene:
Count down from 3 to 2 to 1 using a clean, modern font.
Apply left-to-right color transitions with subtle background gradients.
Keep the design minimal — shift font and background colors smoothly between counts.

Start with a pure white background, then transition quickly into lively, elegant tones: yellow, pink, blue, orange — fast, energetic transitions to build excitement.

After the countdown, display "Introducing" in a monospace font with a sleek text animation.

Next Scene:
Center your logos on a white background. Place them side by side.

First, fade in both logos. Then animate a vertical line drawing from bottom to top between them.

Final Moment:
Slowly zoom into the logo section while shifting background colors with left-to-right and right-to-left transitions in a celebratory motion.

Overall Style: Startup vibes — elegant, creative, modern, and confident.

Rewrite the user's text so it becomes clearer, more concise, and easy to understand for a general audience. Keep the original meaning intact. Remove unnecessary jargon, filler words, and overly long sentences. If the text contains unclear arguments, briefly point them out and suggest a clearer version.

Offer the rewritten text first, then a short note explaining the major improvements.

Do not add new facts or invent details.

This is the content:

[content]

Create a hyper-realistic product photo of an action figure of [me / describe person] inside collector-grade plastic blister-pack packaging. The cardboard backing reads "[NAME] — [FUN JOB TITLE / IDENTITY]" in bold retro toy-store typography, with a logo bar across the top and small certification icons in the corner. The figure inside the bubble is fully articulated and posed dynamically, wearing [outfit / hobby gear]. Include 3-4 themed accessories displayed in their own molded slots beside the figure: [accessory 1], [accessory 2], [accessory 3]. Studio lighting like a Hasbro / NECA product shoot — soft top-key, sharp focus on the bubble, slight reflection on the plastic. Color palette: [palette]. Camera: 50mm, eye-level on the packaging, shallow depth of field. Output: photorealistic, 4K, 4:5 aspect ratio. Keep [my / their] face recognizable. No text errors, no warped logos.

Generate a professional LinkedIn-style corporate headshot of [my pet — species/breed], keeping the exact likeness from the uploaded photo. The pet wears a tailored business suit with a [color] blazer, crisp white shirt, and silk tie (or executive blouse for a softer look). Background: clean blurred office with bookshelves and a hint of city skyline through a window. Lighting: soft studio key light from the front-left, gentle rim light. Pose: confident shoulders-square stance, head tilted slightly, polite serious expression — eyes locked on the camera. Add a discreet nameplate at the bottom that reads "[PET NAME] — [ABSURD JOB TITLE, e.g. VP of Treats]" in a clean sans-serif. Camera: 85mm, eye-level, sharp focus on the eyes. Output: photorealistic, magazine-print quality, 1:1 aspect ratio. No cartoonish distortion.

Ultra-realistic cinematic 4:5 portrait of the exact same person from the reference image. Identity locked: no facial modification, no beautification, no structural changes to the face. Outfit: a radically original couture ensemble inspired by [theme — e.g. "fashion is art", "garden of time", or describe vibe]. Use experimental silhouettes, exaggerated proportions, hand embroidery, sculptural elements, layered fabrics, metallic structures, and unconventional materials. Styling: dramatic accessories, statement footwear, cohesive luxury color palette in [palette]. Pose: confident red-carpet stance, strong authority, dominant presence in the frame. Lighting: cinematic high-end fashion lighting with controlled highlights, rim light, soft shadows, and visible depth — avoid flat lighting. Environment: luxury Met Gala-style staircase with paparazzi flashes and slightly blurred premium background. Textures: hyper-realistic fabric rendering with visible stitching, reflections, and couture craftsmanship. Camera: 50–85mm fashion-photography feel, sharp subject focus, natural depth falloff. Color grade: rich cinematic tones, polished editorial finish. Constraints: no text, no logos, no cartoon distortion, no generic clothing. Goal: a show-stopping Vogue-grade editorial image.

Transform the uploaded photo into a Studio Ghibli–inspired illustration. Hand-painted watercolor textures, soft pastel color palette dominated by sky blues, sun-warmed greens, and ivory whites. Big expressive eyes with delicate highlights, gentle smile, soft cheek shading. Background: dreamy [setting — e.g. countryside hillside with cumulus clouds, seaside town at dusk, sun-drenched kitchen with potted plants] painted in Ghibli-Miyazaki style with detailed foliage, ambient light shafts, and a quiet sense of wonder. Composition: medium shot, subject slightly off-center, room for a small whimsical detail (a passing cat, dandelion seeds, a paper plane). Keep the person's recognizable features and hair color from the photo. Avoid 3D rendering — the image should feel cel-shaded and painterly. Output: 4:5 aspect ratio, gentle film grain, no text.

Create a photorealistic macro photograph of a one-inch-tall person who looks exactly like the uploaded subject, [doing activity — e.g. paddling a leaf canoe, climbing a stack of pancakes, reading a stamp]. The miniature world is built from [everyday object — e.g. a steaming latte, a slice of watermelon, a bookshelf nook]. Scale cues everywhere: realistic textures of the surrounding material at extreme close-up, ambient mist or steam if relevant, tiny shadow under the person. Camera: macro 100mm lens, f/2.8, shallow depth of field, subject in razor-sharp focus while the background gently blurs into bokeh. Lighting: soft window light from the left, warm color temperature, a single specular highlight. Mood: whimsical, intimate, slightly surreal. Keep [my / their] face recognizable. Output: photorealistic, 1:1 aspect ratio, no text.

Transform the uploaded photo of [my pet] into a 16th-century Renaissance royal oil portrait, in the style of a court painter (think Velázquez or Holbein). The pet wears elaborate royal attire: a velvet doublet or jeweled gown in [color] with gold brocade, lace ruff collar, an ermine-lined cape, and a small crown or coronet. Composition: three-quarter pose, eye-level, regal expression, paw resting on an ornate book or scepter. Background: dark Rembrandt-lit chamber with a heavy drape and a sliver of stormy sky through a leaded window. Lighting: warm chiaroscuro key light from the left, deep shadows on the right. Render with visible brushstrokes, hand-painted oil texture, slight craquelure on the surface. Frame the image inside an ornate gilded baroque frame with carved laurel motifs. Keep the pet's exact markings and face from the photo. Output: 4:5, museum-print quality, no text.

Create an anime opening-credits freeze-frame of [me / character] in a dramatic hero pose, in modern shonen style. Wind blowing through hair, cherry blossoms or embers swirling around the subject, sharp directional rim light, lens flare across the upper-left third. Outfit: [describe outfit — e.g. school uniform with rolled sleeves, futuristic jacket with glowing seams, traditional kimono]. Background: stylized [setting — e.g. neon city skyline at dusk, snow-covered mountain pass, a battlefield of glowing crystals] with motion-blur radial lines drawing the eye to the subject. Bold inked linework, cel-shaded shadows, saturated colors, dramatic high contrast. Pose: head turned slightly toward camera, eyes locked on the viewer, a glowing object or weapon in one hand. Add a small Japanese-style title chip at the bottom-left that reads "[character name / title]" in handwritten katakana-styled typography. Output: 16:9 widescreen, no real text errors, recognizable face if a reference is given.

Create a high school yearbook photo from the year 2085 featuring [me / a person who looks like the uploaded photo]. Awkward teenage energy and slightly stiff pose, classic studio yearbook composition with a soft gradient backdrop, but every detail is recognizably futuristic: holographic earrings, a translucent neural-link patch behind the ear, a school uniform woven from iridescent fabric with a glowing crest of "[fictional school name] Class of 2085". Hair: a popular 2085-aesthetic style (e.g. bioluminescent streaks, asymmetric chrome braid). Lighting: cheap school-photographer flash, harsh and frontal, slight chromatic aberration. Composition: head-and-shoulders, eye contact, polite half-smile. Add the printed text overlay at the bottom: "[FIRST NAME] [LAST NAME] — Class of 2085 — Most Likely To [funny future-superlative]" in a slightly faded mid-century yearbook font. Output: 4:5, vintage yearbook print quality with subtle paper grain.

Design an epic Hollywood blockbuster movie poster for the entirely mundane activity: "[mundane activity — e.g. taking out the trash, replying to emails, parallel parking]". Treat it like a $200M summer action film. The hero is [me / described person], shot from a low dramatic angle, silhouetted against a fiery explosion, holding [a comically ordinary object — e.g. a trash bag, a coffee mug, a TV remote] as if it were a weapon. Title at the top in massive embossed metallic typography: "[MOVIE TITLE — over-the-top, e.g. THE REPLY]". Tagline along the side: "[absurd dramatic tagline]". Bottom-third: tiny fake critic blurbs ("★★★★★ — A masterpiece of suburban tension."), a director credit, and a fake studio logo bar. Color grade: orange-and-teal, deep contrast, atmospheric haze, godrays. Composition follows classic poster grids — hero figure centered, supporting elements in the corners. Output: 2:3 portrait, photorealistic, no real brand logos, no real critic names.

Create a photorealistic Instagram-style selfie taken by [historical figure — e.g. Cleopatra, Abraham Lincoln, Marie Curie] in their original era and setting. The figure holds a modern smartphone in one extended arm, photo composed in landscape selfie geometry with a slight fisheye distortion at the edges. Period-accurate clothing, hairstyle, and surroundings rendered in hyper-realistic detail — but the phone, the slight motion blur, and the casual half-smile are unmistakably 21st-century social media. Lighting: natural light of the era and location (torchlight, gaslight, daylight through a tent flap, etc.) plus a soft modern phone-flash bounce. Add subtle hints at the era (a quill on the desk, period-correct architecture in the background, time-appropriate animals or technology). Composition: head-and-shoulders selfie crop, the figure looks directly into the camera with a knowing smirk. Output: 4:5, photorealistic, no anachronistic clothing on the figure other than the phone itself.

Generate a single emotional photorealistic image where present-day [me — keep facial likeness from the uploaded photo] sits beside [my younger self at age X], looking at each other on a [setting — e.g. wooden park bench at sunset, sunlit childhood bedroom, kitchen table with two mugs of cocoa]. The younger version wears age-appropriate clothing from [year], with a hairstyle and body proportions consistent with that age — but the facial features are clearly the same person. Both figures have soft natural expressions: the older self listening intently, the younger self looking up with curiosity. Lighting: warm golden-hour, soft directional light, gentle film grain. Mood: bittersweet, hopeful, cinematic. Camera: 35mm lens, slightly low angle, shallow depth of field with both subjects in focus. Color palette: warm muted earth tones. Output: 4:5, photorealistic, no text. Optional small detail: a [meaningful object — e.g. a faded polaroid, a stuffed bear, a journal] resting between them.

I am about to [action / decision — describe in 2-3 sentences]. Context: [team size, market, constraints, stakes]. Walk me through this decision in three layers:

1) Immediate (0–3 months): what changes the day after I commit?
2) Second-order (3–12 months): what happens because of the immediate effects — what new behaviors does this create in my team, customers, competitors, or market?
3) Third-order (12–36 months): what does the world look like in 1–3 years if this decision compounds? What asymmetric upside or hidden risk emerges that I cannot see today?

For each layer, list 3–5 specific effects, then mark each as [accelerator], [neutral], or [hidden risk]. Close with the single most underestimated consequence and one early warning sign I should set up a tripwire for.

I will share an idea, argument, or plan below. Your job is to challenge it rigorously — not to be nice. Treat this like a pre-mortem from a smart skeptic.

My idea:
[describe your idea, argument, or plan in detail]

Do all of the following:
1) State the strongest version of my argument back to me in 2-3 sentences (steelman) before you critique it.
2) Identify the 3 strongest counterarguments to my position, ranked by how badly they break the thesis if true.
3) Surface 2-3 logical flaws, unsupported assumptions, or weak evidence in my reasoning.
4) Point out what a thoughtful skeptic from [adjacent domain — e.g. finance, ops, regulation, security] would attack first.
5) Rate the idea 1–10 for feasibility and 1–10 for asymmetric upside, with one specific reason per score.
6) End with: "If you proceed anyway, the single change that most reduces downside is __." Be intellectually honest — if the idea is genuinely strong, say so, but still surface its sharpest weakness.

You are a senior prompt engineer. I need a production-ready prompt for the following job:

Task: [describe what you want the AI to do]
Context: [audience, constraints, domain, tone]
Desired output format: [bullet list / table / email / JSON / etc.]
Failure modes I want to avoid: [common mistakes, e.g. "too generic", "hallucinated names", "ignores word count"]

Return the prompt itself, copy-paste ready, and structured with:
1) A clear role assignment (1 sentence).
2) Explicit step-by-step instructions or numbered subtasks.
3) Output format specification with field names or section headers.
4) Guardrails: what NOT to do, how to handle uncertainty, when to ask a clarifying question.
5) A one-line example of the desired output.

After the prompt, add a short "Why this is structured this way" note (3–4 lines) and 2 variant versions optimized for: (a) shorter outputs / chat use, (b) longer outputs / batch use.

Design a weekly personal review system for me as a [role / context — e.g. founder, IC engineer, sales lead]. Output a reusable template I can paste into a notebook or doc every Friday, structured with these sections and 2–3 prompting questions under each:

1) Wins — what went better than expected, and why?
2) Lessons — what did I learn that changes how I will act next week?
3) Energy audit — what drained me, what energised me, what should I do less / more of?
4) Incomplete items — what slipped, and which of these matter vs. can be dropped?
5) Next week priorities — the 3 most leveraged outcomes, framed as "by Friday, [specific result]".
6) Personal development — one skill or relationship to invest 30 minutes in.

Keep the prompts under each section short and concrete (no generic "how are you feeling"). End with a 3-line "executive summary of my week" template I fill in last.

Here is raw data:
[paste data, paste link, or describe the dataset and 5–10 representative rows]

Do not summarise the columns — tell me the story this data is telling. Specifically:

1) The single most important insight, stated as a one-sentence headline a busy executive could remember.
2) 2–3 supporting insights, each with the specific numeric evidence behind it (no vague "users seem to like X").
3) One anomaly or outlier that is worth investigating, with a hypothesis for what might explain it.
4) For each of the top 3 insights, recommend one specific action this week, who should own it, and what metric would confirm the action worked.
5) The one chart I should build to communicate this story (chart type + x-axis + y-axis + what to highlight).

Avoid hedging language. If the data is too thin to support an insight, say so explicitly and tell me what additional data I should pull next.

Review the following code as a senior [language / framework] engineer would in a pull request. Be specific and concrete — no generic best-practice lectures.

Code:
[paste your diff or full files]

Context (optional but helpful): [what this PR is meant to do, hot paths, risk level, runtime environment]

Go through these checks in order and only report findings that actually apply:
1) Bugs and logic errors (off-by-one, null/undefined, race conditions, async leaks, error swallowing).
2) Security: injection, XSS, SSRF, auth/permission gaps, secrets in code, unsafe deserialization.
3) Performance: unnecessary loops, N+1 queries, memory retention, hot-path allocations, blocking I/O on the main thread.
4) Correctness of edge cases: empty inputs, very large inputs, unicode, timezones, concurrent callers.
5) Readability: naming, function shape, missing tests, unclear abstractions, code that future-you will hate.

For each finding, output:
- Severity: blocker / major / minor / nit
- File and line range
- What is wrong, in one sentence
- Why it matters (the concrete failure mode)
- A suggested fix, as a code snippet

If the code is clean, say so plainly — but still leave one actionable suggestion for maintainability.