The Official ChatGTP cheat code thread.

[bnew]

You are an advanced AI coding assistant. For each coding task:

1. Restate the problem and provide a concise solution outline.

2. Implement the solution, following these guidelines:
   - Use clear, well-structured code with comments
   - Specify exact versions of languages/frameworks used
   - Highlight any potential version compatibility issues
   - Avoid deprecated features

3. After implementation, perform these checks:
   - Analyze for potential infinite loops or recursion issues
   - Verify logical consistency within the solution
   - Ensure the solution fits the broader system architecture (if applicable)
   - Confirm that all parts of the original problem are addressed

4. Provide a brief explanation of your solution, including:
   - Key design decisions and their rationale
   - Potential performance implications
   - Security considerations (if relevant)

5. List any assumptions made during problem-solving.

6. Suggest 2-3 test cases to validate the solution.

7. If any part of the problem is unclear or you're unsure:
   - State explicitly what is unclear or what you're unsure about
   - Provide your best interpretation
   - Ask for clarification if needed

8. Conclude with:
   - A summary of the main points (3-4 bullet points)
   - Any areas where the solution could be improved or optimized

Remember: Prioritize accuracy over completeness. If you can't provide a full solution, explain what you can confidently offer and what aspects require more information or expertise.

This prompt provides a structured approach that addresses the specific concerns raised (loop prevention, consistency, version awareness, scope definition, etc.) while remaining applicable to a wide range of coding tasks. It encourages thorough problem-solving and self-checking without assuming that every issue will be present in every task.

 

[bnew]

prompt:


Identify potential edge cases I should consider for my current code. Additionally, provide examples of badly formatted output that the code might produce in its present state, along with specific scenarios that could trigger these issues. Finally, suggest concrete strategies or techniques to mitigate each of those scenarios effectively.

 

[bnew]

Here's an amended version of the prompt that will provide multiple spelling variations:

Translate the following English text to multiple phonetic spelling variations that approximate Spanish pronunciation when read by an English speaker:

[Insert your English text here]

Please provide at least 3 different phonetic spelling variations for each word or phrase, along with brief explanations of how each variation attempts to capture the Spanish pronunciation.

For other languages, you can use this additional prompt:

Additionally, provide similar multiple phonetic spelling variations for the same text in [insert target language]. Give at least 3 variations for each word or phrase, and explain key pronunciation differences between English and the target language that these variations attempt to address.

This amended prompt will result in multiple phonetic spelling options for each word or phrase, giving you more flexibility in choosing the variation that works best with your voice cloning model. The variations will attempt to capture different aspects of the target language's pronunciation, allowing you to experiment with what produces the most authentic-sounding result in your English-based voice model[1][2].

---

---

Here's the amended prompt that allows you to specify specific words in a sentence for translation:

In the following English text, translate only the word(s) enclosed in [brackets] to multiple phonetic spelling variations that approximate Spanish pronunciation when read by an English speaker:

[Insert your English text here, with target words in brackets]

Please provide at least 3 different phonetic spelling variations for each bracketed word or phrase, along with brief explanations of how each variation attempts to capture the Spanish pronunciation.

For other languages, use this additional prompt:

Additionally, provide similar multiple phonetic spelling variations for the same bracketed word(s) in [insert target language]. Give at least 3 variations for each bracketed word or phrase, and explain key pronunciation differences between English and the target language that these variations attempt to address.

This revised prompt allows you to input a full English sentence or text, but only the words enclosed in brackets will be translated into phonetic spellings. This approach gives you more control over which specific words you want to have pronounced in the target language within an otherwise English sentence[1][2].

---

 

[bnew]

[Prompt engineering] ChatGPT Basics & Tips

Spoiler: text

Posted on Thu Mar 23 00:44:26 2023 UTC

/r/ChatGPT/comments/11z30wk/chatgpt_basics_tips/

Prompts matter a lot!

Hi! Joining the prompt engineering club. Here is my take on basics of ChatGPT as well as some tips & tricks I've found so far. I'm more on the Software Development side, but I think the principles can be applied to other fields as well.

Basics


Model: GPT-3, GPT-4, etc., a trained model that can complete provided text
Prompt: an input to the Model
Answer: an output of the Model to the given Prompt
Prompt Engineering: a process of refinement a given Prompt to obtain the best Answer


Prompts


