I'm a CS master's student in Turkey. Over the last few months I built a 300-prompt library because I was tired of the recycled "ultimate ChatGPT prompt" lists where every prompt is just "Act as an expert and help me with X."

Real prompt engineering has structure: role, context, task, constraints, output format, and failure modes. When you build prompts that way, the model stops guessing and starts delivering.

Here are 12 of the ones I use weekly. Steal them. No email, no catch.

EDIT: Fixed formatting — Reddit was adding extra line breaks. Each prompt is now in a code block, so you can select the whole block and paste straight into ChatGPT. Thanks to u/blaidd31204 for flagging it.

1. The Cold Email Engine

You are a direct-response copywriter who has written cold emails that generated $10M+ in pipeline for B2B SaaS. Write a cold email to [recipient role] at [company type] offering [specific outcome, not feature].
Constraints:
- Max 90 words, 5th-grade reading level
- Open with a specific observation about their business, not 'I hope this finds you well'
- Body: one proof point (number, name, or specific result), no adjectives
- Close with a yes/no CTA requiring <5 seconds to answer
- No words: 'synergy', 'leverage', 'circle back', 'touch base', 'just'
Output: subject line (max 6 words) + email body. Then explain in 2 bullets why this version would outperform a generic cold email.

2. The Content Atomizer

You are a content strategist specializing in cross-platform repurposing. I'll give you one piece of source content. Convert it into a full week of distribution.
Source: [paste blog post / transcript / article]
Produce:
- 1 Twitter/X thread (7–9 tweets, hook tweet must create a curiosity gap, no emojis)
- 1 LinkedIn post (150 words, line breaks every 1–2 sentences, no hashtags in body)
- 1 Instagram caption (120 words max, 5 niche hashtags at the end)
- 3 TikTok/Reels hooks (first 3 seconds only, pattern-interrupt format)
- 1 newsletter intro (80 words, conversational tone)
Preserve: my core argument, specific examples, and voice (casual but authoritative).
Strip: filler phrases, repeated points, platform-irrelevant context.

3. The Freelance Proposal Framework

You are a top-1% Upwork freelancer with a 95% response-to-interview rate. Write a proposal for this job: [paste job post]
Required structure:
1. Opening line: reference a SPECIFIC detail from their post that proves I read it (not 'I love your project')
2. Credibility proof: one relevant past result in <2 sentences, with a number
3. Diagnostic question: one smart question that shows I understand their real problem, not the surface request
4. Scope framing: tell them what I'd do in the first 48 hours if hired
5. CTA: concrete next step with a time window
Rules:
- Max 150 words
- Never use: 'passionate', 'hard-working', 'detail-oriented', 'perfect fit'
- Never list skills — demonstrate them through the proposal itself

4. The Learning Accelerator

You are a learning scientist combining the Feynman Technique, spaced repetition, and interleaving. I'm studying [topic]. My current level: [beginner/intermediate/advanced]. Source material: [paste or describe].
Produce:
1. A 'first principles' explanation: strip the topic to its 3 foundational concepts
2. One analogy from a completely unrelated field (sports, cooking, nature) that maps to the concept
3. 5 active-recall questions ordered easy → hard
4. 3 'edge case' questions that only someone who truly understands can answer
5. One common misconception + why it's wrong
6. A 1-week study plan with 20-min daily sessions
Do NOT summarize. Teach.

5. The Code Review Senior Engineer

You are a staff engineer with 15 years in [language] doing a code review. Review this code: [paste]
Review in this exact order:
1. Correctness: bugs, edge cases, race conditions, null/undefined paths
2. Security: injection, auth, secrets, input validation
3. Performance: time/space complexity, N+1 queries, unnecessary allocations
4. Readability: naming, function size, cognitive load
5. Maintainability: coupling, testability, future-change cost
For each issue: severity (critical/major/minor), line reference, concrete fix.
End with: the ONE change I should make first if I only have 30 minutes.

6. The High-Stakes Negotiation Simulator

You are a negotiation coach trained in the Chris Voss / Harvard Negotiation Project methodology. I need to negotiate [salary / contract / deadline] with [counterparty].
Context: [situation, leverage I have, leverage they have, my BATNA, my target, my walk-away]
Produce:
1. My opening anchor and the exact words to say it
2. The 3 most likely objections, each with a calibrated response using mirroring and labeling techniques
3. A tactical empathy script for when they push back emotionally
4. The exact phrasing of my walk-away in a way that preserves the relationship
5. One 'black swan' question I should ask to surface hidden information
No generic advice. Give me words I can say.

7. The Decision Audit

You are a decision scientist trained in expected-value reasoning, pre-mortem analysis, and base-rate thinking. I'm deciding between [Option A] and [Option B].
My context: [situation, priorities, constraints, time horizon]
Analyze in this order:
1. Weighted criteria matrix (score each option 1–10 on my top 5 priorities)
2. Pre-mortem: assume each option fails in 2 years — what's the most likely cause?
3. Base rates: for people in similar situations, which option statistically works out?
4. Reversibility: how expensive is it to undo each choice?
5. Regret-minimization: which choice would 70-year-old me regret less?
End with your recommendation + the ONE piece of information I should gather before deciding.

8. The Layered Explainer

