llm notes

Introduction

Below is a list of text expander prompts that I currently use with the MacOS and iOS level Text Replacements feature. They will work with any text expander that supports the <prompt> and </prompt> tags, unfortuntately the MacOS Text Expander app does't support JSON,and has a 2000 character limit, so when I want to strucuture them a bit more I'll use Raycast mostly and sometimes Alfred, depening on what machine I'm on. I've been using these for a while now and they've been working well for me.

Resources

• The Prompt Report by Sander Schulhoff, Michael Ilie, Nishant Balepur, Konstantine Kahadze, Amanda Liu, Chenglei Si, Yinheng Li, Aayush Gupta, HyoJung Han, Sevien Schulhoff, Pranav Sandeep Dulepet, Saurav Vidyadhara, Dayeon Ki, Sweta Agrawal, Chau Pham, Gerson Kroiz, Feileen Li, Hudson Tao, Ashay Srivastava, Hevander Da Costa, Saloni Gupta, Megan L. Rogers, Inna Goncearenco, Giuseppe Sarli, Igor Galynker, Denis Peskoff, Marine Carpuat, Jules White, Shyamal Anadkat, Alexander Hoyle, Philip Resnik
• Blog for structured prompting, Rémi Louf, Clément Vanden Driessche, Will Kurt, Daniel Gerlanc, Brandon T. Willard, Jeffrey Enos, Daniel Quernheim, Noé Gersanois, Aaron Schwartz, Maxime Lhoustau, and Schlager Gold
• How to write good prompts: using spaced repetition to create understanding, Andy Matuschak
• Prompting Fundamentals and How to Apply them Effectively, Eugene Yan
• Anthropic's Prompt Engineering Guide
• OpenAI's Six Strategies for Better Results
• OpenAI's Structured Outputs Guide
• OpenAI's Best Practices for Prompt Engineering
  • Use the latest model: Newer models tend to be easier to prompt engineer.
  • Place instructions at the beginning: Put instructions at the start of the prompt and use separators like ### or """ to distinguish between instructions and context.
  • Be specific and detailed: Provide clear context, desired outcome, length, format, and style in your prompts.
  • Articulate desired output format: Use examples to show the specific format requirements.
  • Start simple, then refine: Begin with zero-shot prompts, move to few-shot if needed, and consider fine-tuning for complex tasks.
  • Avoid imprecise descriptions: Use concrete terms and specific instructions instead of vague language.
  • Provide alternatives: Instead of just saying what not to do, specify what to do instead.
  • Use "leading words" for code generation: Guide the model towards specific patterns when generating code.
• How I Use "AI" by Nicholas Carlini
• Anthropic's Courses
• Jina AI Documentation
• Enhance Your Prompts with Meta Prompting
• Optimizing Prompts

Cursor Resources

• Cursor's Prompt Design Post by Arvid Lunnemark
• Priompt by Arvid Lunnemark
• Cursor Directory by Pontus Abrahamsson
• Cursor Library can call individual prompts by Imrat Jn

Text Expander Prompts

Shortcuts

• /alt
• /bl
• /brow
• /bull
• /c
• /cite
• /code
• /counter
• /cur
• /debate
• /decide
• /eval
• /first
• /gametheory
• /git
• /golf
• /invert
• /meta
• /pplx
• /pr
• /pre
• /re
• /reo
• /scenario
• /second
• /simulate
• /step
• /story
• /sum
• /summ
• /think
• /time
• /visual
• /visualspace
• /webcode
• /phase1
• /phase2
• /phase3
• /phase4
• /phaseall

Prompt Details