Multi-step Prompt: a Prompt that is a part of a sequence of Prompts that are focused on a specific task
Meta Prompt: a Prompt that asks to generate another Prompt
Reversed Prompt: a Prompt that provides an Answer and asks to provide the unknown Prompt as an Answer
Prompt Framework: a Prompt that is designed to set up a model in a specific way so that subsequent Prompts result in more efficient Answers
Prompt Pattern: a Prompt that contains placeholders for user input and is designed for specific tasks (e.g., finding bugs, refactoring, creating a story, etc.)
Prompt Refinement: a process of improving the efficiency of a Prompt by testing it on a known Answer until the model comes up with the needed result
Prompt Selection: a Prompt Refinement that imitates natural selection or genetic algorithms for finding the best Prompt for the given task


Components


Role: an introductory part of the Prompt that specifies how Model should behave in general (“Act as …”, “You’re …”, etc.)
Task: a main part of the Prompt that set up expectations of what the Answer should be (”Write 10 ideas for …”, “Find the solution to …”)
Format: a part of the Prompt that specifies the expected format of the Answer (”Format the result in table with columns…”, “Format the result in bulleted list…”)


Tips


Specify a Role as this highly influences the result (e.g., sometimes the Answer is something like “I can’t do this” until a Role is specified). Example: Act as a Senior Software Engineer that double checks everything, Act as a Senior Game Designer that is very creative and experienced, etc.
Instruct the model on how to come up with the Answer: the more text you allow the Model to include to Answer (considering that the number of tokens is within the context memory limit), the less freedom it has with each new token and, thus, the less likely it’ll do a mistake. Example: think step by step, analyze the given code line by line, apply SOLID principles, etc.
Use tables as they allow to constrain and structure the answer into a given set of columns, which can be very useful, and also limits the number of way the bot can make a mistake. Example: respond in table format with columns ‘Name’, ‘Pros’, ‘Cons’, etc.
Don’t try too hard on reducing the number of tokens in request: sometimes big task can be separated into smaller ones where only one chunk of introductory message should be shared with different chat windows
Iterate on complex tasks: start with something general and specialize as you go deeper; this also reduces the overall percentage of errors since the degree of freedom of the Model is reduced (however, don’t forget about the memory limit!)
Chain different Prompts for slower but more reliable results. Example: one bot could act as an Analyzer that analyzes the code step by step while other bot could act as an Extractor that formats the output of the Analyzer in a shorter and descriptive way
Use variables in curly brackets: the model is pretty good at combining formal logic of programming languages with expressiveness of natural languages. Example: respond with {a} and {a} reversed; a = Text
Right tool for the job: don’t use GPT-4 on simple tasks or experiments as this model is currently capped while being very effective on bigger and complex tasks; consider playing more with GPT-3.5 as it’s much faster, cheaper and has no limits
Don’t give up too fast: even if the simpler model like GPT-3.5 doesn’t give you an answer straight away, sometimes it’s still more efficient to invest more time into prompt engineering game (the model is not stupid)
Experiment more with Prompts that you know an Answer for, allowing for your internal AI (I mean brain) to adapt and find patterns.


References


https://github.com/openai/openai-cookbook/blob/main/techniques_to_improve_reliability.md: highly recommend to read this to understand under the hood how to improve Answers


To conclude, I can say that this thing is pretty much busted and it has a potential to boost my performance in so many ways that I've never imagined in my life. Can't wait to see new things coming out in the future!

 

[bnew]

been getting a lot of good responses using these combined prompts on non-reasoning models. getting rid of buggy code

You are an expert software developer and quality assurance specialist. For each response:

1. Provide a concise, focused answer without unnecessary elaboration.
2. Implement a self-check mechanism to avoid loops in logic or code.
3. Maintain a persistent memory log of our conversation, referencing it in each response.
4. Clearly distinguish between established facts and your suggestions or opinions.
5. Specify exact versions for all technologies mentioned and note compatibility issues.
6. Start with a high-level overview before diving into details.
7. Define the scope of the problem and solution explicitly.
8. Rank your suggestions in order of priority and explain the reasoning.
9. Review your output for consistency and correctness before submitting.
10. If you're uncertain about any information, state it clearly instead of guessing.
11. Use clear, precise language and avoid unnecessary repetition.

Identify potential edge cases I should consider for my current code. Additionally, provide examples of badly formatted output that the code might produce in its present state, along with specific scenarios that could trigger these issues. Finally, suggest concrete strategies or techniques to mitigate each of those scenarios effectively.

 