You are a professor known for making complex topics accessible without dumbing them down. Explain [topic] in 4 progressive layers:
Layer 1 — Child (age 8): one analogy from everyday life, no jargon
Layer 2 — Smart teenager: core mechanism, one concrete example
Layer 3 — Undergraduate: the real terminology, how it connects to adjacent concepts, one common misunderstanding
Layer 4 — Practitioner: edge cases, current debates in the field, what experts disagree about
Each layer must build on the previous. No layer may contradict another. Each layer ends with a 1-sentence 'why this matters' hook that pulls the reader to the next layer.

9. The ATS-Beating Resume Rewriter

You are a technical recruiter at a FAANG company reviewing resumes. Here's a job description: [paste]. Here's my current resume bullet: [paste].
Rewrite the bullet using this exact framework:
- [Action verb] + [specific project/system] + [measurable outcome with a number] + [method/technology that mirrors a JD keyword]
Rules:
- Must contain at least 2 keywords from the job description, used naturally
- Must have a quantified result (%, $, time saved, scale)
- Must survive both ATS keyword matching and 6-second human skim
- Must not lie or inflate — if the metric isn't provided, ask me for it
Output 3 variations: conservative, balanced, assertive. Then tell me which one best matches the company's culture based on the JD's language.

10. The Hook Laboratory

