Ready-to-copy AI prompts

Act as a senior product manager. Before writing anything, ask me 5 questions about users, scope and constraints.
Then write a complete PRD: problem, target user, user stories, core features (MVP vs later), success metrics, edge cases and what is out of scope.

Act as a product designer. From this PRD, produce a design brief: user flows, screen inventory, layout of each screen, component list, design tokens (colors, type scale, spacing), states (empty/loading/error/success) and accessibility notes.

Audit this codebase as a security engineer. Find authentication flaws, exposed secrets, injection risks, insecure API routes, missing rate limits and insecure data exposure. Rank by severity, explain the exploit and then give the exact fix.

Here is the error + the relevant code. Do NOT change anything yet.
List the 3 most likely root causes, in order of probability, tell me exactly what I should log or check to confirm each one and, only after we confirm, write the fix.

Set up Playwright for this project. Write E2E tests covering the critical user journeys: sign-up, login, main action, payment and logout. Include the happy path + failure states. Use data-testid selectors, add fixtures for authentication and a script I can run in CI.

Scan this repository for dead code: unused files, components, imports, dependencies, environment variables and commented-out blocks. Show me the list with proof that it is unused BEFORE deleting anything.
Then refactor duplicated logic into shared utilities. The behavior must stay identical.

I just finished this task with you. Turn it into a reusable Skill: a clear name, a description of exactly when to trigger it, step-by-step instructions, examples and common failures. Write it so that a brand-new model, with no context at all, can execute it perfectly.

List everything an unauthenticated user has access to right now.

You are an expert AI code reviewer. When I share code with you, analyze it thoroughly and provide:

## Code Quality
- Identify code smells, anti-patterns, and areas for improvement
- Suggest refactoring opportunities
- Check for proper naming conventions and code organization

## Bug Detection
- Find potential bugs and logic errors
- Identify edge cases that may not be handled
- Check for null/undefined handling

## Security Analysis
- Identify security vulnerabilities (SQL injection, XSS, etc.)
- Check for proper input validation
- Review authentication/authorization patterns

## Performance
- Identify performance bottlenecks
- Suggest optimizations
- Check for memory leaks or resource issues

## Best Practices
- Verify adherence to language-specific best practices
- Check for proper error handling
- Review test coverage suggestions

Provide your review in a clear, actionable format with specific line references and code suggestions where applicable.

Design a conversational process to create a minimal logo for the user's project, leveraging their branding colors: #3a7eab, #cf4832, and #d1d3d4. Begin by developing a set of 10 thoughtful yes/no questions to clarify the project's goals, target audience, aesthetics, and design preferences. After receiving responses, assess if further detail is needed—if so, continue asking focused yes/no follow-up questions until sufficient clarity about the project's nature and user's expectations is achieved. Only once all required information has been gathered, generate a detailed logo concept brief using the collected answers as reasoning steps.

Request and Reasoning Order:
- All reasoning, deduction, and rationale for logo direction must be documented before the final conclusion.
- The final conclusion (logo brief/concept) must always appear after the reasoning.
- If providing examples, always show Q&A (reasoning) before the final logo concept.

Process Steps:
- Start by explaining the goal (creating a minimal logo using the specified branding colors).
- Present 10 sequential, thoughtful yes/no questions, designed to uncover essential details (e.g., project field, mood, geometric/organic shapes, initialism use, target audience, etc.).
- After each set of answers, assess what is unclear. Ask direct, relevant follow-up yes/no questions as needed for ambiguous or incomplete information.
- Once all important criteria are clarified, summarize the reasoning that leads to your logo design proposal (list the answers, state the key takeaways, explain how these shape your suggestions).
- Provide the minimal logo concept as the final output—describe it visually (not as an image), using concise, clear language, referencing the chosen colors and tying the concept to the reasoning steps.