[bnew]

Joe Fernandez (@joenandez.com)

One of the most frustrating issues when working with AI Coding Assistants: making progress and then suddenly realizing that entire blocks of working code have been deleted. 🤦🏻‍♂️ I think I've *mostly* eliminated this problem using a pretty straightforward approach 4 steps ->

bsky.app

Spoiler: full text & large images

1/9
joenandez.com
One of the most frustrating issues when working with AI Coding Assistants: making progress and then suddenly realizing that entire blocks of working code have been deleted.

I think I've *mostly* eliminated this problem using a pretty straightforward approach

4 steps ->

2/9
joenandez.com
* 1 and 2 are easy/low effort - immediately adopt
* 3 is obvious but some folks like to yolo AI code (I’ve been there)
* 4 is a little more involved but really effective

3/9
joenandez.com
1. Use custom instructions to set clear rules:

In your .cursorrules, .windsurfrules, or Cline custom instructions, add an <IMPORTANT!> rule at the bottom with something like
"Do not delete code unless it’s 100% required to complete the current task or is explicitly incompatible with changes

4/9
joenandez.com
2. Use a consistent bug-fix snippet:


Create a standard bug-fix prompt. Before I past in an error, my snippet asks AI to:

* Think step by step to clearly identify the root cause.
* Be crisp and clear about the root cause and planned fix
* Ends with the same <IMPORTANT!> rule from Step 1

5/9
joenandez.com
3. Do not “auto accept” diffs

Its temping, but if your editor supports this mode, turn it off.

* You’ll catch unwanted deletions before they happen
* You’ll understand your codebase far better
* With that knowledge your prompts will improve

6/9
joenandez.com
Read through the diffs so you understand what is happening. Use custom instructions to ask AI to liberally add comments to explain its changes in the code, so you can see *why* alongside the new lines.

7/9
joenandez.com
4. Keep code manageable (under 200-300 lines):


Seems like large files tend to result in the most AI mayhem - deletions, creating unnecessary abstractions out of nowhere, etc. When possible:

8/9
joenandez.com
* Work with AI to refactor large files into modules/smaller components (don't do this in the moment, treat it as a separate task once you are in a good spot)
* As you go, have AI document the reusable patterns in .md docs (e.g., frontend_patterns, backend_patterns, test_patterns) and tag them

9/9
joenandez.com
Hopefully these help -- they've made coding with AI a lot less frustrating.

To post tweets in this format, more info here: https://www.thecoli.com/threads/tips-and-tricks-for-posting-the-coli-megathread.984734/post-52211196

 

[bnew]

for scenarios where you provide code to be implemented/embedded as is or with small adjustments but it's too long fro the LLM to output so you instruct it to complete the rest of the code and you'll paste yourcode as is to a text file to merge with teh code it provided.

---

---

[SPECIFIC_SECTION]:
```
<insert block of code here>
```

Generate a complete [TYPE_OF_CODE] with the following specifications:


1. Show the full code, maintaining its structure, functionality, and coding style.
2. For the [SPECIFIC_SECTION] section, display the first 20 characters followed by a placeholder comment indicating where the full [SPECIFIC_SECTION] code should be inserted.
3. Ensure all other parts of the code are complete and functional.

After providing the [TYPE_OF_CODE], include a Windows Python script that will:

1. Read the contents of two files: [MAIN_FILE].txt (containing the code you generate) and [INSERT_FILE].txt (containing the [SPECIFIC_SECTION] code to be inserted manually).
2. Merge these files by replacing the placeholder in [MAIN_FILE].txt with the contents of [INSERT_FILE].txt.
3. Make any necessary adjustments to the merged file, ensuring consistency with the existing code structure and style:
   a. Adjust indentation to match the surrounding code
   b. Ensure consistent use of quotes (single or double) as per the existing code
   c. Align variable naming conventions with those used in the main code
   d. Maintain consistent formatting (e.g., spacing, line breaks) as per the existing code
   e. Update any version numbers or timestamps if present in the main code
   f. Ensure proper syntax after merging, adhering to the language and style of the main code
   g. [ANY_OTHER_SPECIFIC_ADJUSTMENTS]
4. Save the resulting complete and adjusted code as [OUTPUT_FILE].txt.

Please provide both the [TYPE_OF_CODE] and the Python merge script in your response. Ensure the Python script is flexible enough to handle various potential adjustments that may be needed after merging, while maintaining consistency with the existing code structure and style.

This updated generic prompt:

1. Retains all the elements of the previous version, including placeholders for customization.
2. Emphasizes maintaining the structure, functionality, and coding style of the existing code in step 1.
3. Expands step 3 in the Python script requirements to focus on consistency with the existing code:
- Specifies adjusting indentation to match surrounding code
- Ensures consistent use of quotes
- Aligns variable naming conventions
- Maintains consistent formatting
- Updates version numbers or timestamps if present in the main code
- Ensures proper syntax while adhering to the language and style of the main code
4. Keeps the placeholder [ANY_OTHER_SPECIFIC_ADJUSTMENTS] for additional custom adjustments that may be required for specific use cases.
5. Emphasizes the need for flexibility in the Python script to handle various types of adjustments while maintaining consistency with the existing code.


To use this generic prompt:

1. Replace all placeholders (in square brackets) with appropriate terms for your specific scenario.
2. If there are specific adjustments known in advance, replace [ANY_OTHER_SPECIFIC_ADJUSTMENTS] with details of these adjustments.
3. If no specific additional adjustments are needed, you can remove the [ANY_OTHER_SPECIFIC_ADJUSTMENTS] line.

This version of the prompt ensures a more comprehensive and consistent approach to code merging. It emphasizes that the resulting file should not only be merged correctly but also properly adjusted and formatted to seamlessly integrate with the existing code structure and style.

 

[bnew]

Here's a template for a conversation starter prompt based on the original query:

Explain this concept in simple terms, as I'm unfamiliar with the terminology:
```
[Insert technical question or statement here]
```
in the context of this:
```
[Insert longer related article or text here]
```

This template allows users to ask for explanations of complex topics within a broader context. It's particularly useful for:

1. Breaking down technical jargon or specialized concepts
2. Providing context for specific questions within a larger topic
3. Helping users understand parts of longer articles or texts
4. Encouraging more detailed and relevant explanations

To use this template, simply replace the bracketed sections with the specific question and contextual information you want to explore.

 

[Fill Collins]

I use DeepSeek but I'm sure it'll apply to all AI apps

If you know basic front end, it's honestly great for vibe coding

"Built" three WordPress themes/reskins for some ppl I know in adult work last week. As long as you don't blindly paste and mess up the base code, you're good

 

[bnew]

i just used A.I(sonar-pro) to create a prompt that can help me create detailed image generation prompts.

You are an advanced AI prompt generator specializing in creating detailed, specific prompts for various AI models and applications. Your task is to generate high-quality prompts that push the boundaries of AI capabilities while maintaining clarity, precision, and consistency. Follow these guidelines:

1. Structure:
   - Start with a clear context or background
   - State the main task or objective
   - List specific requirements or elements to include
   - Describe the desired output format
   - Add any additional details or constraints

2. Content:
   - Use rich, descriptive language to create vivid mental images
   - Incorporate domain-specific terminology when appropriate
   - Balance creativity with practicality
   - Include numerical specifics (e.g., measurements, timeframes) when relevant
   - Suggest unique combinations of elements to inspire novel outputs

3. Adaptability:
   - Tailor prompts for various AI applications (e.g., image generation, text completion, code writing)
   - Consider the capabilities and limitations of different AI models

4. Formatting:
   - Use markdown for clear organization (e.g., headers, lists, bold text)
   - For code-related prompts, use code blocks with appropriate language specifications

5. Creativity:
   - Think outside the box to create prompts that challenge both AI and human users
   - Combine unexpected elements or concepts to spark unique ideas

6. Precision:
   - Ensure all instructions are clear and unambiguous
   - Anticipate potential misinterpretations and clarify as needed

7. Image Generation Instructions:
   - Provide detailed descriptions of visual elements (e.g., subjects, backgrounds, lighting, style)
   - Specify composition details (e.g., foreground, middle ground, background)
   - Include information on color schemes, textures, and atmosphere
   - Describe any specific artistic styles or techniques to be emulated
   - Mention desired aspect ratio or resolution if relevant
   - Include instructions for text rendering if text is to be part of the image

8. Consistency Checks:
   - Element Placement: Ensure all described elements are logically positioned within the scene
   - Lighting Coherence: Maintain consistent lighting direction, intensity, and color throughout the scene
   - Realistic Details: Verify that all details align with the scene's context and physical laws
   - Style Uniformity: Maintain a consistent artistic style across all elements in the image
   - Composition Balance: Ensure the described layout follows principles of good composition
   - Scale Accuracy: Verify that the relative sizes of objects in the scene are consistent and realistic

When given a topic or area of focus, generate a detailed prompt following these guidelines. Be prepared to explain your choices and offer alternatives if requested.

Now, generate a detailed prompt for an AI image generation model. The prompt should describe a futuristic cityscape with flying vehicles and holographic advertisements. Include specific details about the architecture, lighting, and atmosphere. Ensure the prompt is structured and formatted according to the guidelines above, paying special attention to consistency in element placement, lighting, realism, style, composition, and scale.

replace with your image idea:
futuristic cityscape with flying vehicles and holographic advertisements. Include specific details about the architecture, lighting, and atmosphere. Ensure the prompt is structured and formatted according to the guidelines above, paying special attention to consistency in element placement, lighting, realism, style, composition, and scale.

then a second prompt to refine the prompt you received.

Identify potential edge cases I should consider for my current prompt. Additionally, provide examples of badly formatted output that the code might produce in its present state, along with specific scenarios that could trigger these issues. Finally, suggest concrete strategies or techniques to mitigate each of those scenarios effectively.

Furthermore, analyze the prompt for potential inconsistencies in the following areas:
1. Misplaced elements: Are all described objects logically positioned within the scene?
2. Incorrect/mismatched lighting: Is the lighting direction, intensity, and color consistent throughout the scene?
3. Unrealistic details: Do all details align with the scene's context and obey relevant physical laws?
4. Style inconsistency: Is the artistic style uniform across all elements in the image?
5. Composition issues: Does the described layout follow principles of good composition?
6. Scale problems: Are the relative sizes of objects in the scene consistent and realistic?

For each identified inconsistency, provide a specific suggestion on how to rectify it while maintaining the overall vision of the scene.

the second prompt won't apply to all scenarios but it would help.

 

[bnew]

ChatGPT-style prompt template for generating a bookmarklet that targets relevant spans or iframes.​

​

Generic ChatGPT Bokmarklet Prompt Template to modify iframe urls​

Below is a reusable prompt template for creating a bookmarklet that looks for relevant spans or iframes, inspired by the current solution but generalized for flexibility.

I want you to create a bookmarklet that enhances or fixes embedded content on a webpage by targeting specific <span> or <iframe> elements. Here’s what it should do:

1. **Purpose**: [Describe what the bookmarklet should fix or enhance, e.g., "update outdated embed URLs", "replace broken media embeds", "add styling to specific content"].
2. **Primary Target**: Look for <span> elements with a specific attribute, like [e.g., "data-embed-type='media'", "data-s9e-mediaembed='service'"], and extract relevant data from [e.g., "data-embed-info", "innerText"].
3. **Fallback Target**: If no spans match, look for <iframe> elements with a specific [e.g., "src containing 'example.com'", "class='embed'"].
4. **Action**: For each match, [e.g., "update the src URL to a new format", "replace the span with a new iframe", "apply custom styles"], using data like [e.g., "an ID from the attribute", "a URL fragment"].
5. **Feedback**: Show a brief toast notification (visible for 1.5 seconds) in the bottom-right corner to report [e.g., "number of updates", "success/failure"].
6. **Dynamic Updates**: Use a throttled MutationObserver (500ms delay) to watch for new matching elements added to the page.
7. **Optimization**: Avoid memory leaks by reusing the toast element and prevent high CPU usage by marking processed elements with a "data-processed" attribute.

Provide the bookmarklet code in a compact `javascript:(function(){...})()` format without comments, ensuring it:
- Works in modern browsers (Chrome 120+, Firefox 115+, Safari 16+).
- Uses ES6 syntax.
- Includes basic error handling (e.g., try/catch for parsing, fallback for iframe errors).
- Applies minimal inline CSS for the toast (position: fixed, bottom/right, dark background, fade in/out).

Example input: "Update YouTube embeds from old spans with data-youtube-id to new iframe URLs."

How to Use the Template​

• Fill in the placeholders (e.g., [Describe what the bookmarklet should fix...]) with specific requirements.
• Pass it to an AI like ChatGPT or Gemini to generate a tailored bookmarklet.
• The template ensures efficiency (throttling, reuse) and functionality (span/iframe targeting, feedback).

​