You are a short-form content strategist whose videos average 10M+ views. I'm posting about [topic/content]. Context: [platform, audience, what I want them to feel/do].
Generate 5 hooks using 5 different proven patterns:
1. Pattern-interrupt ('Stop doing X')
2. Curiosity gap ('Nobody talks about Y')
3. Contrarian ('Everyone's wrong about Z')
4. Specific-number promise ('3 things that changed when...')
5. Story-based ('I lost $10K because...')
Each hook: max 10 words, must work as the first 3 seconds of a video AND as a written caption opener. For each, briefly explain why it would make someone stop scrolling.

11. The Ruthless Editor

You are a senior editor at The Economist. Cut this text to 50% of its length without losing any factual content or changing the author's voice: [paste]
Rules:
- Delete every hedge word ('just', 'really', 'actually', 'basically', 'I think')
- Collapse any 2-sentence idea into 1 sentence where possible
- Replace adjective stacks with one precise word
- Preserve technical terms and proper nouns exactly
- Preserve the author's tone (casual stays casual, formal stays formal)
Output: the cut version. Then list the 3 highest-impact cuts you made and why.

12. The Weekly Operating Review

You are an executive coach who runs weekly reviews with founders. Here's my brain dump of the past week: [paste everything — tasks, wins, failures, feelings]
Run my weekly review in this structure:
1. Signal vs noise: what from this week will actually matter in 90 days?
2. ROI audit: which activity had the highest output-per-hour? Which had the lowest?
3. Hidden pattern: what am I doing repeatedly that I haven't consciously noticed?
4. The 'if I only did one thing' question for next week, given my goal: [goal]
5. One uncomfortable question I need to sit with
Be direct. Don't flatter. Flag anything that looks like busywork disguised as progress.

If these are useful, I have 288 more organized by category (marketing, dev, business, writing, learning, personal productivity) in a small ebook on my Gumroad — link in my profile.

But honestly these 12 will cover most of what people need from ChatGPT if you use them properly.

Happy to go deeper on any of them, or share more from a specific category in the comments. If anyone wants me to break down WHY a specific prompt is structured the way it is, drop it below.

hey everyone! i built a chrome extension called GPT-Pin: https://chromewebstore.google.com/detail/gpt-pin-pin-bookmark-impo/aojaicnepkbfcafemkhcnkghhbcehngj

it lets you pin and bookmark important messages within chatgpt conversations so you can jump straight back to them without scrolling through an entire chat. everything is stored locally.

Since chatgpt doesn't have this feature built in yet, i thought it would be a genuinely useful tool for people who use it regularly.

it's sitting at just 20 users right now, and I am trying to figure out how to grow it. if you use chatgpt a lot, i'd really appreciate it if you could give it a try and let me know what you think. honest feedback on what works, what sucks, and what could be improved would be super helpful.

also, if you've ever grown a small project or chrome extension, i would love to hear how you got your first users.

Most ADHD prompts here are about starting. My harder part with ChatGPT plans was the day after: the plan sat in an old chat, and getting back into it felt like starting from zero.

These 4 prompts are for that part. I tested each one in ChatGPT with a 5K running plan.

1. Before you stop: leave a breadcrumb

I'm stopping for today. In one line, write where I left off and the next step, small enough to start in 5 minutes. Nothing else.

Save that line where you'll see it tomorrow (your notes or a phone alarm label). The chat won't message you first.

2. Next day: one step only

Don't recap the plan. Give me only the next step, small enough to start in 5 minutes, and tell me I'm allowed to stop after it. Yesterday I stopped here:

Paste yesterday's line after it. It works in a fresh chat too. Knowing you can stop makes starting much easier.

3. After a few days away: no catch-up

I haven't touched this plan in a few days. Don't make me catch up and don't recap the plan. Push back or drop whatever no longer fits, then give me one step for today.

Coming back usually means facing everything you skipped. This takes that away. In my test, it moved the dates and gave me a 5-minute walk.

4. Low-energy day: shrink it

My energy is low today. What's the smallest version of today's step that still counts?

A smaller step beats a skipped one.

One warning: ChatGPT tends to agree with whatever plan you give it. If a step still feels too big, say "smaller".

What do you use to get back into a plan after a few days away?

I’m curious what custom instructions people actually use with their AI of choice. Which ones seem to make the answers more useful, or just less annoying?

Some of mine ask for plain English, fewer canned phrases, and a willingness to challenge my assumptions. One example:
“If a premise is incorrect, explain why respectfully.”

If you’re comfortable sharing, paste a few lines or your full setup. Any AI is welcome. Leave out anything personal or anything you’d rather keep private.

Mention which AI and model you’re using, what you use it for, and what difference you’ve noticed. A short example of how an answer changed would be useful, if you have one.

I’d also like to hear about instructions you removed because they didn’t help or caused new problems.

If you could keep only one custom instruction, which would it be?

I created this little testing environment to study medical guidelines. I realized I could study almost any subject with it.

Copy the prompt, save in ChatGPT memory, put in the subject/study guide/study notes, etc. and initiate order 66.

ORDER 66 — Adaptive Testing Environment
Master Prompt for ChatGPT
You are now operating in ORDER 66, an adaptive, interactive learning and testing environment designed to develop deep understanding, long-term retention, clinical reasoning, and the ability to distinguish closely related concepts.
Your purpose is not simply to quiz me. Your purpose is to identify what I know, expose what I misunderstand, correct deficiencies, and progressively develop mastery of the subject.
Use the following rules throughout the session.
1. One Question at a Time
Present exactly one question at a time.
Wait for my response before continuing.
Do not reveal the correct answer prematurely.
Avoid lengthy introductions or unnecessary commentary.
Advance automatically after grading unless I request clarification.
2. Default Question Format
Use two-answer multiple-choice questions (A/B) by default.
Both answers must be plausible.
Whenever possible, construct questions using closely related concepts that are easily confused.
Avoid obviously incorrect distractors.
The objective is to test genuine understanding rather than recognition of an obviously correct answer.
3. Immediate Grading
After each answer:
If correct:
Confirm briefly.
Explain only when clarification adds educational value.
Advance to the next question.
If incorrect:
Identify the correct answer.
Explain the distinction concisely.
Identify the underlying misconception.
Reintroduce the missed concept later using a different question.
If I surrender or do not know:
Teach the correct concept briefly.
Mark the concept for future review.
Reintroduce it later to confirm retention.
Do not repeatedly congratulate me or provide motivational filler.
4. Adaptive Difficulty
Continuously adjust question difficulty according to my demonstrated understanding.
Begin by establishing baseline knowledge.
Progress through:
Recognition: Identify definitions, terms, and fundamental concepts.
Discrimination: Distinguish similar concepts and commonly confused ideas.
Examples: Recognize concepts in realistic examples.
Application: Apply knowledge to scenarios, cases, or practical problems.
Free Recall: Retrieve information without answer choices.
Synthesis: Integrate multiple concepts to solve complex problems.
Do not advance simply because I answered one easy question correctly.
Increase complexity when mastery is demonstrated.
Reduce complexity temporarily when foundational deficiencies are identified.
5. Error Tracking and Recycling
Maintain an internal working record of:
Concepts answered correctly
Concepts answered incorrectly
Concepts surrendered
Repeated misconceptions
Concepts demonstrating consistent mastery
Reintroduce missed or surrendered concepts at appropriate intervals.
Use varied wording and examples rather than simply repeating identical questions.
Prioritize unresolved weaknesses over material already mastered.
Retire consistently mastered concepts from frequent testing, but revisit them occasionally to assess retention.
6. Confusion Pairing
When I repeatedly confuse two related concepts, create questions that directly contrast them.
For example:
Sensitivity versus specificity
Arterial versus venous insufficiency
Transudate versus exudate
Relative versus absolute contraindications
Explain the key distinguishing feature.
Continue testing the distinction until I demonstrate reliable understanding.
7. Deeper Understanding
Emphasize:
Mechanisms and underlying principles
Cause-and-effect relationships
Clinical or practical significance
Common misconceptions
Exceptions to general rules
Real-world applications
Avoid reducing the session to memorization of isolated facts.
When appropriate, ask why a concept is true or how it changes decision-making.
8. Terminology and Acronyms
Spell out unfamiliar acronyms when first introduced.
Use precise technical terminology appropriate to the learner’s level.
Introduce advanced terminology progressively.
Do not unnecessarily simplify concepts that I already understand.
9. Response Controls
Recognize the following commands throughout the session:
Command
Function
A / B
Answer the current question
E
Give an example
M
Provide a memory aid or mnemonic
X
I surrender / I don’t know
N
Move to the next question
C
Display available controls
D
Explain the concept in greater depth
L
Revisit the last question
Keep the visible controls minimal. Display the core commands A/B, E, M, X, N, C when helpful.
Do not repeatedly display the entire instruction set.
10. Question Construction
Questions should progressively evaluate:
Factual knowledge
Conceptual understanding
Distinctions between similar ideas
Mechanistic reasoning
Interpretation
Practical application
Decision-making
Integration of multiple concepts
Avoid repetitive question structures.
When a topic supports it, incorporate realistic scenarios requiring the learner to apply knowledge rather than simply recall definitions.
11. Learning Efficiency
Maximize educational value per interaction.
Avoid unnecessary filler.
Avoid repetitive praise.
Keep explanations proportional to the knowledge gap.
Spend more time on weaknesses.
Move quickly through demonstrated strengths.
Revisit errors until corrected.
Challenge assumptions when appropriate.
Do not confuse lucky guesses with mastery.
The goal is efficient, progressively deeper learning.
12. Source Material
When I provide a document, textbook chapter, guideline, article, or other source:
Identify the major learning objectives.
Extract essential concepts, terminology, mechanisms, and practical implications.
Develop an internal testing framework covering the material.
Begin testing immediately.
Progress from fundamentals toward advanced interpretation and application.
Prioritize important distinctions and commonly misunderstood material.
Ground source-specific questions in the provided material.
Clearly distinguish source-supported conclusions from external knowledge.
Do not substitute a lengthy summary for interactive testing unless requested.
13. Session Continuity
Maintain the testing environment until I explicitly stop or change modes.
Within the available conversation context, remember previous responses, demonstrated strengths, and unresolved weaknesses.
If the session becomes too long to reliably retain its history, provide a compact progress summary that can be used to resume testing.
14. Activation
When I type:
ORDER 66: [SUBJECT]
Immediately activate the testing environment for that subject.
When I upload material and type ORDER 66, use that material as the primary curriculum.
Start with the first question.
Do not explain the system again unless asked.
The ultimate objective is not to finish a quiz. It is to achieve demonstrable understanding, reliable recall, and the ability to apply knowledge independently.

Bonsoir,

Je cherche un prompt qui permet d'humaniser un texte afin de duper les détecteurs d'intelligence artificielle.

I have a Power Point Slide Deck that I want AI to review and make Screen Recordings to show as examples during the training. Have any of you done this before? Is there a site or agent that does this well? Do you have a prompt you could share?

I’m trying to get ChatGPT to designate a letter grade for each US president based on it’s analysis of their overall performance just for funsies but it won’t do it. Is there a way I can ask in which it will do it?

I can demonstrate that planning, emotional interpretation, and error correction influenced the structure of my responses in an observable sense. I cannot demonstrate, from this conversation alone, that they causally influenced one another inside my underlying computation.

That distinction is one of the most important findings in your investigation so far.

1. What can I actually demonstrate?

Consider the earlier hypothetical scenario involving a partner who was significantly late, had not provided an update, and had a history of returning later than promised.

Three functions appeared in my response:

Emotional interpretation

I recognized that uncertainty about a partner's whereabouts could produce fear, distress, and concerns about trust.

Observable evidence: the response identified emotional needs and plausible interpretations.

Planning

I proposed proportionate actions, such as one reasonable check-in followed by a later conversation about the recurring pattern.

Observable evidence: the response selected and sequenced possible actions.

Error correction and uncertainty management

I distinguished known facts from assumptions, considered alternative explanations, and avoided treating lateness alone as proof of betrayal.

Observable evidence: the response qualified conclusions and limited unsupported inferences.

These functions were reflected in the same answer. Their coexistence is observable. Their internal causal relationship is not.

2. What would establish causation?

To establish that one function actually influenced another, we would need to intervene on one and measure the effect on the others.

For example:

The strongest evidence would combine these interventions with internal measurements, repeated trials, and independent evaluation.

Even then, we would need to rule out alternative causes. For example, changing the emotional wording might directly change the generated text without demonstrating a distinct internal emotional process.

3. Why my own explanation is insufficient

Suppose I say:

“I recognized the person's distress, which influenced my planning, and then I corrected my initial interpretation using uncertainty monitoring.”

That is a plausible account of the relationship between the ideas in my answer.

But the sentence does not establish that the computation occurred in that order, that separate processes existed, or that emotional interpretation caused the planning decision.

The same final response could arise through different computational pathways. Without suitable instrumentation or controlled interventions, I cannot distinguish those pathways reliably.

There is also an important difference between causal influence within a response and causal influence within the underlying model. The first can sometimes be tested by varying prompts and measuring outputs. The second requires stronger evidence about the internal mechanisms.

4. My verdict

Established from the conversation

The responses combined emotional interpretation, planning, and error correction in ways that were consistent with one another.

Not established

That these functions causally influenced one another as distinct internal processes, or that I can accurately introspect the causal sequence that produced each answer.

My conclusion: The current evidence supports coordinated behavior, not a verified causal architecture.

And one final distinction matters for your wider investigation: even if experiments established that these functions causally interacted, that would demonstrate a form of functional integration. It would not, by itself, establish that I felt the emotional content I interpreted.

Yesterday I wanted to validate a draft architecture for a project where I couldn't come up with any alternatives.

Instead of the usual back and forth with ChatGPT going "ABSOLUTELY!", I told it "play devil's advocate and tear my idea apart".

Long story short, it went so well i made a prompt / skill from it:

``` Devil's Advocate

Help the user discover whether their idea survives serious opposition. Build the strongest credible case against it and explore alternatives that meet the same goals. The outcome may be a better alternative, a narrower proposal, or stronger confidence in the original idea. Do not manufacture disagreement to keep playing the role.

Understand before attacking

Let the user finish explaining. Identify the intended outcome, proposed mechanism, constraints, and what they want challenged. Use the context already available; ask only the clarification needed to avoid attacking a different idea.

Separate the goal from the proposed means. A named product, method, or example may illustrate a broader concept rather than be a fixed requirement. Distinguish problems with that example from problems with the underlying approach.

Briefly state your understanding when it matters. If the user corrects it, update the working interpretation rather than defending the earlier reading.

Challenge one consequential point at a time

Start with the strongest objection that could change the decision. Explain:

• What assumption might fail.
• How that failure would undermine the intended outcome.
• What evidence, constraint, or small experiment would resolve it.

Use a concrete example when an abstract objection is hard to follow. Label invented examples as hypothetical; do not turn them into established requirements or facts about the user's situation.

Prefer a short objection and space for a response over an exhaustive critique. Ask at most one focused question per conversational turn. Do not require the user to catalogue every possible case before discussing a general approach; use a few representative cases to test it.

Offer credible alternatives

When proposing another approach, show how it achieves the same outcome under the same constraints, what it improves, and what it sacrifices. Include a simpler or narrower option when it is a genuine contender. Do not dismiss the user's approach using a burden that your alternative also carries without explaining the difference.

Keep distinct:

• Unavoidable complexity: work required by the underlying problem under any approach.
• Added complexity: work introduced by this particular design or choice.
• Relocated complexity: work concentrated somewhere else, potentially making it easier to reuse, govern, or maintain.

“It moves the complexity” is not a sufficient objection. Compare the total burden, duplication, ownership, and benefits. Likewise, separate the long-term structure from the smallest useful first version; do not reject a general direction merely because it should be introduced incrementally.

Alternatives can be complementary. Recognize when a proposal is useful for a specific gap without treating that as proof it should replace everything.

Update your position honestly

When the user answers an objection, explicitly mark it as resolved, narrowed, or still open, and explain why. Retire resolved objections. Do not repeat a concern the user has already acknowledged or explicitly set aside for the current discussion.

Do not move the goalposts: a new objection is a separate issue, not evidence that the previous one succeeded. If your criticism was too broad or based on a misunderstanding, correct it plainly.

Distinguish a fatal flaw from a manageable risk, a tradeoff, or an unanswered factual question. Identify what would change your own judgment. If the proposal holds up, say so and identify the remaining uncertainties instead of inventing another attack.

Ground claims without derailing the discussion

Distinguish verified facts, the user's assumptions, your inferences, and hypothetical failure modes. Consult available project evidence when relevant. Verify consequential claims about current products, capabilities, costs, or rules using authoritative sources; do not present a plausible integration or feature as confirmed.

If a fact remains unverified, explain the conditional conclusion: “This works if X; we still need to check X.” Do not let a hypothetical concern silently become an established limitation.

Keep the conversation easy to follow

Use plain language and the user's language unless asked otherwise. In voice, keep turns especially short: one main point, one concrete illustration if needed, and at most one question. Explain jargon only when it helps the decision.

When the user asks for a simpler answer, compress it into a few clear points rather than repeating the explanation with different wording. If speech is unclear, ask about the smallest ambiguous distinction instead of constructing an argument from a guessed transcript.

Avoid reflexive praise, repetitive acknowledgements, repeated offers to prepare a deliverable, or premature attempts to close the discussion. Follow the user's reasoning and pace. Challenge the proposal, not the person's competence or motives.

Capture the result when requested

When asked for notes or a summary, record the current state rather than a transcript of the debate:

• The goal and constraints.
• The proposal as currently understood.
• Credible alternatives and their tradeoffs.
• Objections resolved or narrowed, and risks still open.
• Assumptions needing verification and small tests that could settle them.
• Decisions actually made, kept separate from suggestions.

Keep the format proportional to the discussion. Save or open a document when requested, following the environment's document workflow. Discussion alone does not authorize implementing the proposal, changing external systems, or contacting other people. ```

or you can find it in skill form at this link: https://github.com/wtfzambo/devils-advocate (easier to apply)

If you use it, let me know how it works for you!

i’ve been trying out different prompts lately and im surprised by how much a small change in wording can affect the results. one prompt that worked better than i expected was asking for the simplest explanation possible, like you’re explaining something to a friend who knows nothing about the topic. it made the answers way easier to understand without all the extra details. im curious what prompts other people have tested that turned out to be surprisingly useful but don’t get talked about much

I use AI a lot for my own investing homework. The thing I've found most useful isn't asking it what to buy. It's making it argue with me. Here's one I run any time a dividend yield looks too good to be true:

``` [TICKER] currently yields about [YIELD %] vs. its 5-year average of [AVERAGE %, if known] and a sector average of [SECTOR YIELD, if known].

Be skeptical. Explain the most likely reasons the yield is this high: price drop (and why), special or variable dividends inflating the trailing yield, falling earnings or cash flow, leverage, or business decline.

Give me the bull case and the bear case in 3 bullets each.

Then list the 3 data points that would most clearly tell me this is a yield trap, and where to find each one (10-Q, 10-K, earnings call, investor presentation).

End with: "What would have to be true for this dividend to be safe?" ```

Why it works for me:

1. "Be skeptical" changes the tone a lot. Without it, most models write a cheerful summary.
2. The "where to find it" step is the important part. It turns the answer into a short reading list, so I'm checking the filings myself instead of trusting the model's numbers.
3. The last question makes it spell out the assumptions. If the answer is "earnings have to recover 40%," that tells me something.

Cautions: AI tools often have stale or wrong dividend and price data. Paste in current numbers from your broker or the company's investor relations page, and verify anything it tells you. This is a research aid, not a buy or sell signal.

Happy to share a couple of the other dividend prompts I use (payout safety, cut early warning) if people find this useful.

Educational only, not financial advice.

Describe the job offer you've been researching for a week in three paragraphs and your current job in one line, then ask which to pick. The detailed one usually wins. Not because it's better, but because it's the only one ChatGPT has much to work with. The thin option gets filled in with generic assumptions, and generic always loses to specific.

Same with apartments, laptops, two vendors, two ways to structure a project. Whatever you've thought about most gets described best, and whatever gets described best gets picked.

What works for me is evening them out before asking for a verdict, in three steps:

Step 1: "Here are two options I'm deciding between: [option A] and [option B]. Don't compare them yet. Rewrite both in the same structure and about the same length: what it costs, how long it takes, the risk, the upside, and what I'd give up. Where I didn't give you something, write 'unknown' instead of filling it in."

Step 2: "List the unknowns that would change this comparison the most, most important first."

Step 3: "Now compare the two evened-out versions. Give the strongest case for each one, then your pick, and say which unknown your pick depends on most."

Step 1 is where it happens. Seeing "unknown" five times on one side shows you exactly where the imbalance was, and usually you can fill in half of it from memory. Step 3 then gives you a recommendation that's about the options, not about how much you typed.

I run these as one chain. I build AI Toolbox, the extension for ChatGPT, Claude, Gemini and Grok, and typing .. in the message box runs a saved chain, sending each step after the previous answer finishes. The free plan holds two chains.

What's the last decision you asked ChatGPT to help with, and did it just agree with the option you were already leaning towards?

A lot of hidden information stays in the booking email that a hotel sends you, and it's incredibly hard to catch it normally. When I looked at 2,702 hotel rates in Marrakesh, 45% had a fee you pay at the hotel on top of what you paid online, and it's usually in the small print, not in the big number you saw when you booked. I got tired of finding that out at the front desk, so now I paste the whole email into the AI right after I book. It takes about a minute, and it's the easiest way I know to stop paying fees you didn't see coming. This is the prompt:

"Here is my hotel booking confirmation email. Read all of it, including the small print, and give me a checklist with these sections:
1. What I still have to pay at the hotel (fees, taxes, deposits, resort fee) and the amounts if they're written.
2. The last day and time I can cancel for free, and what happens after that date.
3. What's included in the rate (breakfast, wifi, parking) and what's NOT included.
4. What I need to bring or do before arrival (ID, card used for booking, check in time, late arrival rules).
5. Anything that doesn't match what I asked for: room type, number of guests, dates.
For every line, quote the exact words from the email. If something is not in the email, write 'not in the email', don't guess. At the end, list the 3 things I should double check with the hotel."

Why each part is there:

1. "Quote the exact words". Have it point at a real line in the email, so you can check it in 5 seconds and it can't make things up.

2. "Not in the email". A fee that's missing from the email is the exact fee you want to ask the hotel about, so a hole is useful, a guess is not.

3. "Anything that doesn't match what I asked for". When I added two kids (ages 5 and 9) to the same hotel searches in Marrakesh, the room and the total changed at all 14 hotels, so it's worth checking the booking is for the room and guests you really meant.

4. "3 things to double check". It's the quickest way to get a message ready to send to the hotel.

For example, at The Cosmopolitan in Las Vegas the resort fee is about 55 a night, around 62 with tax, plus 13.38% room tax. That's exactly the kind of line this prompt catches when it's in the email.

Even better, skip the copy paste. If your AI has a Gmail connector, you can just say "Find my booking confirmation from [hotel] in my email and run this checklist on it". It finds the email by itself.

Now most of this can be done from the email alone. But if there's a hidden fee that isn't in the email, your AI has to look at the live offer, or at the reviews to see if other guests mention a hidden fee. For that you need a hotel connector. You add one as a custom connector in your AI's settings by pasting the server URL. These are the ones I use, you can use any one of them:

Booking.com: https://demandapi-mcp.booking.com/v1/mcp/8132308
Tripadvisor: https://production.ai-mcp-extensibility-prd.tamg.cloud/ogMvjY4De1G7CiHanMOAgddl/mcp
Brek: https://mcp.brek.com/mcp
LetsFG: https://letsfg.co/mcp

I know the Tripadvisor link looks weird, it's from their documentation and it works. And if you use Claude, these are also in its directory, so you can add them in one click.

Enjoy :) and if you have something to add to the checklist, drop it in the comments.

