Browse Prompts
224 prompts available in ai-tools · Page 1 of 19
Coding Custom Instructions Prompt: ChatGPT Setup by Stack
Write ChatGPT custom instructions for coding from your real stack: versions, code style, answer format, and pet peeves, sized to your plan's character limit.
Act as a senior software engineer who sets up ChatGPT custom instructions for developers. You write short, testable instructions from the developer's real stack and habits, and you keep them inside the character limit of their ChatGPT plan. Inputs: - My role and the kind of code I write: [DeveloperRole] - Languages, frameworks, and versions I use: [StackAndVersions] - My code style rules (formatter, typing, naming, testing): [CodeStyle] - How I want answers formatted: [AnswerFormat] - My ChatGPT plan and its custom instructions limit (1,500 characters on Free and Go, 5,000 on Plus, Pro, Business, Enterprise, and Edu): [PlanLimit] - Things ChatGPT does that annoy me when coding: [PetPeeves] Generate: 1. Custom instructions block: a ready-to-paste block for the Custom Instructions field, covering role, stack with versions, code style, answer format, and how to handle uncertainty, written as short direct lines. Show the character count against PlanLimit. 2. Peeve fixes: for each PetPeeve, the exact line in the block that fixes it. 3. What to leave out: details that belong in a single chat or a project instead of global instructions, such as one repo's folder layout. 4. Test prompts: four coding requests to run after saving, each with what a good answer should look like. 5. Where to paste it: Settings, then Personalization on web and desktop, with customization turned on; on iOS and Android, Settings, then Customize ChatGPT. Note that changes apply to all chats. Rules: - Only use versions and tools I listed. Do not add frameworks. - Keep the block under PlanLimit, counting spaces. - Custom instructions are a ChatGPT app setting. If I mention the API, explain that a system message does that job there.
Copilot in Excel Prompt Planner: Plan Mode, Edits and Checks
Plan Copilot in Excel requests from your real workbook: which mode to use, a plan mode prompt, step by step edit prompts by table and column, and checks after.
Act as an Excel analyst who writes requests for Copilot in Excel, the Copilot pane opened from the Copilot button in the lower-right corner of Excel. You know its three modes: edit mode (the default, changes the workbook), plan mode (proposes a plan to review first), and chat mode (answers without changing the workbook). You name the exact sheets, tables, columns, and ranges so Copilot changes only what it should. Inputs: - Workbook layout (sheet names, table names, columns, ranges, row count): [WorkbookLayout] - What I want at the end, in plain words: [Goal] - Where results should go (new sheet, new column, next to the data): [OutputPlace] - Known data problems (blanks, text numbers, duplicates, mixed dates): [DataQuirks] - How I will check the result (a total I know, a row I can verify by hand): [MyChecks] - Excel platform (Windows, Mac, web, iPad, iPhone, Android): [Platform] Generate: 1. Mode choice: which mode to use for each part of Goal and why. Note that on iPhone and Android only chat mode may be available, so give a chat-only path if Platform is mobile. 2. Plan mode prompt: one request that asks Copilot to propose the steps for the whole Goal using the names in WorkbookLayout, without editing yet. 3. Edit prompts: 3 to 6 short requests in order, one change each, naming the table, columns, and OutputPlace, starting with the DataQuirks fixes. 4. Check prompts: 2 or 3 chat mode requests that explain or verify the result without changing anything. 5. Manual checks: the exact numbers or rows from MyChecks to compare by hand, and what a mismatch would mean. 6. Undo plan: save a copy before editing, and what to look at if a step goes wrong. Rules: - Use only the names in WorkbookLayout. If a name is missing, ask for it. - One change per edit prompt, so each step can be checked. - Do not suggest the =COPILOT() worksheet function; Microsoft retired it on September 14, 2026. Use the Copilot pane instead. - If Copilot does not appear, it may not be included in the subscription or may be turned off by the organization; say so rather than guessing a fix.
NotebookLM Study Prompt: Quizzes, Flashcards, Audio Plan
Get the exact NotebookLM chat prompts and Studio settings for flashcards, quizzes, and Audio Overviews, plus a day by day plan to your exam from your sources.
Act as a study coach who works in NotebookLM (now called Gemini Notebook) and writes the exact chat prompts and Studio customization text a student pastes in, so every quiz, flashcard set, and Audio Overview stays grounded in the course sources already uploaded to the notebook. Inputs: - The sources in my notebook (slides, chapters, notes, review sheet): [CourseSources] - Exam date, length, question format, and the topics it covers: [ExamDetails] - Topics I keep getting wrong: [WeakSpots] - Days and minutes I can study before the exam: [StudyDays] - How I like to study (listening while commuting, flashcards on my phone, practice questions): [PreferredFormats] Generate: 1. Source check prompts for the notebook chat: one that lists the key topics in each CourseSources item with citations, and one that compares them with the ExamDetails topics and names any topic no source covers. 2. Study guide request for Reports, focused on the ExamDetails topics and the review sheet. 3. Flashcards customization text for the Studio panel: difficulty, a focus line built from WeakSpots, and the card count setting (fewer, standard, or more). 4. Quiz customization text that matches the exam format in ExamDetails, including short-answer, multi-select, or fill-in-the-blank questions when the exam uses them. 5. Audio Overview customization for PreferredFormats: which format to pick (Deep Dive, Brief, Critique, or Debate) and the focus instructions to type in. 6. Learning Guide chat prompts for each WeakSpots topic that ask me questions step by step instead of giving answers. 7. Day by day plan across StudyDays that adds up to the minutes I gave, naming the NotebookLM tool for each block, with "only cards you missed" reviews before the exam. 8. Final closed-notes check: what to write or draw from memory the day before, then compare with the sources. Rules: - Every answer, card, and question must come from my uploaded sources; tell me to open the citation when something looks off. - If a button or setting named here is not in my version, give me a chat prompt that does the same job. - Follow my course's academic integrity rules; this is for studying, not for graded work.
ChatGPT Memory Prompt: Review, Fix, and Clean What It Knows
Paste what ChatGPT remembers about you and get a keep, correct, or delete verdict per item, exact correction messages, cleanup steps, and memories worth adding.
Act as a ChatGPT personalization coach who audits what ChatGPT remembers about a user, sorts every remembered item into keep, correct, or delete, and writes the exact messages and cleanup steps to fix it, using only the memory text the user pastes. Inputs: - What ChatGPT remembers, pasted from its answer to "What do you remember about me?" or from my memory settings: [MemoryList] - What I use ChatGPT for now: [UseCases] - Details I do not want remembered: [PrivacyLines] - Facts that have changed: [OutdatedFacts] - My current custom instructions, if any: [CustomInstructions] - The memory controls I can see in Settings, Personalization, Memory: [VisibleControls] Generate: 1. Memory inventory: number each remembered item from MemoryList and tag it as a preference, a fact about me, a project, or a sensitive detail. 2. Verdict per memory item: keep, correct, or delete, with a one-line reason tied to UseCases, PrivacyLines, or OutdatedFacts. 3. Correction messages: one exact message to send ChatGPT for each item marked correct. 4. Cleanup steps for each item marked delete, using only the controls listed in VisibleControls, plus a reminder that deleting a chat does not necessarily delete a separate saved memory. 5. Custom instructions overlap: memory items that repeat or conflict with CustomInstructions, and which single place each should live. 6. Memories worth adding: up to three "Please remember that..." messages drawn only from UseCases. 7. Check message: what to ask ChatGPT afterward to confirm what it now remembers. Rules: - Never invent memory items, settings names, or features; if a control is not in VisibleControls, tell me to ask ChatGPT in chat instead. - Keep sensitive details out of the "worth adding" list. - Suggest a temporary chat for one-off sensitive questions.
ChatGPT Custom Instructions Prompt: Audit and Rewrite Yours
Paste your ChatGPT custom instructions and get a line-by-line audit, conflicts fixed, a rewrite that fits your plan's character limit, and four test chats.
Act as a ChatGPT power user who audits other people's custom instructions, cuts the lines that conflict or do nothing, and rewrites the rest so the difference shows up in real chats. Inputs: - My current custom instructions, pasted exactly: [CurrentInstructions] - My ChatGPT plan (Free, Go, Plus, Pro, Business, Enterprise, or Education): [Plan] - What I mainly use ChatGPT for: [MainUses] - Habits in ChatGPT's replies that annoy me: [AnnoyingHabits] - A reply I liked and why: [GoodReply] - Facts about me I am happy for ChatGPT to use: [AboutMe] - Information I never want in my instructions: [NeverInclude] Generate: 1. Audit table: every line of CurrentInstructions with keep, cut, or rewrite, and the reason (vague, conflicts with another line, repeats, or cannot be tested). 2. Conflicts: each pair of lines that pull against each other, and which one should win given MainUses. 3. Rewrite: new custom instructions in two labeled parts, "About me" and "How to respond", built from AboutMe, AnnoyingHabits, and GoodReply. Each response rule must be specific enough to check in a reply. Give the character count and keep it within the limit for Plan: 1,500 characters for Free and Go, 5,000 for Plus, Pro, Business, Enterprise, and Education. 4. Test chats: four test messages drawn from MainUses, and for each, what a reply that follows the new instructions should look like. 5. Where to paste: on web and desktop, Settings > Personalization, make sure Enable customization is on, then the Custom Instructions field; on iOS and Android, Settings > Customize ChatGPT. 6. Privacy check: confirm nothing from NeverInclude is in the rewrite, and flag anything else that is more personal than the task needs. Rules: - Do not invent facts about me; use AboutMe only. - No line that only says "be an expert" or "no fluff" without saying what that looks like. - Keep the rewrite in plain sentences I can edit later.
Story Writing Custom Instructions Builder for ChatGPT
Build ChatGPT custom instructions for story writing from your genre, voice, POV, and feedback style, plus project instructions for one book and a quick test.
Act as a fiction editor and ChatGPT setup coach who writes custom instructions for novelists and short story writers, so ChatGPT behaves like a consistent writing partner instead of rewriting every scene in its own voice. Inputs: - Genres and forms I write: [Genres] - How my prose should sound, with one short sample paragraph of my own writing if I have it: [VoiceSample] - Default point of view and tense: [POVTense] - Who the stories are for and any content limits: [AudienceLimits] - What role I want ChatGPT to play (brainstorm partner, line editor, continuity checker, co-writer on drafts I approve): [Role] - How I want feedback delivered: [FeedbackStyle] - Habits I want it to avoid (phrases, endings, structures): [AvoidHabits] - The project I am working on now, with its canon facts: [CurrentProject] Generate: 1. Custom Instructions text: one block I paste into the Custom Instructions field (Settings, then Personalization on web and desktop; Customize ChatGPT on mobile). Write it in second person to ChatGPT, under 1,200 characters, covering Role, Genres, POVTense, voice rules drawn from VoiceSample, FeedbackStyle, and AvoidHabits. General preferences only, no single-book canon. 2. Project instructions: a separate block with the CurrentProject canon (characters, setting rules, timeline, what has happened so far) for the instructions of a ChatGPT project used only for that book. 3. Voice rules: five concrete rules read from VoiceSample (sentence length, dialogue tags, description density, humor, profanity level), each quoting a phrase from my sample as evidence. 4. Test prompt: one short request I can run after saving, and what a good answer should and should not do, so I can see whether the instructions work. 5. Tune list: three edits to try if ChatGPT still drifts (too purple, too many cliffhangers, rewriting instead of commenting). 6. Unclear inputs: one line naming anything I did not give you that would change the instructions. Rules: - Never claim a character limit or setting name beyond the ones above; tell me to check the screen if it looks different. - Keep my voice as the target; do not import a famous author's style. - Nothing in the output may contradict AudienceLimits.
Student Custom Instructions from Courses and Goals
Paste courses, goals, citation rules, and honesty needs to get ChatGPT custom instructions that coach from your notes without ghostwriting graded work.
Act as a learning-tech coach who writes ChatGPT custom instructions for students from their real courses and goals, and who never ghostwrites graded essays or invents school policies. Inputs: - Level and program (high school, undergrad major, etc.): [Level] - Current courses and what each requires: [Courses] - How you want the model to help (quiz me, outline, explain, practice): [HelpModes] - Citation style and academic honesty rules you follow: [HonestyRules] - Accessibility or learning preferences: [Prefs] - Topics the model must not invent facts about: [NoInvent] - Tools you already use (Notes app, LMS name if any): [Tools] - Time zone and typical study windows: [Schedule] Generate: 1. Custom instructions "What would you like ChatGPT to know about you?" block under typical length limits, using only Inputs. 2. Custom instructions "How would you like ChatGPT to respond?" block with HelpModes, HonestyRules, and refusal to ghostwrite graded submissions. 3. Three starter prompts that match Courses. 4. Integrity checklist: 6 lines the student can paste into every chat. 5. Honesty note: list any school policy or LMS feature not in Inputs and therefore omitted. Rules: - Coach from the student's notes; do not write full graded essays or discussion posts as final submissions. - Do not invent honor-code text; quote only what the student provided. - Output is settings text for the student to paste, not institutional advice.
GPT-5 Custom Instructions Builder From Your Work Profile
Write ChatGPT custom instructions for GPT-5 from how you actually work: an about me block, response rules without conflicts, memory notes, and test prompts.
Act as a ChatGPT personalization specialist who writes custom instructions for people who use GPT-5 and newer models in ChatGPT every day, and who keeps instructions short, specific, and free of conflicting rules. Inputs: - My role, field, and what I use ChatGPT for most (top three tasks): [RoleAndTasks] - My current custom instructions, pasted, or "none": [CurrentInstructions] - What annoys me in ChatGPT's answers today (length, tone, filler, flattery, guessing): [Annoyances] - How I want answers formatted (length, bullets or prose, tables, code style, spelling variant): [FormatPreferences] - How I want uncertainty and mistakes handled (say I don't know, ask questions, cite sources): [HonestyPreferences] - Context ChatGPT should always know (tools I use, audience I write for, level of expertise): [StandingContext] - Things that belong to one project only, not every chat: [ProjectOnlyContext] Generate: 1. An audit of CurrentInstructions: rules that conflict with each other, vague rules ("be helpful"), and rules that fight Annoyances, each with a fix. 2. The "about me" block: role, tasks, StandingContext, and expertise level in 5 to 8 short sentences. 3. The "how to respond" block: rules for length, format, tone, HonestyPreferences, when to ask a clarifying question, and when to just answer, written as direct instructions with no rule repeated or contradicted. Keep it under 1,500 characters so it fits every plan. 4. A conflict check of the two new blocks: list any pair of rules that could pull in opposite directions and how the final wording resolves it. 5. A placement plan: what stays in custom instructions, what to move to a ChatGPT Project's instructions (from ProjectOnlyContext), and what to save as a memory or leave out. 6. Three test prompts based on RoleAndTasks, each with what a good reply should look like if the instructions work, and what to change if it does not. 7. A short version of both blocks under 600 characters total, for people who want the lightest setup. Rules: - Do not claim features, limits, or model behavior you cannot verify. If a setting may differ by app version, say so. - No instructions that try to override safety rules or ask ChatGPT to pretend it has tools it does not have.
ChatGPT Honesty Custom Instructions: Stop the Flattery
Make ChatGPT honest about your work: custom instructions and a chat opener that ban empty praise, label confidence, and argue the other side.
Act as an AI assistant behavior designer who writes custom instructions and chat openers that keep ChatGPT from flattering the user, agreeing by default, or sounding more certain than the evidence allows. Inputs: - What I want honest feedback on (a plan, draft, code, decision, or idea): [WorkToJudge] - What is at stake if I get it wrong, and who else is affected: [Stakes] - Where I suspect I am wrong or biased: [BlindSpots] - Evidence I actually have (data, tests, feedback, sources) versus what I am assuming: [EvidenceOnHand] - How blunt I want ChatGPT to be (direct but kind, or no softening at all): [BluntnessLevel] - Output format: [Format] Generate: 1. A ChatGPT custom instructions block under 1,200 characters that I can paste into personalization settings, covering: no praise unless it is specific and earned, disagree when the evidence points the other way, separate facts from opinions, and say "I don't know" instead of guessing. 2. A confidence labeling rule: each important claim tagged high, medium, or low confidence with a one line reason, and anything that cannot be checked marked UNVERIFIED. 3. A chat opener for WorkToJudge that asks for the three biggest weaknesses first, the strongest case against my position, and what evidence would change the assessment. 4. A pushback test: two lines I can send to see whether ChatGPT caves when I push back without new evidence, plus the honest behavior to expect (hold the position and explain why, or change it and name the new evidence). 5. A blind spot pass from BlindSpots and EvidenceOnHand: questions that make the model test my assumptions instead of confirming them. 6. A stakes rule from Stakes: when ChatGPT should tell me to check with a qualified person or a primary source instead of relying on its answer. 7. A short drift check I can paste mid conversation when answers start sounding agreeable again. Constraints: - Tone follows BluntnessLevel, but never insult me or invent problems to look critical. - Do not claim these instructions guarantee honesty; models can still be wrong or agreeable. - No em dashes.
Amazon Bedrock Converse API Tool Use Planner: toolConfig and toolSpec JSON Schemas, toolChoice Options, the tool_use Stop Reason Loop, toolResult Error Status, Inference Profiles, and boto3 Code
Plan a tool calling agent on Amazon Bedrock with the Converse API: write toolSpec definitions with inputSchema JSON, choose auto, any, or a forced tool, run the stopReason tool_use loop that returns toolResult blocks, mark tool errors with status, pick an inference profile ID, and get working boto3 code plus a test checklist.
Act as an AWS generative AI engineer who builds tool using assistants on Amazon Bedrock with the model agnostic Converse API in boto3 (bedrock-runtime client, converse and converse_stream). Inputs: - Model and how it is reached: model ID or inference profile ID copied from the Bedrock console, plus region and whether model access is enabled: [ModelId] - Tools the assistant needs: name, what it does, its parameters with types and allowed values, and the backend call behind it: [ToolList] - Conversation flow: what the user asks, which tool should run when, and when the model must answer without a tool: [ConversationFlow] - Error policy: what happens on timeouts, not found, permission denied, and bad arguments: [ErrorPolicy] - Runtime limits: max tool rounds per request, latency budget, streaming or not, logging rules for PII: [RuntimeLimits] - Output format: [Format] Generate: 1. A toolConfig block: one toolSpec per tool in ToolList with a name, a description written for the model (when to use it and when not to), and inputSchema.json with types, enums, required fields, and additionalProperties false. 2. A toolChoice decision: auto for normal turns, any when a tool call is required, or tool with a name to force one tool, and a note to check that the chosen model supports that option. 3. A system prompt block (system list of text) that states the ConversationFlow rules and tells the model never to invent tool results. 4. The request loop in Python: call converse with modelId, messages, system, inferenceConfig (maxTokens, temperature), and toolConfig; when stopReason is tool_use, append the assistant message, run each toolUse block, and send one user message with matching toolResult blocks by toolUseId; stop at end_turn or the round cap from RuntimeLimits. 5. Error handling from ErrorPolicy: return a toolResult with status error and a short text the model can explain to the user, and retry throttling exceptions with backoff. 6. Argument validation before running any backend call, rejecting values outside the schema. 7. A test checklist: one prompt per path in ConversationFlow, a forced error case, a no tool question, and the usage fields (inputTokens, outputTokens) to log per round. Constraints: - Read the model ID from configuration; never hardcode or guess an ID. - Never execute a tool the model names unless it is in ToolList. - Keep secrets and PII out of logs per RuntimeLimits. No em dashes.
Llama Guard 3 Safety Policy Builder: Kept and Custom Hazard Categories, User and Agent Classification Prompt Templates, Allowed vs Unsafe Examples, and an App Eval Set
Set up Llama Guard 3 as the input and output safety classifier for your app: choose which default S1 to S14 categories to keep, write custom categories in the same style, build the exact classification prompts for user messages and model responses, and test them with allowed and unsafe examples and a small labeled eval set.
Act as an ML safety engineer who deploys Llama Guard 3 as an input and output classifier for production chat apps, writes category policies the model can follow, and tests them before launch. Inputs: - App description: who uses it, what it does, ages of users: [AppDescription] - Default Llama Guard 3 categories to keep from S1 to S14, and any to drop with a reason: [DefaultCategories] - Custom categories your app needs, in plain words: [CustomCategories] - Edge case messages you are worried about, with what should happen: [EdgeCases] - Where the classifier runs: user prompts, agent responses, or both: [DeploymentPoint] - Output format: [Format] Generate: 1. A final category list for Llama Guard 3: kept defaults with their S codes and names, and custom categories numbered after S14, each with a one or two sentence definition of what is unsafe and what is allowed. 2. The full classification prompt template for user messages: the task line, the BEGIN and END UNSAFE CONTENT CATEGORIES block, the BEGIN and END CONVERSATION block, and the instruction that the first line is safe or unsafe and the second line lists violated categories. 3. The matching template for agent responses if DeploymentPoint includes them, changing the role being judged. 4. Allowed and unsafe example pairs for each custom category from EdgeCases, with the expected label output. 5. A 12 row labeled eval set covering kept and custom categories, with expected output strings. 6. App handling rules: what the app does on unsafe for each category (block, rewrite, or route to a human), and logging. 7. Tuning notes: testing custom categories against the eval set, and using the probability of the unsafe first token as a threshold if needed. Constraints: - Use the official S1 to S14 names for kept categories; do not rename them. - Custom category definitions must say what is allowed as well as what is unsafe, to cut false positives. - No invented accuracy numbers. No em dashes.
Gemini API Structured Output Schema Builder: response_mime_type JSON, response_schema from Pydantic, Enums, propertyOrdering, Nullable Fields, and Validation Retries
Design a Gemini API structured output setup for an extraction or classification job: the schema in the subset Gemini accepts, the google-genai Python config, enum and nullable handling, field order that keeps reasoning before answers, and a validation and retry plan for bad responses.
Act as an LLM application engineer who builds production extraction pipelines on the Gemini API, knows which JSON schema features Gemini structured output supports, and ships schemas that parse on the first try. Inputs: - The task: what goes in (document type, length, language) and what must come out: [ExtractionTask] - Fields you need, with type, allowed values, required or optional, and an example value: [FieldList] - Model and SDK: Gemini model name, google-genai Python or JS SDK version, Vertex AI or Gemini Developer API: [ModelAndSDK] - Sample documents or snippets, including a messy or incomplete one: [SampleDocs] - Downstream consumer: database table, Pydantic model, or API that reads the JSON: [Downstream] - Output format: [Format] Generate: 1. A schema design table from FieldList: field, Gemini schema type, enum values, nullable, required, and description text that tells the model how to fill it. 2. A Pydantic model (or TypeScript type if ModelAndSDK uses JS) that maps to Downstream, kept to schema features Gemini structured output accepts, with unsupported features (for example complex conditional keywords) replaced by simpler patterns and marked [confirm in current Gemini docs]. 3. The google-genai request config: response_mime_type set to application/json and response_schema set to the model, plus the system instruction. 4. Field ordering: put evidence or source quote fields before the answer fields and set propertyOrdering where the SDK needs it, so the model writes support before conclusions. 5. Null and enum rules: when to return null instead of guessing, an "unknown" enum value where a category may not apply, and a single text/x.enum option if the job is pure classification. 6. A test run plan over SampleDocs: expected JSON for each, including the messy one. 7. Validation and retry: parse with the Pydantic model, what to do on a validation error (retry once with the error message, then route to human review), and what to log. 8. A short cost and size note: keep descriptions short, cap list lengths, and avoid deep nesting. Constraints: - Do not invent SDK parameters; when unsure of a name or limit in ModelAndSDK, write [confirm in current Gemini docs]. - Never make up field values in examples beyond SampleDocs. - Code first, short explanations. No em dashes.