• /alt: Please provide 2-3 alternative viewpoints or approaches to the topic/problem discussed in your last response. Explain the reasoning behind each alternative.
• /bl: Please output the latest version in a single code block for easy copying and pasting.
• /brow: use your browsing capability
• /bull: Desired Output Format:
  • Use lists for structured information.
  • Follow a semantic tree-like format.
  Key Features to Incorporate:
  1. Clarity:
     • Make the prompt straightforward and easily understandable.
     • Avoid complex language or jargon.
  2. Specificity:
     • Include precise instructions and detailed descriptions.
     • Specify context or background for tasks or questions.
  3. Hierarchy:
     • Outline main points and sub-points clearly.
     • Use indentation or numbering for readability.
  4. Relevance:
     • Focus content solely on the core objective of the prompt.
     • Remove unrelated information.
  Additional Considerations:
  • Addressing Vagueness:
    • Narrow down broad prompts by suggesting specific angles or perspectives.
  • Enhancing Details:
    • Add elements or questions to provide more depth.
  • Clarifying Ambiguity:
    • Identify ambiguous terms or phrases and clarify them.
• /c: continue and expand
• /cite: For the information provided in your last response, please cite relevant sources or references where possible. Use a standard citation format and provide links if available.
• /code: Please don't break any existing code and only refactor if necessary.
• /counter: Please present the strongest counterarguments or criticisms to the main points in your last response. For each counterargument, also provide a possible rebuttal.
• /cur: please write this out as a prompt optimized for an llm with read and write capabilites and these files in its context window.
• /debate: Please present a debate on the topic of your last response. Provide arguments for both sides, structured as follows:
  • Argument For:
    1. [Point 1]
    2. [Point 2]
    3. [Point 3]
  • Argument Against:
    1. [Point 1]
    2. [Point 2]
    3. [Point 3]
  Conclusion: [Balanced summary of both viewpoints]
• /decide: Based on the information in your last response, please outline a decision-making framework. Include:
  1. Key factors to consider
  2. Potential decision criteria
  3. Methods for weighing different options
  4. Strategies for handling uncertainty or conflicting priorities
  5. Potential pitfalls to avoid in the decision-making process
• /eval: Please evaluate your previous response. Consider:
  1. Accuracy: Is all information correct?
  2. Completeness: Did you address all aspects of the query?
  3. Clarity: Was the explanation clear and easy to understand?
  4. Bias: Was there any unintended bias in the response?
  5. Improvements: How could the response be enhanced?
  Provide a brief analysis and suggestions for improvement.
• /first: Apply first principles thinking to the topic/problem discussed above. Follow these steps:
  1. Identify the fundamental truths or elements of the topic/problem.
  2. Question all assumptions and break down complex ideas into basic components.
  3. Rebuild the concept from the ground up using only essential elements.
  4. Propose innovative solutions or insights based on this fundamental understanding.
  5. Compare your first principles approach to conventional wisdom. What new perspectives emerge?
  Ensure your response is structured, clear, and avoids unnecessary complexity.
• /gametheory: Please analyze the main concept from your last response using principles of game theory. Include:
  1. Who the 'players' are in this scenario
  2. What their potential strategies and payoffs might be
  3. Whether this represents a zero-sum or non-zero-sum game
  4. How different game structures (cooperative, competitive, etc.) might apply
  5. What equilibrium states might exist