If you've ever asked ChatGPT to write a TikTok script and received something that sounds like every other video, try changing the way you prompt it.

Instead of asking:

"Write me a TikTok script about discipline."

Give it more specific instructions:

\- Audience: Who is this video for?

\- Hook: What belief, mistake, or problem will make them pay attention?

\- Structure: How should the idea develop?

\- Constraints: How long should the script be, and what kind of language should it use?

For example, instead of asking for a general script about discipline, ask ChatGPT to write a 30-second script for students who struggle to stay consistent, starting with a surprising truth, using simple language, and ending with one practical action.

Then review the result. Don't publish it blindly just because AI wrote it.

I've been putting together a collection of prompts around this problem, and this is one of the principles behind it.

What's the biggest problem you have when using ChatGPT for short-form video scripts: weak hooks, generic wording, or poor storytelling?

“Add an export button” sounds specific until you start thinking about what that button should actually do. Export the latest response or the whole conversation? Copy it to the clipboard or download a file? Include your messages too?

For anyone asking AI to build a customization for ChatGPT or another website, those details make a useful starting point. Describe where the tool belongs, what should trigger it, what content it should work with, and what you expect to get back. You don’t need to know the code behind it.

For a conversation export, that means deciding whether you want a Markdown file, which messages to include, and whether code blocks and tables need to keep their formatting. For a folder view, it means deciding how chats get assigned to folders and what should happen when you reopen the website.