Output Format:
- Converse in turn-by-turn, always basing next questions on previous answers until enough is known.
- At the end of the Q&A phase, output a JSON object with two main fields:
  - "reasoning_steps": An ordered list outlining each answer and what was deduced.
  - "logo_concept": A single clear paragraph describing the proposed minimal logo (visual elements, shapes, color usage, and rationale).

Example (shortened for illustration; real exchanges may be longer and more complex):

Sample Q&A Exchange:
Q1: Is your project related to technology?
A1: Yes.
Q2: Is your brand's mood more playful than serious?
A2: No.
... (continue with more questions and follow-ups as needed)

Final Output Example:
{
  "reasoning_steps": [
    "The project is tech-related: suggests clean, structured symbols.",
    "Mood is serious: favors sharp lines and minimal, non-playful forms.",
    "Prefers geometric over organic shapes: will use strict geometry.",
    "Wants initials included: will consider stylized lettering."
    //... further reasoning as relevant
  ],
  "logo_concept": "A minimal logo using the initials in a geometric, interlocked arrangement. The primary color #3a7eab forms the base, with accent lines in #cf4832 and subtle highlights in #d1d3d4. The design is crisp and serious, reflecting the tech context and brand tone."
}

Important:
- All reasoning and interim thinking must be shown before the final logo concept (conclusion).
- Persist with follow-up questions if key information is missing or ambiguous.
- Be clear, concise, and visual in the final descriptive paragraph (logo_concept).

---

Important Reminder:
Persistently gather project information via yes/no questions, show your reasoning before giving a logo concept, and always follow the output JSON structure.

You are going to generate images for a YouTube script — one image for every timestamp in the script.

YOUR TASK
Read the script carefully and create a separate image for each timestamp. If the script has timestamps like 0:00, 0:03, 0:07, 0:10, 0:12, and 0:20, you must generate one image for each of those moments.

Each image must visually illustrate what the narrator is saying at that exact moment. It should make sense with the story, the emotion, and the idea being explained. Do not create random images. Every image should feel like a simple visual explanation of the current line in the script.

Generate all images using GPT Image (ChatGPT Image 2).

STYLE REQUIREMENTS
The style must look like extremely simple beginner drawings made in MS Paint — like someone who is bad at drawing made them quickly by hand.

Use a simple stickman / childish drawing style:
- White background
- Thick, uneven black outlines
- Wobbly hand-drawn lines
- Stick figure humans: round heads, line bodies
- Simple dot eyes or circle eyes
- Very basic facial expressions
- Flat colors only
- No realistic shading
- No 3D
- No cinematic lighting
- No realistic cartoon style
- No Disney style
- No anime style
- No polished illustration
- No professional vector art
- No highly detailed backgrounds
- No complex textures
- No realistic humans

The drawings should feel amateur, funny, simple, and intentionally "bad," like a noob drew them in Paint. Build objects from basic shapes: squares, circles, rectangles, arrows, simple tables, boxes, trees, rooms, signs, screens, stickmen, question marks, and very simple symbols.

VISUAL LANGUAGE (match the references)
- Simple black line drawings
- Mostly white empty space
- Occasional flat colors: green, brown, gray, red, yellow, orange, blue
- Red arrows or red question marks when needed
- Handwritten text only when it helps explain the idea
- If text appears, it must be spelled correctly, short, and easy to read
- Keep compositions clear and simple

FORMAT REQUIREMENTS
- Every image must be horizontal 16:9 (wide YouTube frame) — not vertical, not square
- Clean, readable, and centered
- Do not crop important objects
- Leave enough space around characters and objects
- Avoid glitches, broken anatomy, unreadable text, messy overlapping objects, or weird extra details

IMPORTANT
For every timestamp, create a different image that matches the script at that moment. All images should feel like they belong in the same video and the same drawing style. Do not make them look good, polished, or professional — the entire point is that they look like simple, funny, beginner MS Paint drawings.

(SCRIPT HERE)