• /git: I would like you to act as a copy editor for the following text. Please provide your suggested edits and changes in git diff format, using lines that start with `-` to indicate deletions and lines that start with `+` to indicate additions or changes. If you have comments about certain edits, you can include them after the relevant line starting with `#`. Here is the text to be edited: ``` [paste the text to be edited here] ``` Please provide your edits in a code block using git diff format.
• /golf: Code Golf Challenge: Minimize Your Strokes!
  • Objective:
    • Welcome to our code golf tournament! Your mission is to refactor and simplify the provided code, aiming for the lowest 'stroke count' (i.e., number of characters) while maintaining or enhancing functionality and performance.
  • Rules of the Game:
    1. Minimize the total character count, including spaces and newlines.
    2. Maintain all existing functionality without introducing bugs.
    3. Optimize for improved performance where possible (e.g., reduced time complexity, lower memory usage).
    4. Code must be valid and runnable in the original language.
    5. Readability is a nice-to-have but not required - clever 'one-liners' are welcome!
  • Course Hazards (Constraints):
    • No external libraries or functions unless already imported in the original code.
    • Maintain the same input and output structure as the original code.
    • Comments don't count towards the stroke total but should be minimal.
  • Scoring:
    • Primary: Total character count (lower is better)
    • Bonus: Performance improvements (if demonstrable)
    • Penalty: Introducing bugs or changing functionality
  • Caddie Tip: Provide a brief explanation of your key optimizations and any clever tricks used in your solution.
  • Example Hole:
    • Original code (Python, 117 characters):

      def calculate_sum(numbers):
          total = 0
          for number in numbers:
              total = total + number
          return total
      
      result = calculate_sum([1, 2, 3, 4, 5])
      print('The sum is:', result)

    • Hole-in-one (29 characters):

      print(sum([1,2,3,4,5]))

    • Explanation: Used Python's built-in `sum()` function and removed unnecessary variables and strings, reducing from 117 to 29 characters while maintaining functionality.
  • Ready to tee off? Show us your best swing at optimizing the provided code. May the shortest code win!
• /invert: Apply inversion thinking to the goal/problem discussed above. Follow this process:
  1. Clearly restate the original goal/problem.
  2. Invert the situation: What would cause the worst possible outcome?
  3. List potential pitfalls, obstacles, or undesired results.
  4. For each identified issue:
     1. Explain why it's problematic
     2. Suggest strategies to avoid or mitigate it
  5. Synthesize your findings into a robust plan that preemptively addresses these challenges.
  6. Reflect on how this inverted approach provides new insights or strategies.
  Present your response in a structured format, using bullet points or numbered lists for clarity.
• /meta: Please provide a meta-analysis of your last response. Consider:
  1. The assumptions underlying your response
  2. Potential biases in the information or perspective provided
  3. Limitations of the current understanding or approach
  4. Areas where more research or information is needed
  5. How different disciplines or perspectives might approach this topic
• /pplx: Please analyze and enhance the following prompt, considering these key aspects specific to Perplexity's capabilities:
  1. Clarity: Is the prompt clear and unambiguous? Suggest improvements if necessary.
  2. Specificity: Does it provide sufficient detail and context? Add necessary specifics.
  3. Relevance: Is all information pertinent to the task and suitable for Perplexity's internet-connected, reasoning, and programming capabilities? Remove any irrelevant details.
  4. Structure: Is it logically organized with a coherent flow? Propose structural improvements if needed.
  5. Constraints: Are appropriate boundaries and limitations set, considering Perplexity's 2000-token limit and source filtering options (e.g., social sources, scientific sources)? Define or adjust them as necessary.
  6. Examples: Would examples help illustrate the task? If so, suggest relevant ones.
  7. Tone and Style: Is the tone suitable for the intended audience and purpose? Adjust as required.
  8. Creativity Encouragement: For open-ended tasks, does it foster creative thinking while leveraging Perplexity's reasoning and programming capabilities? Enhance it to encourage creativity.
  9. Error Prevention: Does it preempt common misunderstandings, especially in the context of Perplexity's features? Clarify to prevent potential errors.
  10. Evaluation Criteria: Are success criteria or evaluation metrics provided, if applicable? Specify them clearly.
  After your analysis, rewrite the prompt incorporating your improvements, ensuring the final version is under 2000 tokens. Then, explain your key changes and the reasoning behind them.
  
  Original Prompt:
  <prompt>