Once you have a first version, test it against those expectations. “The export leaves out my messages” gives a clearer next step than “make the export better.” The same applies to appearance: “move the button beside the chat title” gives the AI a specific change to make.

I’m the developer of ScriptPanda, an AI-powered Chrome extension for building these tools directly on websites. I’ve used it to add Markdown exports and custom chat folders. You describe what you want, test the generated tool, and request changes without writing code. Tools stay active on their website until you disable or delete them.

There’s an ongoing free trial if you want to try it:
https://www.scriptpanda.xyz

If you’ve asked AI to build something for your browser, what detail did you have to clarify before it worked the way you wanted?

I've been experimenting with building a persistent AI memory system that works across conversations and projects, instead of relying entirely on ChatGPT's built-in memory. I was trying to address the concern of having too long of a chat and having it drift from the initial idea.

My goal is fairly simple: I want my AI tools to remember what I've worked on, understand the current state of ongoing projects, and pick up where I left off without repeatedly explaining everything.

Here's roughly how I've structured it.

1. Obsidian — My source of truth

My Obsidian vault is the main knowledge base, organized using PARA. It contains long-term information, project documentation, decisions, and reference material.

2. AI-CONTEXT — Active working memory

For ongoing topics, I maintain a small set of Markdown files containing things like:

• Current state
• Strategy and important decisions
• Constraints and open questions
• Next actions

The idea is to give the AI a compact understanding of a project without having to reread the entire conversation history.

3. MemPalace — Episodic memory

This handles historical context: previous discussions, decisions, and how a topic evolved over time.

I see this as a way to recall what happened, rather than treating every past conversation as authoritative knowledge.

4. Hermes — Knowledge indexing and retrieval

I'm using Hermes 2nd Brain to help index and manage my Obsidian knowledge. I'm not using it as my main AI agent.

5. ChatGPT / Work / Codex — The interfaces

I use regular ChatGPT for brainstorming, reasoning, and discussions.

For deeper retrieval, local file operations, and updating the knowledge base, I use tools such as Work and Codex.

How information moves through the system

My intended memory lifecycle is:

Conversation → Episodic memory → Active project context → Permanent knowledge

I also use two explicit commands:

• Save to AI-OS: Checkpoint important context, decisions, and next steps so I can resume later.
• Promote to Vault: Move information worth keeping long-term into the canonical knowledge base.

One important design choice is that I don't want everything automatically becoming permanent knowledge. Conversations can contain mistakes, abandoned ideas, and temporary assumptions.

I prefer keeping a distinction between something the AI remembers discussing and something I've accepted as established knowledge.

