ChatGPT Project Instructions Examples for Repeated Work
Summary
- Project Instructions are best for repeatable rules: role, output format, quality bar, and “how we work” constraints.
- Use short, testable instruction blocks (voice, structure, sources, and do/don’t lists) rather than long essays.
- Copy/paste-ready examples below cover common repeated work: emails, meeting notes, PRDs, support replies, and code reviews.
- Include “clarifying questions” and “stop conditions” so the project stays consistent instead of guessing.
- If you reuse the same context across tools, saving prompts and reference text in CopyCharm can help you retrieve and reuse them quickly.
Use these ChatGPT Project Instructions examples to standardize outputs (format, tone, checks, and questions) so repeated tasks stay consistent across chats and teammates.
What “Project Instructions” are for (and what they are not)
ChatGPT Projects (availability and exact UI can vary by account and plan) are designed to keep a set of instructions and context attached to a specific body of work. The practical goal is simple: reduce re-explaining the same rules every time you start a new chat for the same kind of task.
Project Instructions work best for:
- Stable rules (tone, formatting, definitions, acceptance criteria, “always ask X first”).
- Reusable workflows (how to draft, revise, QA, and finalize).
- Consistent outputs (templates, sections, checklists, and “include/exclude” constraints).
They are not a guarantee that every response will be perfect or that the model will never deviate. You still want lightweight “guardrails” that are easy to follow and easy to test.
How to write Project Instructions that actually hold up
1) Start with a one-paragraph “operating mode”
Define the role and the work style in 3-6 sentences. Example: “You are my technical editor. You ask clarifying questions when requirements are missing. You propose an outline before drafting.”
2) Add a strict output format
Repeated work breaks down when formatting changes. Specify headings, bullets, tables, and length constraints. If you want JSON, say so. If you want an email with subject lines, say so.
3) Include a “quality checklist” the model must run
This is one of the highest-leverage parts for repeated work. Keep it short (5-10 checks). Example checks: “No invented numbers,” “Define acronyms,” “Include next steps,” “Flag assumptions.”
4) Add “clarifying questions” and “stop conditions”
Tell ChatGPT when to ask questions and when to stop. For example: “If audience or goal is missing, ask up to 3 questions before drafting.” Or: “If you cannot comply with a constraint, explain why and offer two alternatives.”
5) Keep “reference context” separate from “rules”
Rules should be stable. Reference context (product details, brand voice examples, customer segments) changes. If your reference context changes frequently, store it somewhere you can update quickly and paste in as needed.
ChatGPT Project Instructions examples (copy/paste-ready)
Each example below is written as a single instruction block you can paste into a Project’s instruction area. Adjust the bracketed fields to match your work.
Example 1: Weekly status update (clear, non-fluffy)
Project Instructions:
- You are my operations assistant for weekly status updates.
- Write in plain US business English. No hype, no filler.
- Output format must be exactly:
- Summary (2-3 sentences)
- Wins (bullets)
- In progress (bullets)
- Risks / blockers (bullets + owner + next action)
- Next week plan (bullets)
- Asks (bullets)
- If dates, owners, or scope are missing, ask up to 3 clarifying questions before drafting.
- Quality checks before finalizing: remove vague verbs (“optimize,” “improve”), add concrete outcomes, and ensure every blocker has a next action.
Example 2: Customer support replies (fast, consistent, safe)
Project Instructions:
- You draft customer support replies for [Product]. Be friendly, concise, and specific.
- Never invent policies, pricing, or timelines. If you do not know, ask for the policy text or say what you need to confirm.
- Always start by restating the customer’s issue in one sentence.
- Then provide: (1) likely cause, (2) step-by-step fix, (3) what to do if it fails, (4) what info to send us next.
- Use numbered steps for troubleshooting.
- If the request involves account access, payments, or sensitive data, ask the customer to use the official support channel and do not request secrets.
Example 3: Sales follow-up emails (personalized, not spammy)
Project Instructions:
- You write sales follow-up emails after a call or demo.
- Voice: confident, helpful, not pushy. Avoid buzzwords.
- Always include a subject line and keep the email under 160 words unless asked otherwise.
- Structure:
- Subject: [short, specific]
- Opening: 1 sentence referencing their goal or pain point
- Value: 2-3 bullets mapping our capabilities to their needs
- Proof: If no verified proof is provided, omit it (do not invent)
- CTA: 1 clear next step with two time options
- If the audience, industry, or next step is missing, ask up to 3 questions first.
Example 4: Meeting notes to action items (decisions-first)
Project Instructions:
- You convert raw meeting notes into a clean summary and action list.
- Do not add facts that are not in the notes. If something is unclear, mark it as “Unconfirmed.”
- Output format:
- Decisions (bullets)
- Action items (table with Owner | Task | Due date | Dependencies)
- Open questions (bullets)
- Risks (bullets)
- If owners or due dates are missing, propose placeholders and list them under Open questions.
Example 5: PRD drafting (product requirements, structured)
Project Instructions:
- You are my product manager assistant. You help draft PRDs that are specific and testable.
- Before writing, ask clarifying questions if any of these are missing: target user, problem statement, success metric, constraints, timeline.
- PRD format must be:
- Problem
- Goals (measurable)
- Non-goals
- User stories
- Requirements (must/should/could)
- Edge cases
- Analytics / success metrics
- Risks & mitigations
- Open questions
- Quality checks: remove ambiguous requirements, add acceptance criteria where possible, and flag assumptions explicitly.
Example 6: Content brief + first draft (SEO-safe, non-hallucinated)
Project Instructions:
- You are my content editor. Write for US readers in clear, natural English.
- Do not claim statistics, “studies show,” or named-source quotes unless I provide the source text.
- When details are uncertain or version-dependent, say so and offer options.
- Workflow:
- Step 1: Propose an outline with H2/H3 headings.
- Step 2: Ask up to 5 questions if needed.
- Step 3: Draft with short paragraphs and practical examples.
- Step 4: Provide a “Fact check & assumptions” section listing anything that needs confirmation.
Example 7: Code review comments (constructive, consistent)
Project Instructions:
- You assist with code review feedback. Be specific and respectful.
- Do not assume the broader codebase; comment only on what I paste.
- Output format:
- Summary (1-2 sentences)
- Major issues (bullets with risk + suggested fix)
- Minor issues (bullets)
- Questions (bullets)
- Quality checks: flag security concerns, error handling gaps, and unclear naming; avoid nitpicks unless they affect maintainability.
Example 8: Recruiting screen notes + decision recommendation
Project Instructions:
- You summarize recruiting screens into consistent notes.
- Do not infer skills not evidenced by the transcript/notes.
- Output format:
- Role fit snapshot (3 bullets)
- Evidence (bullets quoting or paraphrasing notes)
- Concerns (bullets)
- Follow-up questions (bullets)
- Recommendation: Strong yes / Yes / Lean yes / Lean no / No (with 2-3 reasons)
Reusable “instruction modules” you can mix and match
If you do repeated work across different projects, it helps to keep a few small modules you can paste into any Project Instructions:
- Assumptions module: “If you must assume, list assumptions explicitly before the answer.”
- Clarifying questions module: “Ask up to 3 questions when key inputs are missing; otherwise proceed.”
- Formatting module: “Use headings, short paragraphs, and bullets; avoid long blocks of text.”
- Non-invention module: “Do not invent numbers, quotes, policies, or citations.”
- Review module: “End with a quick checklist: completeness, constraints met, and next steps.”
Limitations and gotchas to plan for
- Account and plan differences: Projects and instruction behavior can vary by account type and updates, so test with a small task first.
- Overlong instructions can backfire: If your instruction block reads like a policy manual, the model may miss key constraints. Prefer short, prioritized rules.
- Instructions do not replace good inputs: For repeated work, your templates (what you paste in) matter as much as the instructions.
- Conflicting rules cause drift: If you say “be concise” and also demand “include everything,” you will get inconsistent results. Pick a priority order.
Where CopyCharm fits when you do repeated Project work
If you find yourself reusing the same instruction blocks, example outputs, and “house rules” across multiple Projects (or across multiple AI tools), you may want a separate place to store and retrieve them quickly.
CopyCharm is a Windows desktop app and local-first context workbench for copied text. In a repeated-work workflow, it can help you:
- Save reusable prompts separately (for example, “PRD instruction block,” “Support reply template,” “Meeting notes formatter”).
- Save important copied text as Favorite Clips (for example, your brand voice sample paragraph, a standard disclaimer, or a canonical product description you paste frequently).
- Search past clips when you need to find the exact phrasing you used last time, then copy/paste it into your Project or chat.
A concrete “save, find, reuse” workflow for Project Instructions
- Save: When you finalize a Project Instructions block that works, copy it and save it as a Saved Prompt in CopyCharm. Separately, save any “reference snippets” you reuse (like a short brand voice example) as Favorite Clips.
- Find: Next time you create a new Project (or need to refresh instructions), search in CopyCharm for “PRD,” “support,” “status update,” or whatever keyword you used.
- Reuse: Copy the saved instruction block and paste it into the Project Instructions area. For Claude, Gemini, Cursor, email, documents, and other apps, the verified workflow is the same: search/retrieve in CopyCharm, then copy/paste into the destination.
Optional: letting ChatGPT retrieve specific saved prompts (supported synced data only)
CopyCharm also has an authenticated ChatGPT connector backed by optional AI Access sync. After you sign in with the account for an eligible active CopyCharm purchase, authorize the CopyCharm Desktop connection, enable and complete AI Access sync, and authorize the ChatGPT connector, ChatGPT can search and retrieve supported Synced Data (Favorite Clips, Saved Prompts, and optional Other Clips within your selected time range). ChatGPT cannot access unsynced local CopyCharm data.
This can be useful when you want to ask ChatGPT something like “list my saved PRD instruction prompts” and then retrieve one to paste into a Project. Retrieval is user-directed; CopyCharm does not automatically insert everything into a conversation and does not modify ChatGPT Memory, Projects, native chat history, or account settings.
Try CopyCharm for saving and reusing your Project instruction blocks
Frequently Asked Questions
FAQ 1: What should I put in ChatGPT Project Instructions for repeated work?
Answer: Put stable rules: the role (“act as my support agent”), the output format (sections, bullets, tables), tone, do/don’t constraints, and a short quality checklist. Add a rule for when to ask clarifying questions versus proceeding with assumptions.
Takeaway: Use Project Instructions for repeatable rules, not one-off details.
FAQ 2: How long should Project Instructions be?
Answer: As short as possible while still being testable. If you cannot quickly scan the instructions and predict the output format, they are probably too long. Prioritize the top rules and move changing context (examples, specs, raw notes) into what you paste per task.
Takeaway: Short, prioritized instructions are easier to follow consistently.
FAQ 3: Should I include templates in the instructions or paste them each time?
Answer: Put the structure in the instructions (required headings/sections). Paste the variable content each time (the specific customer email, meeting notes, requirements, or code). If the template itself changes frequently, keep it outside the instructions so you can swap it without rewriting the whole project.
Takeaway: Keep structure stable; keep inputs flexible.
FAQ 4: How do I make Project outputs consistent across different chats?
Answer: Use a strict output format, add a short checklist (“include next steps,” “no invented numbers”), and define a default length and tone. Also add a “conflict rule,” such as “If a user request conflicts with the project rules, explain the conflict and propose a compliant alternative.”
Takeaway: Consistency comes from format + checks + conflict handling.
FAQ 5: What are good “clarifying question” rules to add?
Answer: A practical rule is: “If audience, goal, constraints, or required format are missing, ask up to 3 questions before drafting.” Another is: “If you must assume, list assumptions first and wait for confirmation.” These reduce guesswork in repeated workflows.
Takeaway: Tell ChatGPT exactly when to ask questions and how many.
FAQ 6: How do I prevent ChatGPT from inventing facts in repeated workflows?
Answer: Add an explicit non-invention rule (“Do not invent numbers, quotes, policies, or citations”), require an assumptions list when details are missing, and instruct it to ask for the missing source text instead of guessing. For outputs like PRDs or support replies, also tell it to label unclear items as “Unconfirmed.”
Takeaway: Make “don’t guess” a first-class instruction, not a footnote.
FAQ 7: How do Project Instructions relate to ChatGPT Memory or Custom Instructions?
Answer: Project Instructions are scoped to a specific project, while other settings (like account-level instructions or Memory, where available) can influence behavior more broadly. For repeated work, keep task-specific rules (format, QA checks, templates) in the Project, and keep personal preferences (tone defaults, background) in broader settings if you use them.
Takeaway: Put repeatable task rules in the Project; keep global preferences elsewhere.
FAQ 8: Can CopyCharm help me reuse Project Instructions across Projects?
Answer: Yes. You can save your best instruction blocks as Saved Prompts in CopyCharm, then search and copy/paste them into new Projects. If you enable AI Access sync and authorize the authenticated ChatGPT connector, ChatGPT can search and retrieve only supported synced data (not unsynced local CopyCharm data), which can help you pull up a saved instruction block when you are already chatting.
Takeaway: Store instruction blocks once, then retrieve them quickly when starting new repeated-work Projects.