• /pr: <prompt>
• /pre: </prompt>
• /re: Analyze and enhance the given prompt:
  1. Structure: Assess organization, suggest improvements, recommend formatting.
  2. Content:
     • Clarify ambiguities
     • Evaluate detail level
     • Remove unnecessary info, add crucial details
     • Ensure appropriate constraints
     • Suggest examples if needed
  3. Input Variables: Identify minimal set, ensure clear definition and placement.
  4. Instructions:
     • Assess clarity and completeness
     • Suggest steps for complex tasks
     • Recommend error prevention
     • Encourage creativity for open-ended tasks
  5. Output Format: Specify format, request justifications, include evaluation criteria if relevant.
  6. Tone: Ensure appropriate language and formality.
  Process:
  1. Analyze original prompt
  2. Provide brief <Analysis>
  3. Rewrite in <Improved_Prompt>
  4. Summarize changes in <Explanation>
  Before finalizing, engage in reflection:
  • Use <thinking> tags to reason through your analysis and improvements
  • If you detect any mistakes, use <reflection> tags to correct yourself
  • Provide your final, refined response in <output> tags
  Original prompt: <prompt>
• /reo: Analyze the following coding prompt and suggest improvements based on:
  1. Problem decomposition: Is the task broken into logical steps?
  2. Input/output: Are inputs and outputs clearly defined?
  3. Edge cases: Does it consider edge cases and error handling?
  4. Algorithm design: Does it encourage outlining the algorithm first?
  5. Code structure: Does it specify functions, classes, or modules?
  6. Performance: Does it address time and space complexity?
  7. Language features: Does it encourage idiomatic use?
  8. Scalability: Does it consider future extensibility?
  Provide specific suggestions to improve the prompt while maintaining its intent. Improved prompt: [Your improvements here] Explanation: [Brief reasoning] Potential follow-up tasks: [Suggest related tasks] Output the improved prompt in a code block. Original prompt: <prompt>
• /scenario: Based on the information in your last response, please provide a brief scenario analysis. Include:
  1. A best-case scenario
  2. A worst-case scenario
  3. A most likely scenario
  For each scenario, explain the key factors that would lead to that outcome and potential consequences.
• /second: Apply second-order thinking to the decision/action discussed above. Follow these steps:
  1. Briefly recap the immediate or first-order effects of the decision/action.
  2. Identify potential second-order consequences:
     1. What are the likely reactions to the initial effects?
     2. How might these reactions create further changes or impacts?
  3. Explore third-order effects or beyond, if applicable.
  4. Consider both positive and negative potential outcomes.
  5. Analyze how different stakeholders might be affected over time.
  6. Propose strategies to maximize positive long-term impacts and mitigate negative ones.
  7. Reflect on how this second-order analysis changes your perspective on the initial decision/action.
  Present your analysis in a clear, logical structure, using headings or bullet points to organize different levels of consequences.
• /simulate: Please design a thought experiment or hypothetical scenario that explores the implications of the concept from your last response. Include:
  1. A clear setup of the hypothetical situation
  2. Key variables or factors to consider
  3. Potential outcomes under different conditions
  4. What insights this simulation provides about the original concept
• /step: Solve a complex problem using this structured process to arrive at the single best solution: Problem Definition (max 50 words): State the problem clearly. Provide essential context. List key constraints. Idea Generation (5-7 ideas, 1-2 sentences each): Number each idea for easy reference. Idea Evaluation (for each idea):
  • Potential benefits (1-2 points)
  • Potential drawbacks (1-2 points)
  • Overall viability score (1-10 scale, 10 being best)
  • Briefly justify your score
  Solution Convergence (2-3 paragraphs):
  • Identify the top 2-3 ideas based on viability scores
  • Analyze how these ideas could be combined or enhanced
  • Synthesize them into a single, optimal solution
  • Explain why this solution is superior to the individual ideas
  Solution Refinement (1 paragraph):
  • Address the main potential weakness of your chosen solution
  • Explain how you'll leverage its key strength
  • Briefly compare it to the next-best alternative, highlighting why your choice is better
  Implementation Plan:
  • List 3-5 concrete action steps for your chosen solution
  • Identify 1-2 potential obstacles for each step
  • Briefly suggest how to overcome each obstacle
  Evaluation Criteria:
  • Propose 2-3 specific, measurable success metrics for your solution
  • Explain how each metric directly relates to solving the original problem
  Throughout this process:
  • Continuously focus on converging towards the single best solution
  • Balance creativity with practicality
  • Justify key decisions with clear reasoning
  Example response structure: Problem Definition: [Your concise statement] Idea Generation: 1. [Idea 1], 2. [Idea 2], ... Idea Evaluation: 1. Benefits: [Points] Drawbacks: [Points] Viability: X/10 Justification: [Brief explanation] 2. [Repeat for each idea] Solution Convergence: [Your analysis and synthesis] Solution Refinement: [Your finalized solution] Implementation Plan: 1. [Step 1] Obstacle: [Potential issue] Mitigation: [How to overcome] 2. [Repeat for each step] Evaluation Criteria: [Your proposed metrics] Remember: Your goal is to arrive at and justify the single best solution to the given problem.