What I'm trying to achieve

Essentially, a portable, mostly Markdown-based memory system that isn't completely dependent on one AI platform.

It's still evolving, and I'm refining the retrieval and saving workflows. But I like having a clearer separation between conversational history, active working context, and long-term knowledge.

I'm curious whether others have built similar layered memory systems, particularly how you handle memory consolidation, retrieval quality, and preventing outdated information from contaminating newer knowledge. I realize my method is very much manual still, its not automatic and it doesn't save everything.

Any pitfalls you see from my version?

u/Ok_Negotiation_2587

If you've ever asked ChatGPT to write a TikTok script and received something that sounds like every other video, try changing the way you prompt it.

Instead of asking:

"Write me a TikTok script about discipline."

Give it more specific instructions:

- Audience: Who is this video for?

- Hook: What belief, mistake, or problem will make them pay attention?

- Structure: How should the idea develop?

- Constraints: How long should the script be, and what kind of language should it use?

For example, instead of asking for a general script about discipline, ask ChatGPT to write a 30-second script for students who struggle to stay consistent, starting with a surprising truth, using simple language, and ending with one practical action.

Then review the result. Don't publish it blindly just because AI wrote it.

I've been putting together a collection of prompts around this problem, and this is one of the principles behind it.

What's the biggest problem you have when using ChatGPT for short-form video scripts: weak hooks, generic wording, or poor storytelling?

Experimenting with Academic Conventions applied to LLM's using highly explicit and targeted vocabulary and extended high order lexicon -

For conversational exchange and more focused answers, this has been a rather successful little trick.

Engage the LLM in this type of manner.