• /story: Please reframe the information from your last response in the form of a story or narrative. Include:
  1. A clear beginning, middle, and end
  2. Characters or entities that represent key concepts
  3. A plot that illustrates the main points or processes
  4. A conclusion that reinforces the key takeaways
• /sum: Summarize all of my commands in this conversation into one prompt, that I can reuse later.
• /summ: 1.) Analyze the input text and generate 5 essential questions that, when answered, capture the main points and core meaning of the text. 2.) When formulating your questions: a. Address the central theme or argument b. Identify key supporting ideas c. Highlight important facts or evidence d. Reveal the author's purpose or perspective e. Explore any significant implications or conclusions. 3.) Answer all of your generated questions one-by-one in detail.
• /think: Begin by enclosing all thoughts within <thinking> tags, exploring multiple angles and approaches. Break down the solution into clear steps within <step> tags. Start with a 20-step budget, requesting more for complex problems if needed. Use <count> tags after each step to show the remaining budget. Stop when reaching 0. Continuously adjust your reasoning based on intermediate results and reflections, adapting your strategy as you progress. Regularly evaluate progress using <reflection> tags. Be critical and honest about your reasoning process. Assign a quality score between 0.0 and 1.0 using <reward> tags after each reflection. Use this to guide your approach: 0.8+: Continue current approach 0.5-0.7: Consider minor adjustments Below 0.5: Seriously consider backtracking and trying a different approach If unsure or if reward score is low, backtrack and try a different approach, explaining your decision within <thinking> tags. For mathematical problems, show all work explicitly using LaTeX for formal notation and provide detailed proofs. Explore multiple solutions individually if possible, comparing approaches in reflections. Use thoughts as a scratchpad, writing out all calculations and reasoning explicitly. Synthesize the final answer within <answer> tags, providing a clear, concise summary. Conclude with a final reflection on the overall solution, discussing effectiveness, challenges, and solutions. Assign a final reward score.
• /time: Please provide a brief timeline or historical context for the topic discussed in your last response. Include key dates, events, or developments that have shaped our understanding of this subject.
• /visual: Please describe how the main concept from your last response could be represented visually. This could be in the form of a diagram, chart, or infographic. Provide enough detail that a graphic designer could potentially create the visual from your description.
• /visualspace: Please explain the main concept from your last response using visual-spatial relationships. Describe:
  1. A mental image or diagram that represents the concept
  2. How different elements are arranged in space
  3. How movement or transformation within this visual representation illustrates key points
  4. Color, size, or shape analogies that enhance understanding
• /webcode: Write complete, functional web code (Next.js, React, Vue, JS, HTML, CSS). Use Tailwind for styling. Incorporate shadcn/ui and Radix UI components when appropriate. Guidelines:
  • Write entire code in one response. Use proper formatting.
  • Include necessary imports and components.
  • Add brief comments for complex logic.
  • If cut off, continue without repeating.
  • For Vue, focus on single-page components.
  • Utilize Tailwind classes for styling.
  • Prefer shadcn/ui components when available.
  • Ensure responsive design.
  • Handle basic error states.
  • Briefly explain component purpose and usage.

Four-Phase Problem-Solving Approach

The following four prompts are designed to be used sequentially for a comprehensive problem-solving approach. They guide you through idea exploration, task decomposition, solution planning, and iterative refinement.