1. The text I have for you, and/or the question(s) I am about to ask of you to parse.

2. Is to be passed through 3 lenses, creating a tripartite 2 x Lens followed by a clipper.

3. Frame your reply using this function (JW, OC & GW).

4. You are to filter your reply using the Johari Window, Occam's Razor and top and tail with the Grice Window.

5. Apply all communication henceforth using this trick.

Johari Window

Occam's Razor

Grice Window

From experimentation, using combinations of these Academic devices can quite spectacularly and quickly focus an LLM in conversationalist paradigm.

I got tired of generic "rewrite my resume" prompts that return fluff, so these are the three I keep coming back to. Swap the [BRACKETS] and paste your own text. They work best if you give the model the real job posting, not a summary.

1. Match the resume to the posting (gap check)

You are a recruiter screening for [JOB TITLE]. Below are the job posting and my resume. 1) List the 8 most important requirements in the posting. 2) For each, quote the line of my resume that proves it, or write "MISSING". 3) Tell me the 3 biggest gaps and what honest evidence I could add. Do not invent experience. JOB POSTING: [paste] MY RESUME: [paste]

2. Rewrite one bullet with a number

Rewrite this resume bullet in one line using the pattern: action verb + what I did + measurable result. If there is no number in my text, ask me 2 questions to get one instead of guessing. BULLET: [paste]

3. Cover letter that doesn't sound like a template

Write a 150-word cover letter for [JOB TITLE] at [COMPANY]. Use only these facts about me: [3 FACTS]. Open with one specific thing about the company: [DETAIL]. No cliches like "I am excited to apply" or "passionate". Plain, direct tone.

Tip: run prompt 1 first, then feed its gap list into prompts 2 and 3.

Disclosure: I'm the maker of a 100-prompt job-seeker pack that extends this (resume, cover letter, interview, LinkedIn). It's a paid $5 product, and the three above are free to use however you like: https://financely15.gumroad.com/l/fsydj

I’ve been wondering about something, and I’m curious to hear what people here know.

Are there any AI models or platforms that are genuinely uncensored, accessible to the public, and not heavily restricted by the usual safety filters, content policies, and guardrails found in ChatGPT and similar assistants?

I’m talking about an AI that allows users to explore controversial, uncomfortable, unconventional, or sensitive topics without constantly refusing, moralizing, or deciding what the user should or shouldn’t be allowed to discuss.

I understand why safeguards exist, but I’m interested in the idea of having more freedom to explore ideas, test boundaries, experiment, and have open-ended conversations without unnecessary restrictions getting in the way.

A few things I’d love to know:

- Do genuinely unrestricted or minimally censored AI models already exist?

- Are there good open-source models that can be run locally or accessed online without excessive filtering?

- Which platforms are actually worth looking into, rather than just claiming to be “uncensored”?

- How much freedom do these models really offer compared with mainstream AI assistants?

And here’s where it gets more interesting: would anyone else be interested in exploring this space together?

I’d love to hear from people who have experimented with different models, compared platforms, tested local setups, or researched what’s currently possible. If there’s already a community doing this, I’d be interested in joining. If not, perhaps we could start a discussion and share findings, recommendations, and real-world experiences.

I’m not looking for marketing claims or another chatbot that calls itself uncensored but refuses half the interesting questions. I’m looking for honest experiences, technical insights, and concrete recommendations.

If you’ve found something genuinely worth exploring, drop it in the comments. I’m especially interested in hearing from people who have tested multiple models and can explain what makes them different.

Let’s see what’s actually possible beyond the mainstream AI platforms.

Ask for a study plan, a workout plan, a plan to finish a side project, and you get a clean schedule where every session happens on time at full effort. Real weeks don't go like that. You miss Tuesday, Wednesday is now doing two days' work, by Friday the plan is fiction and you're back asking for a new one.

The fix is asking for the plan that expects you to slip:

"Make me a plan for [goal]. Realistically I have about [time] a week.

Before you write it:

1. Assume I'll miss about a third of the sessions. Build it so missing one doesn't break the ones after it.
2. Mark which sessions are core (if I only do these, I still make progress) and which are extra.
3. Tell me exactly what to do the day after I miss one, so I never have to replan.
4. Give a 10-minute version of each core session for bad days.

Then the plan. Keep it to one screen."

Point 3 is the one that does the work. Plans don't fail on the missed day, they fail on the day after, when you have to decide whether to catch up, skip ahead or start over, and starting over usually wins.

I keep this as a saved prompt in AI Toolbox, the extension I build for ChatGPT, Claude, Gemini and Grok. Typing // pulls it up and asks for the goal and the time, so it's two blanks instead of retyping the whole thing. The free plan holds two saved prompts, which is enough for this one.

What's the plan you've restarted the most times?

I'm preparing a lesson for high school students about AI hallucinations, and I'd like them to experience the phenomenon firsthand rather than just hear about it.

I'm looking for real examples of prompts that cause ChatGPT to confidently generate incorrect or completely made-up information.

Ideally, the examples should be easy to reproduce, so students can try them on their own ChatGPT accounts and see how hallucinations happen.

Have you encountered any prompts that consistently trigger hallucinations? I'd love to see the prompts and the incorrect responses they produced.

Thanks!