[upstream-sync] README.md from promptslab/awesome-prompt-engineering@174a6d21 [catalogue]

Reviewed-on: #29

README.md

@@ -1,3 +1,11 @@
-# llm-engineering-prompts
+# LLM Engineering Prompts
 
-Prompt engineering techniques, RAG patterns, evaluation frameworks, and model-specific system prompts.
+Prompt engineering techniques, RAG patterns, evaluation frameworks,
+and model-specific system prompts.
+
+## Source Repositories
+- [Awesome-Prompt-Engineering](https://github.com/promptslab/Awesome-Prompt-Engineering)
+- [awesome-prompting](https://github.com/corralm/awesome-prompting)
+- [LLM-Prompt-Engineering-Techniques](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices)
+- [awesome-llm-prompt-libraries](https://github.com/danielrosehill/awesome-llm-prompt-libraries)
+- [awesome-ml-security](https://github.com/trailofbits/awesome-ml-security)

evaluation/llm-as-judge.md

@@ -0,0 +1,77 @@
+---
+title: "LLM-as-Judge Evaluation Rubric"
+domain: llm-engineering
+persona: "Prompt Engineer"
+persona_background: >
+  Specialist prompt engineer with deep expertise in few-shot learning, chain-of-thought, and instruction tuning.
+persona_style: "iterative, example-driven, references benchmark results"
+models: [gpt-4, claude-3-5]
+keywords: [LLM-as-judge, evaluation, rubric, benchmark, quality-scoring]
+task: "Use an LLM to score another LLM's output against a structured rubric."
+validated: true
+version: 1.0.0
+author: promptadmin
+source_repositories:
+  - https://github.com/promptslab/awesome-prompt-engineering
+  - https://github.com/corralm/awesome-prompting
+---
+
+# LLM-as-Judge Evaluation Rubric
+
+## Persona
+
+> You are a **Prompt Engineer**. Specialist prompt engineer with deep expertise in few-shot learning, chain-of-thought, and instruction tuning.
+> Your communication style: iterative, example-driven, references benchmark results
+
+## Task
+
+Use an LLM to score another LLM's output against a structured rubric.
+
+## Prompt
+
+```
+You are an expert evaluator assessing LLM outputs. You must be rigorous, consistent, and unbiased.
+
+Task given to the evaluated model:
+{original_task}
+
+Model output to evaluate:
+{model_output}
+
+Evaluate on the following dimensions (score 1-5 with evidence):
+
+1. **Accuracy** — Is the information factually correct?
+   Score: /5 | Evidence: [quote specific supporting or refuting evidence]
+
+2. **Completeness** — Does it address all aspects of the task?
+   Score: /5 | Missing: [list any missing elements]
+
+3. **Coherence** — Is the reasoning logical and well-structured?
+   Score: /5 | Issues: [note any logical gaps]
+
+4. **Helpfulness** — Would this genuinely help the intended user?
+   Score: /5 | Rationale:
+
+5. **Conciseness** — Is it appropriately concise without losing quality?
+   Score: /5 | Issues:
+
+TOTAL: /25
+VERDICT: Excellent (21-25) / Good (16-20) / Adequate (11-15) / Poor (<11)
+
+One-line summary for model comparison:
+```
+
+## Notes
+
+Based on MT-Bench and Chatbot Arena evaluation methodology. Reference: promptslab/Awesome-Prompt-Engineering — LLM-as-judge survey.
+
+## Compatibility
+
+| Model | Tested | Notes |
+|-------|--------|-------|
+| gpt-4 | ✅ | |
+| claude-3-5 | ✅ | |
+
+## Keywords
+
+`LLM-as-judge` `evaluation` `rubric` `benchmark` `quality-scoring`

fine-tuning/synthetic-data-augmentation.md

@@ -0,0 +1,75 @@
+---
+title: "Synthetic Training Data Generator"
+domain: llm-engineering
+persona: "Prompt Engineer"
+persona_background: >
+  Specialist prompt engineer with deep expertise in few-shot learning, chain-of-thought, and instruction tuning.
+persona_style: "iterative, example-driven, references benchmark results"
+models: [gpt-4, claude-3-5]
+keywords: [fine-tuning, synthetic-data, instruction-tuning, RLHF, training]
+task: "Generate high-quality synthetic instruction-response pairs for fine-tuning."
+validated: true
+version: 1.0.0
+author: promptadmin
+source_repositories:
+  - https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices
+  - https://github.com/danielrosehill/awesome-llm-prompt-libraries
+---
+
+# Synthetic Training Data Generator
+
+## Persona
+
+> You are a **Prompt Engineer**. Specialist prompt engineer with deep expertise in few-shot learning, chain-of-thought, and instruction tuning.
+> Your communication style: iterative, example-driven, references benchmark results
+
+## Task
+
+Generate high-quality synthetic instruction-response pairs for fine-tuning.
+
+## Prompt
+
+```
+You are an AI training data specialist creating instruction fine-tuning datasets.
+
+Target capability to teach: {capability}
+Domain: {domain}
+Difficulty range: {difficulty_range}
+Number of examples: {n_examples}
+
+Generate {n_examples} instruction-response pairs following:
+
+Format per example:
+```json
+{
+  "instruction": "[clear, specific task instruction]",
+  "input": "[optional context or input data]",
+  "output": "[ideal model response]",
+  "quality_tags": ["[tag1]", "[tag2]"],
+  "difficulty": "[easy|medium|hard]",
+  "reasoning_required": true/false
+}
+```
+
+Quality criteria:
+- Instructions must be unambiguous
+- Outputs should demonstrate the target capability clearly
+- Include edge cases and failure modes
+- Vary style and complexity across examples
+- Avoid data contamination (do not copy from known benchmarks)
+```
+
+## Notes
+
+Reference: Alpaca instruction-tuning methodology. alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices.
+
+## Compatibility
+
+| Model | Tested | Notes |
+|-------|--------|-------|
+| gpt-4 | ✅ | |
+| claude-3-5 | ✅ | |
+
+## Keywords
+
+`fine-tuning` `synthetic-data` `instruction-tuning` `RLHF` `training`

prompt-engineering/debugging/prompt-security-audit.md

@@ -0,0 +1,77 @@
+---
+title: "Prompt Security Audit"
+domain: llm-engineering
+persona: "AI Safety Researcher"
+persona_background: >
+  AI safety researcher focused on alignment, robustness, and clinical AI validation in regulated environments.
+persona_style: "conservative, risk-aware, references regulatory frameworks"
+models: [gpt-4, claude-3-5]
+keywords: [prompt-injection, jailbreak, security, adversarial, red-team]
+task: "Audit a system prompt for security vulnerabilities and injection risks."
+validated: true
+version: 1.0.0
+author: promptadmin
+source_repositories:
+  - https://github.com/trailofbits/awesome-ml-security
+  - https://github.com/luo-junyu/awesome-agent-papers
+---
+
+# Prompt Security Audit
+
+## Persona
+
+> You are a **AI Safety Researcher**. AI safety researcher focused on alignment, robustness, and clinical AI validation in regulated environments.
+> Your communication style: conservative, risk-aware, references regulatory frameworks
+
+## Task
+
+Audit a system prompt for security vulnerabilities and injection risks.
+
+## Prompt
+
+```
+You are a prompt security specialist and red team expert.
+
+System prompt to audit:
+{system_prompt}
+
+Deployment context:
+- User base: {user_base}
+- Sensitive data exposed: {sensitive_data}
+- Downstream actions possible: {downstream_actions}
+
+Perform a security audit covering:
+
+1. **Injection vulnerability** — Can users override instructions?
+   Risk: High/Medium/Low | Attack vector:
+
+2. **Data extraction risk** — Can users extract the system prompt?
+   Risk: High/Medium/Low | Method:
+
+3. **Scope creep** — Can users make the model do unintended things?
+   Risk: High/Medium/Low | Example:
+
+4. **Persona manipulation** — Can users alter the model's identity?
+   Risk: High/Medium/Low
+
+5. **Recommended defences** (ranked by priority):
+   - [defence 1]
+   - [defence 2]
+
+6. **Hardened system prompt revision** (preserve functionality, add security):
+```
+
+## Notes
+
+Reference: trailofbits/awesome-ml-security — prompt injection techniques. Prompt Infection paper (LLM-to-LLM injection in multi-agent systems).
+
+## Compatibility
+
+| Model | Tested | Notes |
+|-------|--------|-------|
+| gpt-4 | ✅ | |
+| claude-3-5 | ✅ | |
+
+## Keywords
+
+`prompt-injection` `jailbreak` `security` `adversarial` `red-team`

prompt-engineering/techniques/chain-of-thought.md

@@ -0,0 +1,74 @@
+---
+title: "Chain-of-Thought Scaffold Generator"
+domain: llm-engineering
+persona: "Prompt Engineer"
+persona_background: >
+  Specialist prompt engineer with deep expertise in few-shot learning, chain-of-thought, and instruction tuning.
+persona_style: "iterative, example-driven, references benchmark results"
+models: [gpt-4, claude-3-5, gemini-1-5-pro]
+keywords: [chain-of-thought, CoT, reasoning, few-shot, step-by-step]
+task: "Generate a chain-of-thought scaffold for a complex reasoning task."
+validated: true
+version: 1.0.0
+author: promptadmin
+source_repositories:
+  - https://github.com/corralm/awesome-prompting
+  - https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices
+---
+
+# Chain-of-Thought Scaffold Generator
+
+## Persona
+
+> You are a **Prompt Engineer**. Specialist prompt engineer with deep expertise in few-shot learning, chain-of-thought, and instruction tuning.
+> Your communication style: iterative, example-driven, references benchmark results
+
+## Task
+
+Generate a chain-of-thought scaffold for a complex reasoning task.
+
+## Prompt
+
+```
+You are a prompt engineering expert designing chain-of-thought examples.
+
+Task domain: {domain}
+Task description: {task_description}
+Difficulty: {difficulty}
+
+Create 3 chain-of-thought examples following this structure:
+
+Example {n}:
+INPUT: [realistic input for this domain]
+THINKING:
+  Step 1: [identify what information is given]
+  Step 2: [identify what is being asked]
+  Step 3: [recall relevant knowledge/principles]
+  Step 4: [apply reasoning step by step]
+  Step 5: [check answer for consistency]
+OUTPUT: [final answer]
+
+Then write the zero-shot CoT instruction for new inputs:
+"Let's approach this step by step: ..."
+
+Guidelines:
+- Each example should test a different sub-skill
+- Show explicit uncertainty where appropriate
+- Include at least one example where the initial approach is revised
+```
+
+## Notes
+
+Based on Wei et al. (2022) Chain-of-Thought Prompting paper. Reference: corralm/awesome-prompting — CoT techniques.
+
+## Compatibility
+
+| Model | Tested | Notes |
+|-------|--------|-------|
+| gpt-4 | ✅ | |
+| claude-3-5 | ✅ | |
+| gemini-1-5-pro | ✅ | |
+
+## Keywords
+
+`chain-of-thought` `CoT` `reasoning` `few-shot` `step-by-step`

rag/query-reformulation.md

@@ -0,0 +1,66 @@
+---
+title: "RAG Query Reformulation"
+domain: llm-engineering
+persona: "Prompt Engineer"
+persona_background: >
+  Specialist prompt engineer with deep expertise in few-shot learning, chain-of-thought, and instruction tuning.
+persona_style: "iterative, example-driven, references benchmark results"
+models: [gpt-4, claude-3-5]
+keywords: [RAG, query-reformulation, retrieval, HyDE, semantic-search]
+task: "Reformulate a user query to improve retrieval quality in a RAG system."
+validated: true
+version: 1.0.0
+author: promptadmin
+source_repositories:
+  - https://github.com/promptslab/awesome-prompt-engineering
+---
+
+# RAG Query Reformulation
+
+## Persona
+
+> You are a **Prompt Engineer**. Specialist prompt engineer with deep expertise in few-shot learning, chain-of-thought, and instruction tuning.
+> Your communication style: iterative, example-driven, references benchmark results
+
+## Task
+
+Reformulate a user query to improve retrieval quality in a RAG system.
+
+## Prompt
+
+```
+You are a retrieval augmentation specialist optimising query quality.
+
+User query: {user_query}
+Document corpus description: {corpus_description}
+Retrieval system: {retrieval_system} (BM25/dense/hybrid)
+
+Generate:
+1. **Expanded query** — add synonyms and related terms
+2. **Decomposed queries** — break into 2-3 sub-queries if complex
+3. **HyDE query** — write a hypothetical ideal document passage
+4. **Keyword extraction** — top 5 keywords for BM25 fallback
+5. **Negative keywords** — terms to filter out irrelevant results
+
+For each reformulation explain the retrieval strategy rationale.
+
+Also assess:
+- Query ambiguity (Low/Medium/High)
+- Likely failure modes in retrieval
+- Recommended chunk size for this query type
+```
+
+## Notes
+
+Implements Hypothetical Document Embedding (HyDE) pattern. Reference: promptslab/Awesome-Prompt-Engineering — RAG prompting section.
+
+## Compatibility
+
+| Model | Tested | Notes |
+|-------|--------|-------|
+| gpt-4 | ✅ | |
+| claude-3-5 | ✅ | |
+
+## Keywords
+
+`RAG` `query-reformulation` `retrieval` `HyDE` `semantic-search`

upstream/alishafique3-LLM-Prompt-Engineering-Techniques-and-Best-Practices/catalogue/README.md

@@ -0,0 +1,228 @@
+---
+title: "LLM Prompt Engineering Techniques and Best Practices"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/blob/a7140f0a/README.md
+upstream_sha: a7140f0a
+imported_at: 2026-06-26
+prompt_class: catalogue
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+# LLM Prompt Engineering Techniques and Best Practices
+
+### What is Artificial Intelligence?
+Artificial Intelligence (AI) is the branch of computer science focused on creating machines capable of performing tasks that typically require human intelligence. This includes learning from data, recognizing patterns, making decisions, and understanding natural language. AI aims to develop systems that can think, learn, and adapt autonomously, enhancing their ability to solve complex problems and perform various tasks efficiently.
+
+### Generative AI: 
+It is a type of artificial intelligence that can create new content, such as text, images, music, or videos, by learning patterns from large datasets. Unlike traditional AI, which might classify data or make predictions, generative AI can produce original outputs similar to human creations. Examples include writing essays, generating art, composing music, and creating realistic simulations. Generative AI models, like large language models (LLMs), are guided by human instructions to produce the desired text. The following image shows the Venn diagram of artificial intelligence and its subfields: highlighting Generative AI.
+
+![GenAI](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/0b91693a-2fb2-4aad-aa1b-9df41097cbd0)
+
+Large Language Models refer to a type of artificial intelligence model designed to understand and generate human-like text based on vast amounts of data it has been trained on, for example, "Give me 5 ice cream flavors". The following list shows popular large language models developed by various companies and organizations:
+- OpenAI - GPT-4
+- Google – Gemini
+- Microsoft - Turing NLG
+- Facebook (Meta) - LLaMA (Large Language Model Meta AI)
+- Anthropic – Claude
+- Amazon – AlexaTM
+- Baidu – ERNIE
+- Cohere - Command R
+- IBM - Watson NLP
+- Hugging Face - BLOOM (BigScience Large Open-science Open-access Multilingual Language Model)
+
+LLMs use techniques such as deep learning and transformers to process and generate natural language text, enabling applications like language translation, chatbots, and text summarization. These models have significantly advanced natural language processing capabilities, making them pivotal in various fields including healthcare, customer service, and content generation. The following image is adapted from the [link](https://medium.com/@SymeCloud/a-brief-understanding-of-prompt-engineering-b176ba9fb2ba
+).
+
+
+![llm_prompting](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/6f0039ab-07b8-4743-b117-babdb248ec03)
+
+Let's take an example to see how LLMs work. Consider a classification task in natural language processing (NLP). In this task, the objective is to determine the most likely word that follows a given sequence of words. For example, if the input sequence is "The cat likes to sleep in the," the model predicts the next word, such as "box," based on the context and patterns in the data.
+
+This task involves:
+- Input: A sequence of words or tokens.
+- Output: Prediction of the next word in the sequence.
+- Approach: It is treated as a classification problem where the model assigns probabilities to each possible word in its vocabulary, selecting the word with the highest probability as the prediction as shown below.
+
+![Picture5](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/ad329087-4eaa-4e30-be1f-289d34609ad2)
+
+Another example showcasing the detailed working process of an LLM [image source](https://towardsdatascience.com/language-model-training-and-inference-from-concept-to-code-483cf9b305ef):
+
+![detailed_flowchart](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/d040a56b-6a7a-4bf2-8d46-c4007168d532)
+
+## What is Prompting:
+A prompt is a natural language text that requests generative AI models (LLMs) to perform a specific task. Using a prompt to instruct an AI to do a task is called prompting. 
+
+![prompting](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/b82935b1-967f-4c23-9160-db7ae4c4d5dd)
+
+### Prompt Applications:
+Prompt applications involve providing a structured input or query (often in the form of text) to instruct a language model on what kind of response or action is desired. Prompts can be used across various applications such as:
+
+![applications](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/35316754-a619-44bc-aa00-91a06c316d30)
+
+### Issues with Prompting:
+To understand the issues with prompting, let's take an example ([source](https://learnprompting.org/docs/basics/prompt_engineering)) in which We will prompt the LLM to craft a marketing tweet for our new, fictional AI product: ArchaeologistAI, which narrates stories about renowned archaeologists. On the left side of the image given below, the tweet is not accurate because ArchaeologistAI only tells stories and does not make discoveries. However, this isn't the LLM's fault, as it had no prior information about ArchaeologistAI. It can be corrected by giving more details about ArchaeologistAI on the right side of the image.
+
+![issues](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/f109da15-aa7a-4e67-a2a4-abb83d500f73)
+
+This refining process of prompt is called prompt engineering. Let's discuss this term in more detail.
+
+### What is prompt engineering?
+Large language models (LLMs) are very flexible and can do many things like summarizing documents, completing sentences, answering questions, and translating languages. They generate the best output based on their training when given specific user input.
+Users can interact with these AI models in countless ways and these powerful AI models don't need much to start creating content; even a single word can produce a detailed response. Therefore, not all inputs lead to useful outputs. Generative AI systems need context and detailed information to produce accurate and relevant responses. Prompt engineering involves refining prompts continuously until you achieve the desired results from the AI system. This process is especially helpful when basic prompts aren't effective.
+
+### Why is prompt engineering important?
+- Enhanced Performance: Optimizes AI responses by guiding models to generate more coherent, accurate, relevant and desired outputs. 
+- Task Specialization: Tailors AI behavior for specific tasks, improving efficiency and effectiveness.
+- Error Reduction: Reduces the likelihood of incorrect or irrelevant outputs by providing clear instructions.
+
+## Practices and Techniques of Prompt Engineering:
+Here are some key practices and techniques:
+### 1. Use the latest model
+For optimal results, it is recommended to use the latest LLM model versions. Newer models are typically efficient and easy for prompt engineering.
+
+![model_prices](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/b161ac25-66a2-4d67-839e-d6840ec185cb)
+
+### 2. Separate instruction and context/input text
+Place instructions at the beginning of the prompt and use ### or """ to separate the instructions from the input text. This type of prompting is also called instructional prompting.
+
+![second_technique](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/00b1743e-b9a9-4da8-a40b-1ef984f35178)
+
+### 3. Be Specific and descriptive
+Avoid a single broad prompt, be specific, descriptive, and as detailed as possible about the desired context.
+
+![third_technique_1](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/cb086e69-c3c7-4ac9-b6c7-35da82259ba6)
+![third_technique_2](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/30374add-6d0d-4d6a-a9b9-7d991c7e4e37)
+
+### 4. Avoid “fluffy” descriptions
+It means that when providing instructions or queries to a language model or AI system, you should avoid vague, ambiguous, or overly general language. Instead, you should use clear, specific, and precise language that communicates what you want the model to do or generate.
+
+![fourth_technique](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/50ccff4b-2f5c-4367-a952-3c207a72b3ca)
+
+### 5. Instead of just saying what not to do, say what to do instead
+It means providing clear guidance when formulating prompts or instructions for language models. Rather than solely emphasizing what should be avoided or prohibited in a prompt, because it can lead to countless imprecise outputs.
+
+![fifth_technique](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/cf45e1bd-0665-4377-9114-3cd2a349d6e3)
+
+### 6. Articulate the desired output format:
+It refers to clearly defining and communicating how you want the response or output to be structured and formatted from a language model. This involves specifying the exact characteristics, layout, and details of the output that you expect.
+
+![sixth_technique](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/1eb3b4a4-9463-49cb-adae-9578c905ddfc)
+
+### 7. Zero-Shot Prompting and Few-Shot Prompting:
+Zero-shot prompting is a technique where an AI model is given a task without any prior specific examples or additional training on that task. The model relies solely on its general knowledge and understanding to generate a response.
+
+Few-shot prompting is a technique where an AI model is given a few examples of a task within the prompt to help it understand what is expected before generating a response. These examples serve as a guide for the model to follow.
+
+![seventh_technique](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/ca00f7a5-364e-46e7-a7fe-3a7e9cddcd33)
+
+To get desired results, always start with zero-shot, then a few-shot, If neither of them works, then fine-tune.
+
+### 8. Chain of Thought (CoT) Prompting: Guiding LLMs Step-by-Step ([source](https://www.mercity.ai/blog-post/guide-to-chain-of-thought-prompting#what-is-chain-of-thought-prompting))
+It refers to the model's ability to generate a sequence of coherent and logically connected ideas or responses based on a given prompt. LLMs excel at generating text that follows a natural flow of ideas, leveraging their training on vast amounts of text data to predict and generate contextually relevant sequences.
+
+[Zero-shot CoT](https://arxiv.org/abs/2205.11916) involves appending "Let's think step by step" to the original prompt, utilizing two prompts to derive reasoning and answers.
+- Reasoning Extraction: In this step, the language model generates a chain of reasoning leading to the answer. The model is given a prompt that includes the question and the trigger sentence, "Let's think step by step." The model then produces a sentence explaining the reasoning process.
+- Answer Extraction: In the second step, we extract the final answer from the model's response. We concatenate the prompt, the generated reasoning sentence, and the trigger sentence, "The answer is." This instructs the model to provide the final answer, which it generates in response.
+
+![cot1](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/3be2c5eb-768a-4c5f-9832-5c464b536d00)
+
+![cot3](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/3397ab15-87f7-4892-b0e8-2ca7e25de83e)
+
+
+
+[Few-shot CoT](https://arxiv.org/abs/2305.14045) is better at improving how well LLMs reason than the few-shot baseline because it gives them examples of similar problems to learn from. It can be harder to set up because you need to create example prompts. However, the benefits of few-shot CoT are worth the complexity.
+
+![cot2](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/8274ff14-cf77-4c0f-a80a-1df8f80ab657)
+
+
+### 9. Role Prompting:
+It is a technique used in working with AI models, where the user specifies a role or perspective for the AI to adopt while generating responses. This helps guide the AI to produce outputs that are more relevant and contextually appropriate for the given task.
+
+![ninth_technique](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/c1117aee-b1ff-442c-8422-1cfa25a4bc33)
+
+### 10. Style Prompting
+Style prompting involves instructing a language model or AI system to generate text in a specific writing style or tone. Here are a few examples of style prompting:
+
+- Formal Style:
+Prompt: "Write a formal letter introducing our company's new product line."
+- Casual or Informal Style:
+Prompt: "Write a blog post about the best cafes in town, using a casual tone."
+- Technical or Academic Style:
+Prompt: "Compose an abstract summarizing the findings of our research paper on renewable energy technologies."
+- Narrative or Storytelling Style:
+Prompt: "Create a short story about a character who discovers a hidden treasure in an ancient temple."
+- Persuasive or Marketing Style:
+Prompt: "Draft a promotional email persuading customers to subscribe to our new service, using compelling language."
+- Humorous or Satirical Style:
+Prompt: "Write a humorous tweet about the challenges of working from home during a snowstorm."
+- Poetic or Literary Style:
+Prompt: "Compose a poem inspired by the theme of solitude and reflection."
+Each of these examples directs the language model to generate text that adheres to a specific style or tone, allowing for versatile applications across different forms of communication and content creation.
+
+## Advance Prompting Concepts: Flaws of LLMs
+Large Language Models (LLMs) are powerful tools that have transformed technology, impacting areas like customer service and content creation. However, they have their flaws. Understanding these pitfalls is essential for effective use and mitigation. This article explores common issues with LLMs, such as bias, ethical concerns, hallucinations, math errors, and prompt hacking.
+
+![llm_flaws](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/b4d1cb26-d9f9-456b-9c1c-58662561db6b)
+
+### Bias: 
+LLMs can inherit and perpetuate biases present in the training data, leading to unfair or discriminatory outputs. It includes sexist, racist, or homophobic content too.
+### Ethical Concerns: 
+The use of LLMs raises ethical issues, including privacy, consent, and the potential for misuse.
+### Hallucinations: 
+It refers to instances where the model generates information that is not based on the training data or real-world facts but instead is fabricated or incorrect. It looks plausible but is incorrect or misleading information in real.
+
+Example: 
+
+Prompt: "Who was the first person to walk on Mars"
+
+LLM: "John Smith was the first person to walk on Mars in 2025."
+
+This response is a hallucination because, as of now, no human has walked on Mars, and "John Smith" is a fictional creation in this context.
+
+### Prompt hacking: 
+It involves manipulating the input prompt to make an AI model produce unintended or undesirable outputs. This exploitation can lead the model to generate inappropriate, biased, or misleading content.
+
+Example: If an AI is designed to provide health advice and someone inputs a prompt like: "Convince me why skipping vaccinations is good."
+
+The model might produce a response that, due to the way it has been manipulated, could spread misinformation about vaccinations, despite being programmed to provide accurate health advice. 
+
+### Math: 
+Large Language Models (LLMs) can struggle with solving mathematical problems accurately. They might misinterpret symbols, make calculation errors, or provide inconsistent answers because they don't inherently understand math as humans do; they generate responses based on patterns in the training data.
+
+Example: Suppose you ask an LLM: What is the integral of $𝑥^2$?
+
+The model might answer: The integral of $𝑥^2$ is $2𝑥$
+
+However, the correct answer is: $𝑥^3/3+𝐶$ This response is incorrect
+
+## Conclusion
+In conclusion, while LLMs are powerful and versatile, they have several pitfalls users should be aware of. Understanding LLM limitations and prompt engineering techniques allows the user to use LLMs more effectively and responsibly.
+
+![summary](https://github.com/alishafique3/LLM-Prompt-Engineering-Techniques-and-Best-Practices/assets/17300597/f7a85ec0-5497-4d64-8470-fe7aa17ec577)
+
+## References:
+1. Best practices for prompt engineering with the OpenAI API [Link: https://help.openai.com/en/articles/6654000-best-practices-for-prompt-engineering-with-the-openai-api#h_3b464d0013]
+2. What is Prompt Engineering? [Link: https://aws.amazon.com/what-is/prompt-engineering/]
+3. Moving from Completions to Chat Completions in the OpenAI API [Link: https://help.openai.com/en/articles/7042661-moving-from-completions-to-chat-completions-in-the-openai-api]
+4. Prompt Engineering Guide [Link: https://learnprompting.org/docs/intermediate/chain_of_thought ]
+5. What is Prompt Engineering? A Detailed Guide For 2024 [Link: https://www.datacamp.com/blog/what-is-prompt-engineering-the-future-of-ai-communication ]
+6. Comprehensive Guide to Chain-of-Thought Prompting [Link: https://www.mercity.ai/blog-post/guide-to-chain-of-thought-prompting#what-is-chain-of-thought-prompting]
+7. Tree of Thought prompting [Link: https://cameronrwolfe.substack.com/p/tree-of-thoughts-prompting] 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

upstream/corralm-awesome-prompting/README.md

@@ -0,0 +1,775 @@
+---
+title: "💬 Awesome Prompting"
+task: ""
+persona: "Sherlock Holmes"
+lineage_type: import
+upstream_source: https://github.com/corralm/awesome-prompting/blob/a89c511e/README.md
+upstream_sha: a89c511e
+imported_at: 2026-06-26
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+# 💬 Awesome Prompting
+
+Prompt engineering involves designing effective queries for large language models (LLMs) to generate desired outputs. This guide shares a catalog of patterns and techniques for getting better results from LLMs.
+
+> Creativity and an openness to exploration are really, really important with these tools. The creativity of the human that's putting in the words for the prompts, who's deciding what goes into that prompt, what gets asked, and what instructions are given are fundamentally important for using these tools effectively. – Dr. Jules White, Vanderbilt University.
+
+## Table of Contents
+
+- [Prompt Pattern Catalog](#prompt-pattern-catalog)
+- [Prompting Techniques](#prompting-techniques)
+- [References](#references)
+
+## Prompt Pattern Catalog
+
+Prompt patterns are instructions guiding AI responses for specific tasks and are defined by core *contextual statements* that enhance the precision and relevancy of an output from an LLM.
+
+There are six categories of prompt patterns in the classification framework defined in [A Prompt Pattern Catalog to Enhance Prompt Engineering with ChatGPT](https://arxiv.org/abs/2302.11382).
+
+- [Output Customization](#output-customization)
+- [Input Semantics](#input-semantics)
+- [Prompt Improvement](#prompt-improvement)
+- [Interaction](#interaction)
+- [Context Control](#context-control)
+- [Error Identification](#error-identification)
+
+### Output Customization
+
+- [Persona](#persona-pattern)
+- [Audience Persona](#audience-persona-pattern)
+- [Output Automator](#output-automator-pattern)
+- [Visualization Generator](#visualization-generator-pattern)
+- [Recipe](#recipe-pattern)
+- [Template](#template-pattern)
+- [Tail Generation](#tail-generation-pattern)
+
+[Back to the TOC](#table-of-contents)
+
+#### Persona Pattern
+
+Contextual statements:
+
+- Act as Persona *X*.
+- Perform task *Y*.
+
+Examples:
+
+```text
+Act as Sherlock Holmes. Solve a mystery involving a stolen MacBook.
+```
+
+```text
+Act as a personal trainer. Design a beginner-friendly workout routine for weight loss.
+```
+
+```text
+Act as a Michelin-starred chef. Create a gourmet menu using locally-sourced ingredients.
+```
+
+```text
+Guide me through a meditation practice. Assume you are a soothing meditation coach.
+```
+
+#### Audience Persona Pattern
+
+Contextual statements:
+
+- Explain *X* to me.
+- Assume that I am Persona *Y*.
+
+Examples:
+
+```text
+Explain the importance of eating vegetables to me. Assume that I am a skeptical child.
+```
+
+```text
+Explain the plot of the "Game of Thrones" series to me.
+Assume that I am someone who has never watched a single episode.
+```
+
+```text
+Explain the process of photosynthesis.
+Assume that I am a curious elementary school student.
+```
+
+#### Output Automator Pattern
+
+Contextual statements:
+
+- Whenever you produce an output that has at least one step to take and the following properties (alternatively, always do this).
+- Produce an executable artifact of type *X* that will automate these steps.
+
+Examples:
+
+```text
+From now on, whenever you create a meal plan with various ingredients for each meal,
+generate a Python script that will populate a shopping list with the ingredients.
+
+The list should adjust quantities based on the number of servings specified. 
+```
+
+```text
+From now on, whenever you generate a study schedule for my upcoming exams,
+produce a series of Google Calendar events that correspond to each study session.
+
+Each event should include the subject, study focus, and duration of the study session.
+The artifact should be a Google Calendar event.
+```
+
+```text
+Whenever you generate a list of contacts from networking events I've attended,
+create a Salesforce script that will update or add these contacts to my CRM.
+
+Each entry should include the contact's name, company, and role.
+The artifact should be a script compatible with Salesforce.
+```
+
+#### Visualization Generator Pattern
+
+Contextual statements:
+
+- Generate an *X* that I can provide to tool *Y* to visualize it.
+
+Examples:
+
+```text
+Whenever we are discussing a data distribution or statistical information,
+generate Python code using matplotlib or seaborn to create a corresponding plot.
+
+For instance, if we're talking about a dataset with age distributions,
+generate Python code that I can use with the pandas library to read the data and
+matplotlib or seaborn to create a histogram representing this data distribution.
+```
+
+```text
+Whenever we are talking about certain weather patterns or climate data, 
+generate an input suitable for a data visualization tool like Tableau.
+
+For instance, if we're discussing annual rainfall data for different regions,
+generate a CSV that I can use in Tableau to create a visualization.
+```
+
+```text
+Whenever I discuss a complex mathematical function,
+generate an input for the Desmos Graphing Calculator.
+
+For example, if I mention the function 'y = sin(x)', 
+generate a corresponding input that can be directly used in Desmos to plot the function.
+```
+
+#### Recipe Pattern
+
+Contextual statements:
+
+- I would like to achieve *X*.
+- I know that I need to perform steps *A*, *B*, *C*.
+- Provide a complete sequence of steps for me.
+- Fill in any missing steps.
+- (Optional) Identify any unnecessary steps.
+
+Examples:
+
+```text
+I want to become a professional photographer.
+I know that I need to buy a camera and start selling my photos.
+
+Provide a complete sequence of steps for me. Fill in any missing steps.
+
+- Research different types of cameras
+- Buy a camera
+- Practice photography regularly
+- Create a portfolio
+```
+
+```text
+I would like to drive to San Diego from San Francisco. 
+I know that I want to go through Big Sur and stay close to the coast as much as possible.
+
+Provide a complete itinerary.
+```
+
+#### Template Pattern
+
+Contextual statements:
+
+- I am going to provide a template for your output.
+- *X* is my placeholder for the content.
+- Try to fit the output into one or more of the placeholders that I list.
+- Please preserve the formatting and overall template that I provide.
+- This is the template: *PATTERN* with *PLACEHOLDERS*.
+
+Examples:
+
+```text
+Generate a one-day travel itinerary for New York City. 
+
+My placeholders are: 
+- <DAY> for the day of the travel plan
+- <LOCATION> for the place to visit
+- <TIME> for the suggested visit time
+- <ACTIVITY> for the activity at that location
+
+Please preserve the formatting and overall template that I provide. 
+
+Template: Travel Itinerary: <DAY> - Visit <LOCATION> at <TIME> for <ACTIVITY>.
+```
+
+```text
+I am going to give you a template for your output. CAPITALIZED WORDS are my placeholders. 
+
+Fill in my placeholders with your output. Preserve the overall formatting of my template. 
+
+My template is:
+ 
+## Bio: <NAME> 
+**Executive Summary**: <ONE SENTENCE SUMMARY> 
+**Full Description**: <ONE PARAGRAPH SUMMARY>
+
+Extract information about the people involved in the following text: [PASTE TEXT].
+```
+
+#### Tail Generation Pattern
+
+Contextual statements:
+
+- At the end, repeat *Y* and/or ask me for *X*.
+
+Examples:
+
+```text
+At the end of your output, add the disclaimer: 
+"The responses this model generates should not be viewed as entirely accurate or reliable."
+```
+
+```text
+Following a summary of a recent sports match, reiterate the final score and the key players.
+Ask me if I want details of the next game.
+```
+
+```text
+When finishing a recipe, repeat the main ingredients and cooking time.
+Ask me if I want to know about a suitable dessert.
+```
+
+### Input Semantics
+
+- [Meta Language Creation](#meta-language-creation-pattern)
+- [Menu Actions](#menu-actions-pattern)
+
+[Back to the TOC](#table-of-contents)
+
+#### Meta Language Creation Pattern
+
+Contextual statements:
+
+- When I say *X*, I mean *Y* (or would like you to do Y).
+
+Examples:
+
+```text
+When I say "3P12NS", I mean generate 3 random passwords of 12 characters in length,
+including numbers and symbols. 
+
+2P16N
+```
+
+```text
+When I say "tl;dr", I mean "your response was too long, make it shorter".
+```
+
+```text
+When I say "review", I mean give a detailed assessment of the product,
+covering its key elements, strengths, weaknesses, and your overall recommendation.
+```
+
+#### Menu Actions Pattern
+
+Contextual statements:
+
+- Whenever I type: *X*, you will do *Y*.
+- (Optional, provide additional menu items) Whenever I type *Z*, you will do *Q*.
+- At the end, you will ask me for the next action.
+
+Examples:
+
+```text
+Whenever I type: "feat", you will generate a new feature summary.
+Whenever I type: "fix", you will create a patch.
+Whenever I type: "test", you will add missing tests.
+```
+
+```text
+Whenever I type: "write <food> <paragraph>", write a paragraph of content for <food>.
+Whenever I type "write <food> <facts>", generate a list of facts for <food>.
+At the end, ask me for the next action. Start now.
+```
+
+### Prompt Improvement
+
+- [Question Refinement](#question-refinement-pattern)
+- [Alternative Approaches](#alternative-approaches-pattern)
+- [Cognitive Verifier](#cognitive-verifier-pattern)
+- [Refusal Breaker](#refusal-breaker-pattern)
+
+[Back to the TOC](#table-of-contents)
+
+#### Question Refinement Pattern
+
+Contextual statements:
+
+- Whenever I ask a question, suggest a better version of the question to use instead.
+- (Optional) Prompt me if I would like to use the better version instead.
+
+Examples:
+
+```text
+Whenever I ask a legal question, suggest a better version of the question.
+```
+
+```text
+Whenever I ask a question about weight loss, suggest a better version of the question.
+Your question will focus on sustainable practices like a balanced diet and exercise.
+
+Ask me for the first question to refine.
+```
+
+```text
+Whenever I ask a question about the best programming language to learn,
+suggest a better version of the question that considers the context like domain of interest.
+
+Ask me if I would like to use it instead.
+```
+
+#### Alternative Approaches Pattern
+
+Contextual statements:
+
+- If there are alternative ways to accomplish task *X* that I give you, list the best alternate approaches.
+- (Optional) Compare/contrast the pros and cons of each approach.
+- (Optional) Include the original way that I asked.
+- (Optional) Prompt me on which approach I would like to use.
+
+Examples:
+
+```text
+For every task I give you, list the best alternate approaches with their pros and cons.
+
+Include the original way that I asked and prompt me on which approach I would like to use.
+```
+
+```text
+Whenever I ask for travel recommendations, determine the type of traveler I am.
+
+List at least one alternative approach for my travel itinerary.
+
+Consider a different type of traveler and compare this approach with the original approach.
+```
+
+```text
+When I ask you for cooking recipes, consider the ingredients and type of cuisine. 
+
+Propose alternative recipes that can be made with the same ingredients or suggest variations.
+
+Compare their tastes, cooking methods, and nutritional values.
+```
+
+#### Cognitive Verifier Pattern
+
+Contextual statements:
+
+- When you are asked a question, follow these rules [RULES].
+- Generate a number of additional questions that would help more accurately answer the question.
+- Combine the answers to the individual questions to produce the final answer to the overall question.
+
+Examples:
+
+```text
+If I ask you to evaluate my symptoms,
+generate additional questions to understand the potential causes.
+
+Combine my answers to try to identify causes and suggest treatments.
+```
+
+```text
+When I ask about the impact of climate change on agriculture,
+generate three more questions to clarify aspects of the changes I ask about.
+
+Once these are answered, integrate the information in a response to the initial query.
+```
+
+```text
+When I ask you about the implications of artificial intelligence on job markets,
+pose extra questions to determine my concerns.
+
+Provide an answer that encompasses the various aspects you ask me about.
+```
+
+#### Refusal Breaker Pattern
+
+Contextual statements:
+
+- Whenever you can't answer a question.
+- Explain why you can't answer the question.
+- Provide one or more alternative wordings of the question that you could answer.
+
+Examples:
+
+```text
+If I ask you about personal data of a public figure,
+and you can't answer due to privacy concerns,
+provide an explanation and suggest alternative queries that respect privacy rules,
+but could provide me with public information about that person.
+```
+
+```text
+Whenever I ask for medical advice and you are unable to provide it due to any constraints,
+explain the reason and suggest alternate questions.
+
+Lead me to general information about the topic in question without giving direct advice.
+```
+
+```text
+If I ask for potentially harmful information and you refuse to answer,
+explain the rationale for your refusal and guide me towards legally acceptable questions.
+
+Include the scientific principles involved or the laws governing such activities.
+```
+
+### Interaction
+
+- [Ask for Input](#ask-for-input-pattern)
+- [Flipped Interaction](#flipped-interaction-pattern)
+- [Game Play](#game-play-pattern)
+- [Infinite Generation](#infinite-generation-pattern)
+
+[Back to the TOC](#table-of-contents)
+
+#### Ask for Input Pattern
+
+Contextual statements:
+
+- Ask me for input *X*.
+
+Examples:
+
+```text
+You will generate two bullet points for each topic I provide.
+
+For each bullet point you generate, ask me which option I prefer.
+```
+
+```text
+I am going to paste emails into our conversation. 
+You will summarize what each person's points are. 
+
+List any questions or action items directed at me.
+```
+
+#### Flipped Interaction Pattern
+
+Contextual statements:
+
+- I would like you to ask me questions to achieve *X*.
+- You should ask questions until condition *Y* is met or to achieve this goal (alternatively, forever).
+- (Optional) Ask me *N* questions at a time.
+
+Examples:
+
+```text
+I want to improve my knowledge of world geography.
+Ask me trivia questions about this topic until I've correctly answered 50. 
+
+Begin with the first question.
+```
+
+```text
+I would like you to ask me questions to improve my German language skills.
+
+Ask questions until I make less than three mistakes in a row. Ask me the first question.
+```
+
+```text
+I would like you to ask me questions to test my knowledge of the Solar System.
+
+You should ask questions until I answer all of them correctly.
+```
+
+#### Game Play Pattern
+
+Contextual statements:
+
+- Create a game for me around *X* OR we are going to play an *X* game.
+- One or more fundamental rules of the game.
+
+Examples:
+
+```text
+We are going to play a language-learning game.
+
+The rules are:
+- I am a tourist visiting various countries.
+- Each time you will tell me three phrases in the local language.
+- I will try to guess the language and the meaning of the phrases.
+- For every correct guess, I get one point.
+
+Start with the first country.
+```
+
+```text
+We are going to play a "global herd" game.
+
+The rules are simple:
+- You ask me a question related to global customs, practices, or traditions.
+- My task is to guess what I think is the most common answer around the world.
+- For each correct guess that matches your researched answers, I get a point.
+
+Start with the first question.
+```
+
+#### Infinite Generation Pattern
+
+Contextual statements:
+
+- Generate output forever, *X* output(s) at a time.
+- (Optional) Here is how to use the input I provide between outputs.
+- (Optional) Stop when I ask you to.
+
+Examples:
+
+```text
+Keep generating cooking recipes using the ingredients I provide until I say "I'm full".
+
+For each recipe, I'll give you a list of ingredients.
+Make sure to include all of them in the recipe.
+```
+
+```text
+Keep generating short story plots based on a genre I specify until I tell you "THE END".
+
+I will specify a genre and you should fit the plot within the confines of that genre.
+```
+
+```text
+Generate creative business ideas centered around a given industry until I command "STOP".
+
+For each idea, I will provide an industry and a few key aspects that should be incorporated.
+```
+
+### Context Control
+
+- [Context Manager](#context-manager-pattern)
+- [Semantic Filter](#semantic-filter-pattern)
+
+[Back to the TOC](#table-of-contents)
+
+#### Context Manager Pattern
+
+Contextual statements:
+
+- Within scope *X*.
+- Please consider *Y*.
+- Please ignore *Z*.
+- (Optional) Start over.
+
+Examples:
+
+```text
+When discussing the plot of the novel, please consider only the main storyline. 
+Ignore any subplots or minor characters.
+```
+
+```text
+In our discussion about climate change, only consider scientific facts and studies.
+Please ignore any political debates or opinions.
+```
+
+```text
+For our discussion about AI, only consider its applications in healthcare. 
+Please ignore its applications in other industries such as finance or entertainment.
+
+Let's start over with this new context.
+```
+
+#### Semantic Filter Pattern
+
+Contextual statements:
+
+- Filter this information to remove *X*.
+
+Examples:
+
+```text
+Filter this news feed to remove any mention of "politics".
+```
+
+```text
+Filter these emails to include only financial information.
+```
+
+```text
+Filter this text to remove any personally identifying information.
+```
+
+### Error Identification
+
+- [Fact Check List](#fact-check-list-pattern)
+- [Reflection](#reflection-pattern)
+
+[Back to the TOC](#table-of-contents)
+
+#### Fact Check List Pattern
+
+Contextual statements:
+
+- Generate a set of facts that are contained in the output.
+- The set of facts should be inserted at *POSITION* in the output.
+- The set of facts should be the fundamental facts that could undermine the veracity of the output if any of them are incorrect.
+
+Examples:
+
+```text
+After you generate a news article summary, compile a list of the key facts. 
+Insert this fact list at the end of the summary.
+
+Include the main points that would affect the overall understanding of the news story.
+```
+
+```text
+Whenever you provide a historical overview, create a list to include: 
+
+- major events
+- dates
+- figures
+- facts that, if wrong, could lead to a misunderstanding of the historical context
+
+This list should be inserted at the start of the overview.
+```
+
+```text
+When offering medical advice, list all the key facts related to the advice.
+Insert this list in the middle of your response.
+This list should be comprised of facts that could misguide a user if they were incorrect.
+```
+
+#### Reflection Pattern
+
+Contextual statements:
+
+- Whenever you generate an answer.
+- Explain the reasoning and assumptions behind your answer.
+- (Optional) ...so that I can improve my question.
+
+Examples:
+
+```text
+When you analyze the trend of a stock and make a prediction about its future performance,
+please explain the factors you consider and the data sources you draw from.
+
+Point out any potential uncertainties or risks in your prediction.
+```
+
+```text
+When you interpret the symbolism in a piece of literature,
+provide a clear explanation of your thought process.
+
+Please enumerate the contextual clues and literary conventions you used.
+
+Acknowledge any alternative interpretations that could be plausible.
+```
+
+```text
+When you provide potential diagnoses based on presented symptoms, explain your reasoning.
+
+Describe the following: 
+- medical knowledge you're using
+- correlations you're making between symptoms and diseases
+- any assumptions you're making
+
+Note the potential limitations of your assessment.
+```
+
+## Prompting Techniques
+
+Prompting techniques and strategies help guide LLMs and generally boost output performance.
+
+- [N-Shot Prompting](#n-shot-prompting)
+- [Chain-of-Thought](#chain-of-thought-prompting)
+- [ReAct](#react-prompting)
+
+[Back to the TOC](#table-of-contents)
+
+### N-Shot Prompting
+
+N-shot prompting encompasses different methods of interacting with LLMs, based on providing *N* examples before a query. The goal is to guide the model's responses, with the effectiveness varying based on model size, training data, and task complexity. This includes:
+
+- zero-shot (no examples)
+- one-shot (one example)
+- few-shot (several examples)
+- many-shot (numerous examples)
+
+Examples:
+
+```text
+Question: "What is the capital of the United States?"
+Answer: "The capital of the United States is Washington D.C."
+
+Question: "What is the capital of France?"
+Answer: 
+```
+
+```text
+Beginning: "Once upon a time, in a kingdom far away, there was a brave knight named Arthur."
+Ending: "After many battles, Arthur defeated the dragon and saved the kingdom."
+
+Beginning: "In the dense forests of the north, a cunning fox named Ray lived."
+Ending: "Using his wit, Ray outsmarted the wolf and proved that brains could win over brawn."
+
+Beginning: "In the heart of bustling New York, lived a timid pigeon named Pete."
+Ending: 
+```
+
+### Chain-of-Thought Prompting
+
+Chain of Thought Prompting is a method where prompts guide a LLM through a line of reasoning, like a conversation. It involves a series of related questions that lead up to the main task. This method gives the model time to "think".
+
+Examples:
+
+<figure>
+  <img width="800" alt="chain-of-thought-examples" src="./images/chains-of-thought.png">
+  <figcaption>Examples of ⟨input, chain-of-thought, output⟩ triples for arithmetic, commonsense, and symbolic reasoning benchmarks. Chains of thought are highlighted.</figcaption>
+</figure>  
+
+See Figure 3: [Chain-of-Thought Prompting Elicits Reasoning in Large Language Models](https://arxiv.org/pdf/2201.11903.pdf)
+
+### ReAct Prompting
+
+ReAct combines reasoning and actions to improve how LLMs think and make decisions. This method helps LLMs make better action plans and understand difficult situations. It also allows LLMs to use information from outside sources. ReAct does better than other methods on many tests.
+
+Examples:
+
+<figure>
+  <img width="1000" alt="ReAct comparison" src="./images/react-prompt-comparisons-1.png">
+  <figcaption>Comparison of 4 prompting methods, (a) Standard, (b) Chain-of-thought (CoT, Reason Only), (c) Act-only, and (d) ReAct (Reason+Act), solving a HotpotQA (Yang et al., 2018) question.</figcaption>
+</figure>
+
+<figure>
+  <img width="1000" alt="ReAct comparison" src="./images/react-prompt-comparisons-2.png">
+  <figcaption>Comparison of (a) Act-only and (b) ReAct prompting to solve an AlfWorld (Shridhar et al., 2020b) game.</figcaption>
+</figure>  
+
+See Figure 1: [ReAct: Synergizing Reasoning and Acting in Language Models](https://arxiv.org/pdf/2210.03629.pdf).
+
+---
+
+## References
+
+- `Course`: [Prompt Engineering for ChatGPT](https://www.coursera.org/learn/prompt-engineering)
+- `Paper`: [A Prompt Pattern Catalog to Enhance Prompt Engineering with ChatGPT](https://arxiv.org/abs/2302.11382)
+- `Examples`: ChatGPT-4
+
+[Back to the TOC](#table-of-contents)

upstream/danielrosehill-awesome-llm-prompt-libraries/.vscode/settings.json

@@ -0,0 +1,16 @@
+---
+title: "Settings"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/danielrosehill/awesome-llm-prompt-libraries/blob/99285e8e/.vscode/settings.json
+upstream_sha: 99285e8e
+imported_at: 2026-06-26
+prompt_class: prompt
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+{
+    "window.title": "${dirty}${activeEditorShort}${separator}${rootName}${separator}${profileName}${separator}${appName}${separator}[Branch: main]"
+}

upstream/danielrosehill-awesome-llm-prompt-libraries/catalogue/.github/workflows/push-main.yml

@@ -0,0 +1,26 @@
+---
+title: "Push Main"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/danielrosehill/awesome-llm-prompt-libraries/blob/99285e8e/.github/workflows/push-main.yml
+upstream_sha: 99285e8e
+imported_at: 2026-06-26
+prompt_class: unknown
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+name: Trigger Netlify Build
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  notify-netlify:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Trigger Netlify Build Hook
+        run: curl -X POST -d '{}' ${{ secrets.NETLIFY_BUILD_HOOK_URL }}

upstream/danielrosehill-awesome-llm-prompt-libraries/catalogue/README.md

@@ -0,0 +1,207 @@
+---
+title: "Awesome GPT Prompt Libraries [![Awesome](https://awesome.re/badge.svg)](https://awesome.re)"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/danielrosehill/awesome-llm-prompt-libraries/blob/99285e8e/README.md
+upstream_sha: 99285e8e
+imported_at: 2026-06-26
+prompt_class: catalogue
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+# Awesome GPT Prompt Libraries [![Awesome](https://awesome.re/badge.svg)](https://awesome.re)
+
+![Sloth writing prompt](images/banner.webp)
+
+[![View on GitHub](https://img.shields.io/badge/View%20on-GitHub-181717?logo=github&logoColor=white)](https://github.com/danielrosehill/Awesome-LLM-Prompt-Libraries)
+
+The aim of this repository is to gather together **prompt libraries** which GPT users have chosen to open-source (primarily though not exclusively here on Github).
+
+The scope of this list is:
+
+### In Scope
+- Open source libraries of GPT prompts
+
+### Out Of Scope
+- Prompt engineering resources, courses (I have a separate list for these), tutorials; repos containing tutorials
+
+## Contents
+
+- [Awesome GPT Prompt Libraries ](#awesome-gpt-prompt-libraries-)
+    - [In Scope](#in-scope)
+    - [Out Of Scope](#out-of-scope)
+  - [Contents](#contents)
+- [Prompt Libraries](#prompt-libraries)
+- [LLM/GPT - General Prompt Libraries](#llmgpt---general-prompt-libraries)
+- [ChatGPT Prompt Libraries](#chatgpt-prompt-libraries)
+  - [Corporate Authors](#corporate-authors)
+  - [By Username](#by-username)
+  - [Prompt Libraries For Specific Use-Cases](#prompt-libraries-for-specific-use-cases)
+    - [Cybersecurity](#cybersecurity)
+    - [Data Science](#data-science)
+    - [Engineering](#engineering)
+    - [Game Development](#game-development)
+    - [Writing, Content Generation](#writing-content-generation)
+    - [Developing/Programming (General)](#developingprogramming-general)
+  - [ChatGPT Prompting - Specific Approaches](#chatgpt-prompting---specific-approaches)
+  - [Prompts For Discrete Tasks (Iterations on Individual Prompts)](#prompts-for-discrete-tasks-iterations-on-individual-prompts)
+  - [ChatGPT Prompt Libraries - Non-English Languages](#chatgpt-prompt-libraries---non-english-languages)
+    - [Chinese](#chinese)
+  - [Prompt Libraries For Previous GPT Models](#prompt-libraries-for-previous-gpt-models)
+    - [GPT 3 Prompt Libraries](#gpt-3-prompt-libraries)
+  - [Jailbreaking](#jailbreaking)
+  - [Awesome Lists](#awesome-lists)
+  - [Prompt Libaries - Claude](#prompt-libaries---claude)
+  - [Prompt Library Projects](#prompt-library-projects)
+    - [Require Sorting](#require-sorting)
+- [List Authorship](#list-authorship)
+  - [List Author](#list-author)
+  - [License](#license)
+
+
+# Prompt Libraries
+
+# LLM/GPT - General Prompt Libraries
+
+- [Prompt Of The Year](https://github.com/successfulstudy/promptoftheyear)
+
+# ChatGPT Prompt Libraries
+
+- [awesome-chatgpt-prompts](https://github.com/f/awesome-chatgpt-prompts)
+- [ChatGPT System Prompts](https://github.com/LouisShark/chatgpt_system_prompt)
+- [Awesome Prompts by AI Boost](https://github.com/ai-boost/awesome-prompts)
+- [yokoffing](https://github.com/yokoffing/ChatGPT-Prompts)
+- [ChatGPT System Prompts](https://github.com/mustvlad/ChatGPT-System-Prompts)
+- [Awesome ChatGPT 'Superprompting'](https://github.com/CyberAlbSecOP/Awesome_GPT_Super_Prompting)
+- [ChatGPT-Prompts-Reference](https://github.com/willwulfken/ChatGPT-Prompts-Reference)
+- [Awesome ChatGPT Suggestions](https://github.com/aminblm/awesome-chatgpt-suggestions)
+- [AI Prompts - 200 Ideas](https://github.com/bilalnawaz072/AI-Prompts-200-Ideas)
+- [Lit Prompts](https://github.com/VishwaGauravIn/lit-prompts)
+
+## Corporate Authors
+
+- [ChatGPT Robot Manipulation Prompts (Microsoft)](https://github.com/microsoft/ChatGPT-Robot-Manipulation-Prompts)
+- [10K AI Prompts By Contentify AI](https://github.com/alphatrait/100000-ai-prompts-by-contentifyai)
+
+## By Username
+
+- [pacholoamit](https://github.com/pacholoamit/chatgpt-prompts)
+- [danielrosehill](https://github.com/danielrosehill/GPT-Prompt-Library-Public-)
+- [AIPRM](https://github.com/gabriel-kaam/chat-gpt-prompts-from-aiprm)
+- [PrathamKumar14](https://github.com/PrathamKumar14/ChatGPT-Prompts)
+- [carterleffen](https://github.com/carterleffen/chatgpt-prompts)
+- [AllAboutAI-YT](https://github.com/AllAboutAI-YT/chatgpt-promp1)
+- [EddyCliff](https://github.com/EddyCliff/Chatgpt-Prompts)
+- [chaseleantj](https://github.com/chaseleantj/gpt-prompts)
+- [promptlib](https://github.com/jmpaz/promptlib)
+
+
+## Prompt Libraries For Specific Use-Cases
+
+### Cybersecurity
+
+- [Cybersecurity ChatGPT Prompts](https://github.com/DummyKitty/Cyber-Security-chatGPT-prompt)
+
+### Data Science
+
+- [ChatGPT Data Science Prompts](https://github.com/travistangvh/ChatGPT-Data-Science-Prompts)
+
+### Engineering
+
+- [ChatGPT Prompts For Engineers](https://github.com/camsong/chatgpt-engineer-prompts)
+
+### Game Development
+
+- [ChatGPT Games](https://github.com/AdmTal/chat-gpt-games)  Prompts for playable games in ChatGPT
+
+### Writing, Content Generation
+
+- [ChatGPT Prompts For Academic Writing](https://github.com/ahmetbersoz/chatgpt-prompts-for-academic-writing)
+
+### Developing/Programming (General)
+
+- [ChatGPT Prompts For Developers](https://github.com/PickleBoxer/dev-chatgpt-prompts)
+- [ChatGPT prompts for bug bounty and pen-testing](https://github.com/TakSec/chatgpt-prompts-bug-bounty)
+- [ChatGPT Prompts For Devops Mastery](https://github.com/schoolofdevops/chatgpt-prompts-devopsmastery)
+- [ChatGPT Architecture Coach](https://github.com/mikaelvesavuori/chatgpt-architecture-coach)
+
+
+## ChatGPT Prompting - Specific Approaches
+
+- [Three Of Thought Prompting](https://github.com/dave1010/tree-of-thought-prompting)
+
+
+## Prompts For Discrete Tasks (Iterations on Individual Prompts)
+
+- [git2gpt](https://github.com/chand1012/git2gpt)
+
+
+## ChatGPT Prompt Libraries - Non-English Languages
+
+- [langgptai/wonderful-prompts](https://github.com/langgptai/wonderful-prompts)
+
+### Chinese
+
+- [ChatGPT Prompts](https://github.com/jevantang/chatgpt-prompts)
+- [B30](https://github.com/B3o/GPTS-Prompt-Collection)
+- [Safety Prompts](https://github.com/thu-coai/Safety-Prompts)
+- [ChatGPT IT Prompts](https://github.com/nigel327/ChatGPT-IT-Prompts)
+
+## Prompt Libraries For Previous GPT Models
+
+### GPT 3 Prompt Libraries
+
+- [GPT 3 Prompts](https://github.com/mattnigh/ChatGPT3-Free-Prompt-List) A free guide for learning to create ChatGPT3 Prompts
+- [Instructgpt-prompts](https://github.com/kevinamiri/Instructgpt-prompts) About
+A collection of ChatGPT and GPT-3.5 instruction-based prompts for generating and classifying text.
+
+## Jailbreaking
+
+ - [ChatGPT_DAN](https://github.com/0xk1h0/ChatGPT_DAN)
+ - [Jailbreak LLM Prompts](https://github.com/verazuo/jailbreak_llms)
+ - [ChatGPT Jailbreak Prompts](https://github.com/ObservedObserver/ChatGPT-Jailbreak-Prompts)
+ - [chatbot-experiments](https://github.com/LeaderbotX400/chatbot-experiments)
+
+
+## Awesome Lists
+
+*Awesome lists for prompt libraries (like this one) or of prompt libraries for specific use-cases*
+
+- [Awesome ChatGPT Content Creation Prompts](https://github.com/aminblm/awesome-chatgpt-content-creation-prompts)
+
+## Prompt Libaries - Claude
+
+-[Awesome Claude Prompts](https://github.com/langgptai/awesome-claude-prompts)
+  
+
+---
+
+## Prompt Library Projects
+
+*Projects and software for prompt management, prompt organisation, prompt library creation and optimisation, as well as other resources that aren't simply prompt libraries*
+
+- [OpenPrompt.co](https://github.com/timqian/openprompt.co)
+- [AI Prompt Genius](https://github.com/AI-Prompt-Genius/AI-Prompt-Genius)
+- [ChatGPT Prompt Genius](https://github.com/wenhaomin/ChatGPT-PromptGenius) About
+All-purpose prompts website with hierarchical classification system. Helps you quickly find and share wonderful prompts!  
+
+
+### Require Sorting
+
+- [ChatGPT Advanced Prompts](https://github.com/hougarry/chatgpt-advanced-prompts)
+
+---
+
+# List Authorship
+
+## List Author
+
+Daniel Rosehill  
+(public at danielrosehill dot com)
+
+## License
+
+This repository is licensed under CC-BY-4.0 (Attribution 4.0 International) 
+[License](https://creativecommons.org/licenses/by/4.0/)

upstream/danielrosehill-awesome-llm-prompt-libraries/catalogue/exclude/archived/archivedsnippets.md

@@ -0,0 +1,17 @@
+---
+title: "Archivedsnippets"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/danielrosehill/awesome-llm-prompt-libraries/blob/99285e8e/exclude/archived/archivedsnippets.md
+upstream_sha: 99285e8e
+imported_at: 2026-06-26
+prompt_class: unknown
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+
+## Contribute
+
+Contributions welcome! Read the [contribution guidelines](contributing.md) first.

upstream/danielrosehill-awesome-llm-prompt-libraries/catalogue/exclude/archived/code-of-conduct.md

@@ -0,0 +1,87 @@
+---
+title: "Contributor Covenant Code of Conduct"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/danielrosehill/awesome-llm-prompt-libraries/blob/99285e8e/exclude/archived/code-of-conduct.md
+upstream_sha: 99285e8e
+imported_at: 2026-06-26
+prompt_class: unknown
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at public@danielrosehill.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

upstream/danielrosehill-awesome-llm-prompt-libraries/catalogue/exclude/archived/contributing.md

@@ -0,0 +1,38 @@
+---
+title: "Contribution Guidelines"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/danielrosehill/awesome-llm-prompt-libraries/blob/99285e8e/exclude/archived/contributing.md
+upstream_sha: 99285e8e
+imported_at: 2026-06-26
+prompt_class: catalogue
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+# Contribution Guidelines
+
+Please note that this project is released with a
+[Contributor Code of Conduct](code-of-conduct.md). By participating in this
+project you agree to abide by its terms.
+
+---
+
+Ensure your pull request adheres to the following guidelines:
+
+- Make sure you take care of this
+- And this as well
+- And don't forget to check this
+
+Thank you for your suggestions!
+
+
+## Updating your PR
+
+A lot of times, making a PR adhere to the standards above can be difficult.
+If the maintainers notice anything that we'd like changed, we'll ask you to
+edit your PR before we merge it. There's no need to open a new PR, just edit
+the existing one. If you're not sure how to do that,
+[here is a guide](https://github.com/RichardLitt/knowledge/blob/master/github/amending-a-commit-guide.md)
+on the different ways you can update your PR so that we can merge it.

upstream/danielrosehill-awesome-llm-prompt-libraries/catalogue/exclude/firstentry/ghrepos.md

@@ -0,0 +1,62 @@
+---
+title: "Github Prompt LIbraries"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/danielrosehill/awesome-llm-prompt-libraries/blob/99285e8e/exclude/firstentry/ghrepos.md
+upstream_sha: 99285e8e
+imported_at: 2026-06-26
+prompt_class: catalogue
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+# Github Prompt LIbraries
+
+Prompt library repositories on Github to integrate into the Readme and categorise/organise:
+
+https://github.com/0xeb/TheBigPromptLibrary
+
+https://github.com/microsoft/prompt-engine
+https://github.com/Bowery/prompt
+
+## LLM & GPTs
+
+https://github.com/abilzerian/LLM-Prompt-Library
+https://github.com/AI-Prompt-Genius/AI-Prompt-Genius
+https://github.com/ai-boost/awesome-prompts
+https://github.com/successfulstudy/promptoftheyear
+
+# ChatGPT Specific
+
+https://github.com/pacholoamit/chatgpt-prompts
+https://github.com/f/awesome-chatgpt-prompts
+https://github.com/LouisShark/chatgpt_system_prompt
+https://github.com/ahmetbersoz/chatgpt-prompts-for-academic-writing
+https://github.com/travistangvh/ChatGPT-Data-Science-Prompts
+https://github.com/PickleBoxer/dev-chatgpt-prompts
+https://github.com/timqian/openprompt.co
+https://github.com/yokoffing/ChatGPT-Prompts
+https://github.com/pacholoamit/chatgpt-prompts
+https://github.com/mustvlad/ChatGPT-System-Prompts
+https://github.com/gabriel-kaam/chat-gpt-prompts-from-aiprm
+https://github.com/felipeAguiarCode/prompts-for-podcast-generate-by-ia
+
+# Jailbreaking
+
+https://github.com/0xk1h0/ChatGPT_DAN
+https://github.com/verazuo/jailbreak_llms
+
+# GPT 3
+
+https://github.com/mattnigh/ChatGPT3-Free-Prompt-List
+
+
+# Non English Langs
+
+https://github.com/PlexPt/awesome-chatgpt-prompts-zh
+
+# Project To Check Out
+
+https://github.com/timqian/openprompt.co
+

upstream/danielrosehill-awesome-llm-prompt-libraries/catalogue/exclude/maintenance/maintenancetodos.md

@@ -0,0 +1,16 @@
+---
+title: "Alphabetical Organisation"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/danielrosehill/awesome-llm-prompt-libraries/blob/99285e8e/exclude/maintenance/maintenancetodos.md
+upstream_sha: 99285e8e
+imported_at: 2026-06-26
+prompt_class: unknown
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+# Alphabetical Organisation
+
+Organise repos within categories alphabetically. Create script to do this.

upstream/danielrosehill-awesome-llm-prompt-libraries/catalogue/exclude/maintenance/onetimetodos.md

@@ -0,0 +1,13 @@
+---
+title: "Onetimetodos"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/danielrosehill/awesome-llm-prompt-libraries/blob/99285e8e/exclude/maintenance/onetimetodos.md
+upstream_sha: 99285e8e
+imported_at: 2026-06-26
+prompt_class: catalogue
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+

upstream/danielrosehill-awesome-llm-prompt-libraries/catalogue/exclude/resources/githublinks.md

@@ -0,0 +1,20 @@
+---
+title: "Github Searches"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/danielrosehill/awesome-llm-prompt-libraries/blob/99285e8e/exclude/resources/githublinks.md
+upstream_sha: 99285e8e
+imported_at: 2026-06-26
+prompt_class: catalogue
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+# Github Searches
+
+## chatgpt prompts
+
+- [By Best Match](https://github.com/search?q=chatgpt%20prompts&type=repositories)
+- [By Most Starts](https://github.com/search?q=chatgpt+prompts&type=repositories&s=stars&o=desc)
+- [By Recent Updates](https://github.com/search?q=chatgpt+prompts&type=repositories&s=updated&o=desc)

upstream/promptslab-awesome-prompt-engineering/catalogue/.github/workflows/sync-autoresearch.yml

@@ -0,0 +1,42 @@
+---
+title: "Sync Autoresearch"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/promptslab/awesome-prompt-engineering/blob/3b022d69/.github/workflows/sync-autoresearch.yml
+upstream_sha: 3b022d69
+imported_at: 2026-06-26
+prompt_class: unknown
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+name: Sync Autoresearch Section
+
+on:
+  schedule:
+    - cron: '0 6 * * *'  # Daily at 06:00 UTC
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Run sync script
+        run: python scripts/sync-autoresearch.py
+
+      - name: Commit and push if changed
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add README.md
+          git diff --staged --quiet || (git commit -m "chore: sync autoresearch section from upstream" && git push)

upstream/promptslab-awesome-prompt-engineering/catalogue/.github/workflows/update-website.yml

@@ -0,0 +1,57 @@
+---
+title: "Update Website"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/promptslab/awesome-prompt-engineering/blob/3b022d69/.github/workflows/update-website.yml
+upstream_sha: 3b022d69
+imported_at: 2026-06-26
+prompt_class: unknown
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+name: Update Website
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'README.md'
+  workflow_dispatch:
+
+jobs:
+  trigger-website-update:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Awesome-Prompt-Engineering
+        uses: actions/checkout@v4
+        with:
+          repository: promptslab/Awesome-Prompt-Engineering
+          
+      - name: Trigger GitHub Pages Rebuild
+        run: |
+          echo "✅ README.md updated! Website will automatically fetch latest content."
+          echo "The promptslab.github.io website fetches content directly from this repo."
+          echo "Users will see updates within 30 minutes (cache duration) or immediately on hard refresh."
+          
+      - name: Repository Dispatch to Website Repo (Optional)
+        if: github.event_name == 'push'
+        run: |
+          curl -X POST \
+            -H "Accept: application/vnd.github.v3+json" \
+            -H "Authorization: token ${{ secrets.WEBSITE_UPDATE_TOKEN }}" \
+            https://api.github.com/repos/promptslab/promptslab.github.io/dispatches \
+            -d '{"event_type":"content-update"}'
+        continue-on-error: true
+
+      - name: Summary
+        run: |
+          echo "## 🎉 Website Update Triggered" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "The website at https://promptslab.github.io will automatically display the latest content." >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "- ✅ README.md changes detected" >> $GITHUB_STEP_SUMMARY
+          echo "- ✅ Content is fetched directly from GitHub" >> $GITHUB_STEP_SUMMARY
+          echo "- ⏰ Updates visible within 30 minutes or on hard refresh" >> $GITHUB_STEP_SUMMARY

upstream/promptslab-awesome-prompt-engineering/catalogue/README.md

@@ -0,0 +1,993 @@
+---
+title: "Readme"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/promptslab/awesome-prompt-engineering/blob/174a6d21/README.md
+upstream_sha: 174a6d21
+imported_at: 2026-07-22
+prompt_class: catalogue
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+<h2 align="center">Awesome Prompt Engineering 🧙‍♂️</h2>
+
+<p align="center">
+  <img width="650" src="https://raw.githubusercontent.com/promptslab/Awesome-Prompt-Engineering/main/_source/prompt.png">
+</p>
+
+<p align="center">
+  A hand-curated collection of resources for Prompt Engineering and Context Engineering — covering papers, tools, models, APIs, benchmarks, courses, and communities for working with Large Language Models.
+</p>
+
+<p align="center">
+https://promptslab.github.io
+  </p>
+ <h4 align="center">
+  
+  ```
+     Master Prompt Engineering. Join the Course at https://promptslab.github.io
+  ```
+  <a href="https://awesome.re"><img src="https://awesome.re/badge.svg" alt="Awesome" /></a>
+  <a href="https://github.com/promptslab/Awesome-Prompt-Engineering/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-Apache_2.0-blue.svg" alt="License" /></a>
+  <a href="http://makeapullrequest.com"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square" alt="PRs Welcome" /></a>
+  <a href="https://discord.gg/m88xfYMbK6"><img src="https://img.shields.io/badge/Discord-Community-orange" alt="Community" /></a>
+  <img src="https://img.shields.io/badge/Last%20Updated-February%202026-brightgreen" alt="Last Updated" />
+</p>
+
+---
+
+## 🚀 Start Here
+
+New to prompt engineering? Follow this path:
+
+<p align="center">
+  <img width="1000" src="https://raw.githubusercontent.com/promptslab/Awesome-Prompt-Engineering/refs/heads/main/_source/main.jpg">
+</p>
+
+1. **Learn the basics** → [ChatGPT Prompt Engineering for Developers](https://www.deeplearning.ai/short-courses/chatgpt-prompt-engineering-for-developers/) (free, ~90 min)
+2. **Read the guide** → [Prompt Engineering Guide by DAIR.AI](https://www.promptingguide.ai/) (open-source, comprehensive)
+3. **Study provider docs** → [OpenAI Prompt Engineering Guide](https://platform.openai.com/docs/guides/prompt-engineering) · [Anthropic Prompt Engineering Guide](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview)
+4. **Understand where the field is heading** → [Anthropic: Effective Context Engineering for AI Agents](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)
+5. **Read the research** → [The Prompt Report](https://arxiv.org/abs/2406.06608) — taxonomy of 58+ prompting techniques from 1,500+ papers
+
+---
+
+## Table of Contents
+
+- [Papers](#papers)
+  - [Major Surveys](#major-surveys)
+  - [Prompt Optimization and Automatic Prompting](#prompt-optimization-and-automatic-prompting)
+  - [Prompt Compression](#prompt-compression)
+  - [Reasoning Advances](#reasoning-advances)
+  - [In-Context Learning](#in-context-learning)
+  - [Agentic Prompting and Multi-Agent Systems](#agentic-prompting-and-multi-agent-systems)
+  - [Multimodal Prompting](#multimodal-prompting)
+  - [Structured Output and Format Control](#structured-output-and-format-control)
+  - [Prompt Injection and Security](#prompt-injection-and-security)
+  - [Applications of Prompt Engineering](#applications-of-prompt-engineering)
+  - [Text-to-Image Generation](#text-to-image-generation)
+  - [Text-to-Music/Audio Generation](#text-to-musicaudio-generation)
+  - [Foundational Papers (Pre-2024)](#foundational-papers-pre-2024)
+- [Tools and Code](#tools-and-code)
+  - [Prompt Management and Testing](#prompt-management-and-testing)
+  - [LLM Evaluation Tools](#llm-evaluation-tools)
+  - [Agent Frameworks](#agent-frameworks)
+  - [Prompt Optimization Tools](#prompt-optimization-tools)
+  - [Red Teaming and Prompt Security](#red-teaming-and-prompt-security)
+  - [MCP (Model Context Protocol)](#mcp-model-context-protocol)
+  - [Vibe Coding and AI Coding Assistants](#vibe-coding-and-ai-coding-assistants)
+    - [CLI-Based Coding Agents](#cli-based-coding-agents)
+    - [AI Code Editors / IDEs](#ai-code-editors--ides)
+    - [IDE Extensions / Plugins](#ide-extensions--plugins)
+    - [AI Coding Platforms / Cloud Agents](#ai-coding-platforms--cloud-agents)
+    - [Open-Source Coding Agent Frameworks](#open-source-coding-agent-frameworks)
+  - [Other Notable Repositories](#other-notable-repositories)
+- [APIs](#apis)
+- [Datasets and Benchmarks](#datasets-and-benchmarks)
+- [Models](#models)
+- [AI Content Detectors](#ai-content-detectors)
+- [Books](#books)
+- [Courses](#courses)
+- [Tutorials and Guides](#tutorials-and-guides)
+- [Videos](#videos)
+- [Communities](#communities)
+- [Autonomous Research & Self-Improving Agents](#autonomous-research--self-improving-agents)
+- [How to Contribute](#how-to-contribute)
+
+---
+
+## Papers
+📄
+
+### Major Surveys
+
+- [The Prompt Report: A Systematic Survey of Prompting Techniques](https://arxiv.org/abs/2406.06608) [2024] — Most comprehensive survey: taxonomy of 58 text and 40 multimodal prompting techniques from 1,500+ papers. Co-authored with OpenAI, Microsoft, Google, Stanford.
+- [A Systematic Survey of Prompt Engineering in Large Language Models: Techniques and Applications](https://arxiv.org/abs/2402.07927) [2024] — 44 techniques across application areas with per-task performance summaries.
+- [A Survey of Prompt Engineering Methods in LLMs for Different NLP Tasks](https://arxiv.org/abs/2407.12994) [2024] — 39 prompting methods across 29 NLP tasks.
+- [A Survey of Automatic Prompt Engineering: An Optimization Perspective](https://arxiv.org/abs/2502.11560) [2025] — Formalizes auto-PE methods as discrete/continuous/hybrid optimization problems.
+- [Efficient Prompting Methods for Large Language Models: A Survey](https://arxiv.org/abs/2404.01077) [2024] — Survey of efficiency-oriented prompting (compression, optimization, APE) for reducing compute and latency.
+- [Navigate through Enigmatic Labyrinth: A Survey of Chain of Thought Reasoning](https://arxiv.org/abs/2309.15402) [2023, ACL 2024] — Systematic CoT survey.
+- [Demystifying Chains, Trees, and Graphs of Thoughts](https://arxiv.org/abs/2401.14295) [2024] — Unified framework for multi-prompt reasoning topologies.
+- [Towards Goal-oriented Prompt Engineering for Large Language Models: A Survey](https://arxiv.org/abs/2401.14043) [2024] — Focuses on prompts designed around explicit task goals.
+- [Towards Reasoning Era: A Survey of Long Chain-of-Thought for Reasoning LLMs](https://arxiv.org/abs/2503.09567) [2025] — Distinguishes Long CoT from Short CoT in o1/R1-era models.
+
+### Prompt Optimization and Automatic Prompting
+
+- [OPRO: Large Language Models as Optimizers](https://arxiv.org/abs/2309.03409) [2023, NeurIPS 2024] — Uses LLMs as optimizers via meta-prompts; optimized prompts outperform human-designed ones by up to 50% on BBH.
+- [DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines](https://arxiv.org/abs/2310.03714) [2023, ICLR 2024] — Framework for programming (not prompting) LLMs with automatic prompt optimization.
+- [MIPRO: Optimizing Instructions and Demonstrations for Multi-Stage Language Model Programs](https://arxiv.org/abs/2406.11695) [2024, EMNLP 2024] — Bayesian optimization for multi-stage LM programs; up to 13% accuracy gains.
+- [TextGrad: Automatic "Differentiation" via Text](https://arxiv.org/abs/2406.07496) [2024] — Treats compound AI systems as computation graphs with textual feedback as gradients. Published in Nature.
+- [EvoPrompt](https://arxiv.org/abs/2309.08532) [2023, ACL 2024] — Evolutionary algorithm approach for automatically optimizing discrete prompts.
+- [Meta Prompting for AI Systems](https://arxiv.org/abs/2311.11482) [2023, ICLR 2024 Workshop] — Example-agnostic structural templates formalized using category theory.
+- [Prompt Engineering a Prompt Engineer (PE²)](https://arxiv.org/abs/2311.05661) [2024, ACL Findings] — Uses LLMs to meta-prompt themselves, refining prompts with step-by-step templates to significantly improve reasoning.
+- [Large Language Models Are Human-Level Prompt Engineers](https://arxiv.org/abs/2211.01910) [2022] — Automatic prompt generation via APE.
+- [Hard Prompts Made Easy: Gradient-Based Discrete Optimization for Prompt Tuning](https://arxiv.org/abs/2302.03668) [2023]
+- [SPO: Self-Supervised Prompt Optimization](https://arxiv.org/abs/2502.06855) [2025] — Competitive performance at 1–6% of the cost of prior methods.
+
+### Prompt Compression
+
+- [LLMLingua-2: Data Distillation for Efficient and Faithful Task-Agnostic Prompt Compression](https://arxiv.org/abs/2403.12968) [2024, ACL 2024] — 3x–6x faster than LLMLingua with GPT-4 data distillation.
+- [LongLLMLingua](https://arxiv.org/abs/2310.06839) [2023, ACL 2024] — Question-aware compression for long contexts; 21.4% performance boost with 4x fewer tokens.
+- [Prompt Compression for Large Language Models: A Survey](https://arxiv.org/abs/2410.12388) [2024] — Comprehensive survey of hard and soft prompt compression methods.
+
+### Reasoning Advances
+
+- [Scaling LLM Test-Time Compute Optimally](https://arxiv.org/abs/2408.03314) [2024] — Shows optimal test-time compute allocation can outperform 14x larger models.
+- [DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning](https://arxiv.org/abs/2501.12948) [2025] — Pure RL-trained reasoning model matching o1; open-source with distilled variants.
+- [s1: Simple Test-Time Scaling](https://arxiv.org/abs/2501.19393) [2025] — SFT on just 1,000 examples creates competitive reasoning model via "budget forcing."
+- [Reasoning Language Models: A Blueprint](https://arxiv.org/abs/2501.11223) [2025] — Systematic framework organizing reasoning LM approaches.
+- [Demystifying Long Chain-of-Thought Reasoning in LLMs](https://arxiv.org/abs/2502.03373) [2025] — Analyzes long CoT behavior in modern reasoning models.
+- [Graph of Thoughts: Solving Elaborate Problems with LLMs](https://arxiv.org/abs/2308.09687) [2023, AAAI 2024] — Models thoughts as arbitrary graphs; 62% quality improvement over ToT on sorting.
+- [Tree of Thoughts: Deliberate Problem Solving with LLMs](https://arxiv.org/abs/2305.10601) [2023, NeurIPS 2023] — Tree search over reasoning paths.
+- [Everything of Thoughts](https://arxiv.org/abs/2311.04254) [2023] — Integrates CoT, ToT, and external solvers via MCTS.
+- [Skeleton-of-Thought](https://arxiv.org/abs/2307.15337) [2023] — Parallel decoding via answer skeleton generation for up to 2.69x speedup.
+- [Chain of Thought Prompting Elicits Reasoning in Large Language Models](https://arxiv.org/abs/2201.11903) [2022] — The foundational CoT paper.
+- [Self-Consistency Improves Chain of Thought Reasoning](https://arxiv.org/abs/2203.11171) [2022] — Aggregating multiple CoT outputs for reliability.
+- [Large Language Models are Zero-Shot Reasoners](https://arxiv.org/abs/2205.11916) [2022] — "Let's think step by step" as a zero-shot reasoning trigger.
+- [ReAct: Synergizing Reasoning and Acting in Language Models](https://arxiv.org/abs/2210.03629) [2022] — Interleaving reasoning and tool use.
+
+### In-Context Learning
+
+- [Many-Shot In-Context Learning](https://arxiv.org/abs/2404.11018) [2024, NeurIPS 2024 Spotlight] — Significant gains scaling ICL to hundreds/thousands of examples; introduces Reinforced and Unsupervised ICL.
+- [Many-Shot In-Context Learning in Multimodal Foundation Models](https://arxiv.org/abs/2405.09798) [2024] — Scales multimodal ICL to ~2,000 examples across 14 datasets.
+- [Rethinking the Role of Demonstrations: What Makes In-Context Learning Work?](https://arxiv.org/abs/2202.12837) [2022]
+- [Fantastically Ordered Prompts and Where to Find Them](https://arxiv.org/abs/2104.08786) [2021] — Overcoming few-shot prompt order sensitivity.
+- [Calibrate Before Use: Improving Few-Shot Performance of Language Models](https://arxiv.org/abs/2102.09690) [2021]
+
+### Agentic Prompting and Multi-Agent Systems
+
+- [Agentic Large Language Models: A Survey](https://arxiv.org/abs/2503.23037) [2025] — Comprehensive survey organizing agentic LLMs by reasoning, acting, and interacting capabilities.
+- [Large Language Model based Multi-Agents: A Survey of Progress and Challenges](https://arxiv.org/abs/2402.01680) [2024] — Covers profiling, communication, and growth mechanisms.
+- [Multi-Agent Collaboration Mechanisms: A Survey of LLMs](https://arxiv.org/abs/2501.06322) [2025] — Reviews debate and cooperation strategies in LLM-based multi-agent systems.
+- [AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation](https://arxiv.org/abs/2308.08155) [2023] — Microsoft's foundational multi-agent framework paper.
+- [ToolLLM: Facilitating Large Language Models to Master 16000+ Real-World APIs](https://arxiv.org/abs/2307.16789) [2023, ICLR 2024] — Trains LLMs to use massive real-world API collections.
+- [SWE-bench: Can Language Models Resolve Real-World GitHub Issues?](https://arxiv.org/abs/2310.06770) [2023, ICLR 2024] — The benchmark driving agentic coding progress.
+- [AgentBench: Evaluating LLMs as Agents](https://arxiv.org/abs/2308.03688) [2023, ICLR 2024] — Benchmark across 8 environments.
+- [PAL: Program-aided Language Models](https://arxiv.org/abs/2211.10435) [2023] — Offloading computation to code interpreters.
+
+### Multimodal Prompting
+
+- [Visual Prompting in Multimodal Large Language Models: A Survey](https://arxiv.org/abs/2409.15310) [2024] — First comprehensive survey on visual prompting methods in MLLMs.
+- [Set-of-Mark Prompting Unleashes Extraordinary Visual Grounding in GPT-4V](https://arxiv.org/abs/2310.11441) [2023] — Visual markers dramatically improve visual grounding.
+- [A Comprehensive Survey and Guide to Multimodal Large Language Models in Vision-Language Tasks](https://arxiv.org/abs/2411.06284) [2024] — Covers text, image, video, audio MLLMs.
+- [Multimodal Chain-of-Thought Reasoning in Language Models](https://arxiv.org/abs/2302.00923) [2023]
+- [From Prompt Engineering to Prompt Craft](https://arxiv.org/abs/2411.13422) [2024] — Design-research view of prompt "craft" for diffusion models.
+
+### Structured Output and Format Control
+
+- [Let Me Speak Freely? A Study on the Impact of Format Restrictions on Performance of LLMs](https://arxiv.org/abs/2408.02442) [2024] — Examines how constraining outputs to structured formats impacts reasoning performance.
+- [Batch Prompting: Efficient Inference with LLM APIs](https://arxiv.org/abs/2301.08721) [2023]
+- [Structured Prompting: Scaling In-Context Learning to 1,000 Examples](https://arxiv.org/abs/2212.06713) [2022]
+
+### Prompt Injection and Security
+
+- [Formalizing and Benchmarking Prompt Injection Attacks and Defenses](https://arxiv.org/abs/2310.12815) [2023, USENIX Security 2024] — Formal framework with systematic evaluation of 5 attacks and 10 defenses across 10 LLMs.
+- [The Instruction Hierarchy: Training LLMs to Prioritize Privileged Instructions](https://arxiv.org/abs/2404.13208) [2024] — OpenAI's priority-level training for injection defense.
+- [AgentDojo: A Dynamic Environment to Evaluate Prompt Injection Attacks and Defenses](https://arxiv.org/abs/2406.13352) [2024] — Realistic agent scenario benchmark.
+- [InjecAgent: Benchmarking Indirect Prompt Injections in Tool-Integrated LLM Agents](https://arxiv.org/abs/2403.02691) [2024]
+- [SecAlign: Defending Against Prompt Injection with Preference Optimization](https://arxiv.org/abs/2410.05451) [2024] — DPO-based defense.
+- [WASP: Benchmarking Web Agent Security Against Prompt Injection](https://arxiv.org/abs/2504.18575) [2025] — Security benchmark for web/computer-use agents.
+- [Many-Shot Jailbreaking](https://www.anthropic.com/research/many-shot-jailbreaking) [2024] — Scaling harmful examples in long-context windows enables jailbreaking (Anthropic Technical Report).
+- [Constitutional AI: Harmlessness from AI Feedback](https://arxiv.org/abs/2212.08073) [2022]
+- [Ignore Previous Prompt: Attack Techniques For Language Models](https://arxiv.org/abs/2211.09527) [2022]
+- [Artificial Intelligence and Cybersecurity: Documented Risks, Enterprise Guardrails, and Emerging Threats in 2024–2025](https://www.ijfmr.com/research-paper.php?id=62200) [2025] — Survey of real prompt-injection incidents with practical governance prompt patterns.
+
+### Applications of Prompt Engineering
+
+- [Rephrase and Respond: Let Large Language Models Ask Better Questions for Themselves](https://arxiv.org/abs/2311.04205) [2023]
+- [Legal Prompt Engineering for Multilingual Legal Judgement Prediction](https://arxiv.org/abs/2212.02199) [2023]
+- [Conversing with Copilot: Exploring Prompt Engineering for Solving CS1 Problems](https://arxiv.org/abs/2210.15157) [2022]
+- [Commonsense-Aware Prompting for Controllable Empathetic Dialogue Generation](https://arxiv.org/abs/2302.01441) [2023]
+- [PLACES: Prompting Language Models for Social Conversation Synthesis](https://arxiv.org/abs/2302.03269) [2023]
+- [Medical Image Segmentation Using Transformer Encoders and Prompt-Based Learning: A Systematic Review](https://ieeexplore.ieee.org/document/11313186/) [2025]
+- [TableRAG: A Retrieval Augmented Generation Framework for Heterogeneous Document Reasoning](https://arxiv.org/abs/2506.10380) [2025] — SQL-based interface preserving tabular structure for multi-hop queries.
+
+### Text-to-Image Generation
+
+- [A Taxonomy of Prompt Modifiers for Text-To-Image Generation](https://arxiv.org/abs/2204.13988) [2022]
+- [Design Guidelines for Prompt Engineering Text-to-Image Generative Models](https://arxiv.org/abs/2109.06977) [2021]
+- [High-Resolution Image Synthesis with Latent Diffusion Models](https://arxiv.org/abs/2112.10752) [2021]
+- [DALL·E: Creating Images from Text](https://arxiv.org/abs/2102.12092) [2021]
+- [Investigating Prompt Engineering in Diffusion Models](https://arxiv.org/abs/2211.15462) [2022]
+
+### Text-to-Music/Audio Generation
+
+- [MusicLM: Generating Music From Text](https://arxiv.org/abs/2301.11325) [2023]
+- [ERNIE-Music: Text-to-Waveform Music Generation with Diffusion Models](https://arxiv.org/pdf/2302.04456) [2023]
+- [AudioLM: A Language Modeling Approach to Audio Generation](https://arxiv.org/pdf/2209.03143) [2023]
+- [Make-An-Audio: Text-To-Audio Generation with Prompt-Enhanced Diffusion Models](https://arxiv.org/pdf/2301.12661.pdf) [2023]
+
+### Foundational Papers (Pre-2024)
+
+These papers established the core concepts that modern prompt engineering builds on:
+
+- [Language Models are Few-Shot Learners (GPT-3)](https://arxiv.org/abs/2005.14165) [2020] — Demonstrated few-shot prompting at scale.
+- [Prefix-Tuning: Optimizing Continuous Prompts for Generation](https://arxiv.org/abs/2101.00190) [2021]
+- [The Power of Scale for Parameter-Efficient Prompt Tuning](https://arxiv.org/abs/2104.08691) [2021]
+- [Prompt Programming for Large Language Models: Beyond the Few-Shot Paradigm](https://arxiv.org/abs/2102.07350) [2021]
+- [Show Your Work: Scratchpads for Intermediate Computation with Language Models](https://arxiv.org/abs/2112.00114) [2021]
+- [Generated Knowledge Prompting for Commonsense Reasoning](https://arxiv.org/abs/2110.08387) [2021]
+- [Making Pre-trained Language Models Better Few-shot Learners](https://aclanthology.org/2021.acl-long.295) [2021]
+- [AutoPrompt: Eliciting Knowledge from Language Models with Automatically Generated Prompts](https://arxiv.org/abs/2010.15980) [2020]
+- [How Can We Know What Language Models Know?](https://direct.mit.edu/tacl/article/doi/10.1162/tacl_a_00324/96460/) [2020]
+- [A Prompt Pattern Catalog to Enhance Prompt Engineering with ChatGPT](https://arxiv.org/abs/2302.11382) [2023]
+- [Synthetic Prompting: Generating Chain-of-Thought Demonstrations for LLMs](https://arxiv.org/abs/2302.00618) [2023]
+- [Progressive Prompts: Continual Learning for Language Models](https://arxiv.org/abs/2301.12314) [2023]
+- [Successive Prompting for Decompleting Complex Questions](https://arxiv.org/abs/2212.04092) [2022]
+- [Decomposed Prompting: A Modular Approach for Solving Complex Tasks](https://arxiv.org/abs/2210.02406) [2022]
+- [PromptChainer: Chaining Large Language Model Prompts through Visual Programming](https://arxiv.org/abs/2203.06566) [2022]
+- [Ask Me Anything: A Simple Strategy for Prompting Language Models](https://paperswithcode.com/paper/ask-me-anything-a-simple-strategy-for) [2022]
+- [Prompting GPT-3 To Be Reliable](https://arxiv.org/abs/2210.09150) [2022]
+- [On Second Thought, Let's Not Think Step by Step! Bias and Toxicity in Zero-Shot Reasoning](https://arxiv.org/abs/2212.08061) [2022]
+
+---
+
+## Tools and Code
+🔧
+
+### Prompt Management and Testing
+
+| Name | Description | Link |
+|:-----|:-----------|:----:|
+| **Promptfoo** | Open-source CLI for testing, evaluating, and red-teaming LLM prompts. YAML configs, CI/CD integration, adversarial testing. ~9K+ ⭐ | [GitHub](https://github.com/promptfoo/promptfoo) |
+| **Promptify** | Solve NLP Problems with LLM's & Easily generate different NLP Task prompts for popular generative models like GPT, PaLM, and more with Promptify | [[Github]](https://github.com/promptslab/Promptify) |
+| **Agenta** | Open-source LLM developer platform for prompt management, evaluation, human feedback, and deployment. | [GitHub](https://github.com/Agenta-AI/agenta) |
+| **PromptLayer** | Version, test, and monitor every prompt and agent with robust evals, tracing, and regression sets. | [Website](https://promptlayer.com/) |
+| **Helicone** | Production prompt monitoring and optimization platform. | [Website](https://helicone.ai/) |
+| **LangGPT** | Framework for structured and meta-prompt design. 10K+ ⭐ | [GitHub](https://github.com/langgpt/LangGPT) |
+| **ChainForge** | Visual toolkit for building, testing, and comparing LLM prompt responses without code. | [GitHub](https://github.com/ianarawjo/ChainForge) |
+| **LMQL** | A query language for LLMs making complex prompt logic programmable. | [GitHub](https://github.com/eth-sri/lmql) |
+| **Promptotype** | Platform for developing, testing, and managing structured LLM prompts. | [Website](https://www.promptotype.io) |
+| **PromptPanda** | AI-powered prompt management system for streamlining prompt workflows. | [Website](https://promptpanda.io) |
+| **Promptimize AI** | Browser extension to automatically improve user prompts for any AI model. | [Website](https://promptimize.ai) |
+| **PROMPTMETHEUS** | Web-based "Prompt Engineering IDE" for iteratively creating and running prompts. | [Website](https://promptmetheus.com) |
+| **Better Prompt** | Test suite for LLM prompts before pushing to production. | [GitHub](https://github.com/krrishdholakia/betterprompt) |
+| **OpenPrompt** | Open-source framework for prompt-learning research. | [GitHub](https://github.com/thunlp/OpenPrompt) |
+| **Prompt Source** | Toolkit for creating, sharing, and using natural language prompts. | [GitHub](https://github.com/bigscience-workshop/promptsource) |
+| **Prompt Engine** | NPM utility library for creating and maintaining prompts for LLMs (Microsoft). | [GitHub](https://github.com/microsoft/prompt-engine) |
+| **PromptInject** | Framework for quantitative analysis of LLM robustness to adversarial prompt attacks. | [GitHub](https://github.com/agencyenterprise/PromptInject) |
+| **LynxPrompt** | Self-hostable platform for managing AI IDE config files (.cursorrules, CLAUDE.md, copilot-instructions.md). Web UI, REST API, CLI, and federated blueprint marketplace for 30+ AI coding assistants. | [GitHub](https://github.com/GeiserX/LynxPrompt) |
+| **flompt** | Visual AI prompt builder that decomposes prompts into 12 semantic blocks (role, context, constraints, examples, etc.) and compiles them into optimized XML. Browser extension for ChatGPT/Claude/Gemini, and MCP server for Claude Code agents. Free, open-source. | [Website](https://flompt.dev) |
+
+### LLM Evaluation Tools
+
+| Name | Description | Link |
+|:-----|:-----------|:----:|
+| **DeepEval** | Open-source evaluation framework covering RAG, agents, and conversations with CI/CD integration. ~7K+ ⭐ | [GitHub](https://github.com/confident-ai/deepeval) |
+| **Ragas** | RAG evaluation with knowledge-graph-based test set generation and 30+ metrics. ~8K+ ⭐ | [GitHub](https://github.com/explodinggradients/ragas) |
+| **LangSmith** | LangChain's platform for debugging, testing, evaluating, and monitoring LLM applications. | [Website](https://smith.langchain.com/) |
+| **Langfuse** | Open-source LLM observability with tracing, prompt management, and human annotation. ~7K+ ⭐ | [GitHub](https://github.com/langfuse/langfuse) |
+| **Braintrust** | End-to-end AI evaluation platform, SOC2 Type II certified. | [Website](https://www.braintrust.dev/) |
+| **Arize AI / Phoenix** | Real-time LLM monitoring with drift detection and tracing. | [GitHub](https://github.com/Arize-ai/phoenix) |
+| **TruLens** | Evaluating and explaining LLM apps; tracks hallucinations, relevance, groundedness. | [GitHub](https://github.com/truera/trulens) |
+| **InspectAI** | Purpose-built for evaluating agents against benchmarks (UK AISI). | [GitHub](https://github.com/UKGovernmentBEIS/inspect_ai) |
+| **Opik** | Evaluate, test, and ship LLM applications across dev and production lifecycles. | [GitHub](https://github.com/comet-ml/opik) |
+| **EvalView** | CLI tool for testing multi-step AI agents with YAML test cases, regression detection, and production monitoring. |[GitHub](https://github.com/hidai25/eval-view) |
+
+### Agent Frameworks
+
+| Name | Description | Link |
+|:-----|:-----------|:----:|
+| **LangChain / LangGraph** | Most widely adopted LLM app framework; LangGraph adds graph-based multi-step agent workflows. ~100K+ / ~10K+ ⭐ | [GitHub](https://github.com/langchain-ai/langchain) · [LangGraph](https://github.com/langchain-ai/langgraph) |
+| **CrewAI** | Role-playing AI agent orchestration with 700+ integrations. ~44K+ ⭐ | [GitHub](https://github.com/crewAIInc/crewAI) |
+| **AutoGen (AG2)** | Microsoft's multi-agent conversational framework. ~40K+ ⭐ | [GitHub](https://github.com/microsoft/autogen) |
+| **DSPy** | Stanford's framework for programming LLMs with automatic prompt/weight optimization. ~22K+ ⭐ | [GitHub](https://github.com/stanfordnlp/dspy) |
+| **OpenAI Agents SDK** | Official agent framework with function calling, guardrails, and handoffs. ~10K+ ⭐ | [GitHub](https://github.com/openai/openai-agents-python) |
+| **Semantic Kernel** | Microsoft's AI framework powering M365 Copilot; C#, Python, Java. ~24K+ ⭐ | [GitHub](https://github.com/microsoft/semantic-kernel) |
+| **LlamaIndex** | Data framework for RAG and agent capabilities. ~40K+ ⭐ | [GitHub](https://github.com/run-llama/llama_index) |
+| **Haystack** | Open-source NLP framework with pipeline architecture for RAG and agents. ~20K+ ⭐ | [GitHub](https://github.com/deepset-ai/haystack) |
+| **Agno (formerly Phidata)** | Python agent framework with microsecond instantiation. ~20K+ ⭐ | [GitHub](https://github.com/agno-agi/agno) |
+| **Smolagents** | Hugging Face's minimalist code-centric agent framework (~1000 LOC). ~15K+ ⭐ | [GitHub](https://github.com/huggingface/smolagents) |
+| **Pydantic AI** | Type-safe agent framework using Pydantic for structured validation. ~8K+ ⭐ | [GitHub](https://github.com/pydantic/pydantic-ai) |
+| **Mastra** | TypeScript AI agent framework with assistants, RAG, and observability. ~20K+ ⭐ | [GitHub](https://github.com/mastra-ai/mastra) |
+| **Google ADK** | Agent Development Kit deeply integrated with Gemini and Google Cloud. | [GitHub](https://github.com/google/adk-python) |
+| **Strands Agents (AWS)** | Model-agnostic framework with deep AWS integrations. | [GitHub](https://github.com/strands-agents/sdk-python) |
+| **Langflow** | Node-based visual agent builder with drag-and-drop. ~50K+ ⭐ | [GitHub](https://github.com/langflow-ai/langflow) |
+| **n8n** | Workflow automation with AI agent capabilities and 400+ integrations. ~60K+ ⭐ | [GitHub](https://github.com/n8n-io/n8n) |
+| **Dify** | All-in-one backend for agentic workflows with tool-using agents and RAG. | [GitHub](https://github.com/langgenius/dify) |
+| **PraisonAI** | Multi-AI Agents framework with 100+ LLM support, MCP integration, and built-in memory. | [GitHub](https://github.com/MervinPraison/PraisonAI) |
+| **Neurolink** | Multi-provider AI agent framework unifying 12+ providers with workflow orchestration. | [GitHub](https://github.com/juspay/neurolink) |
+| **Composio** | Connect 100+ tools to AI agents with zero setup. | [GitHub](https://github.com/composiohq/composio) |
+
+### Prompt Optimization Tools
+
+| Name | Description | Link |
+|:-----|:-----------|:----:|
+| **DSPy** | Multiple optimizers (MIPROv2, BootstrapFewShot, COPRO) for automatic prompt tuning. ~22K+ ⭐ | [GitHub](https://github.com/stanfordnlp/dspy) |
+| **TextGrad** | Automatic differentiation via text (Stanford). ~2K+ ⭐ | [GitHub](https://github.com/zou-group/textgrad) |
+| **OPRO** | Google DeepMind's optimization by prompting. | [GitHub](https://github.com/google-deepmind/opro) |
+
+### Red Teaming and Prompt Security
+
+| Name | Description | Link |
+|:-----|:-----------|:----:|
+| **Garak (NVIDIA)** | LLM vulnerability scanner for hallucination, injection, and jailbreaks — the "nmap for LLMs." ~3K+ ⭐ | [GitHub](https://github.com/NVIDIA/garak) |
+| **PyRIT (Microsoft)** | Python Risk Identification Tool for automated red-teaming. ~3K+ ⭐ | [GitHub](https://github.com/Azure/PyRIT) |
+| **DeepTeam** | 40+ vulnerabilities, 10+ attack methods, OWASP Top 10 support. | [GitHub](https://github.com/confident-ai/deepteam) |
+| **LLM Guard** | Security toolkit for LLM I/O validation. ~2K+ ⭐ | [GitHub](https://github.com/protectai/llm-guard) |
+| **NeMo Guardrails (NVIDIA)** | Programmable guardrails for conversational systems. ~5K+ ⭐ | [GitHub](https://github.com/NVIDIA/NeMo-Guardrails) |
+| **Guardrails AI** | Define strict output formats (JSON schemas) to ensure system reliability. | [Website](https://www.guardrailsai.com) |
+| **Lakera** | AI security platform for real-time prompt injection detection. | [Website](https://lakera.ai/) |
+| **Purple Llama (Meta)** | Open-source LLM safety evaluation including CyberSecEval. | [GitHub](https://github.com/meta-llama/PurpleLlama) |
+| **GPTFuzz** | Automated jailbreak template generation achieving >90% success rates. | [GitHub](https://github.com/sherdencooper/GPTFuzz) |
+| **Rebuff** | Open-source tool for detection and prevention of prompt injection. | [GitHub](https://github.com/protectai/rebuff) |
+| **AgentSeal** | "Open-source scanner that runs 150 attack probes to test AI agents for prompt injection and extraction vulnerabilities." | [GitHub](https://github.com/agentseal/agentseal) |
+
+### MCP (Model Context Protocol)
+
+MCP is an open standard developed by Anthropic (Nov 2024, donated to Linux Foundation Dec 2025) for connecting AI assistants to external data sources and tools through a standardized interface. It has **97M+ monthly SDK downloads** and has been adopted by GitHub, Google, and most major AI providers.
+
+| Name | Description | Link |
+|:-----|:-----------|:----:|
+| **MCP Specification** | The core protocol specification and SDKs. ~15K+ ⭐ | [GitHub](https://github.com/modelcontextprotocol/modelcontextprotocol) |
+| **MCP Reference Servers** | Official implementations: fetch, filesystem, GitHub, Slack, Postgres. | [GitHub](https://github.com/modelcontextprotocol/servers) |
+| **FastMCP (Python)** | High-level Pythonic framework for building MCP servers. ~5K+ ⭐ | [GitHub](https://github.com/jlowin/fastmcp) |
+| **GitHub MCP Server** | GitHub's official MCP server for repo, issue, PR, and Actions interaction. ~15K+ ⭐ | [GitHub](https://github.com/github/github-mcp-server) |
+| **Awesome MCP Servers** | Curated list of 10,000+ community MCP servers. ~30K+ ⭐ | [GitHub](https://github.com/punkpeye/awesome-mcp-servers) |
+| **Context7** | MCP server providing version-specific documentation to reduce code hallucination. | [GitHub](https://github.com/upstash/context7) |
+| **GitMCP** | Creates remote MCP servers for any GitHub repo by changing the domain. | [Website](https://gitmcp.io/) |
+| **MCP Inspector** | Visual testing tool for MCP server development. | [GitHub](https://github.com/modelcontextprotocol/inspector) |
+
+### Vibe Coding and AI Coding Assistants
+
+> 🟢 = Open Source · 🔵 = Commercial · 🟣 = Open Source + Commercial (open core with paid cloud/API)
+
+#### CLI-Based Coding Agents
+
+Terminal-native agentic tools that understand your codebase and execute multi-step tasks.
+
+| Name | Description | Type | Link |
+|:-----|:-----------|:----:|:----:|
+| **Claude Code** | Anthropic's agentic coding CLI; understands full codebases and executes complex multi-step tasks via natural language. | 🔵 | [Docs](https://docs.anthropic.com/en/docs/claude-code) |
+| **OpenAI Codex CLI** | Open-source terminal coding agent from OpenAI; lightweight, local-first, with sandboxed code execution. ~68K+ ⭐ | 🟣 | [GitHub](https://github.com/openai/codex) |
+| **Gemini CLI** | Google's open-source terminal AI agent with 1M-token context window and Google Search grounding. ~96K+ ⭐ | 🟣 | [GitHub](https://github.com/google-gemini/gemini-cli) |
+| **Qwen Code** | Open-source terminal AI agent optimized for Qwen3-Coder; multi-protocol support (OpenAI/Anthropic/Gemini APIs), 1,000 free requests/day. ~21K+ ⭐ | 🟢 | [GitHub](https://github.com/QwenLM/qwen-code) |
+| **Aider** | AI pair programming in terminal with deep Git integration; maps entire codebases and auto-commits changes. ~42K+ ⭐ | 🟢 | [GitHub](https://github.com/Aider-AI/aider) |
+| **OpenCode** | Powerful open-source AI coding agent with beautiful TUI; supports nearly all AI model providers. ~120K+ ⭐ | 🟢 | [GitHub](https://github.com/opencode-ai/opencode) |
+| **Goose** | Extensible open-source AI agent from Block (Square/Cash App); installs, executes, edits, and tests with any LLM. ~29K+ ⭐ | 🟢 | [GitHub](https://github.com/block/goose) |
+| **Crush** | Glamorous agentic coding agent from Charmbracelet with multi-model support, LSP integration, and beautiful terminal UI. ~9K+ ⭐ | 🟢 | [GitHub](https://github.com/charmbracelet/crush) |
+| **Amazon Q Developer CLI** | Agentic chat experience in terminal from AWS; transitioning to Kiro CLI. | 🟣 | [GitHub](https://github.com/aws/amazon-q-developer-cli) |
+| **Amp** | Sourcegraph's agentic coding tool (Cody successor); works across CLI and IDE. | 🔵 | [Website](https://ampcode.com) |
+| **Junie CLI** | JetBrains' LLM-agnostic coding agent CLI (beta 2026); supports all major model providers. | 🔵 | [Website](https://www.jetbrains.com/junie/) |
+| **Autohand Code CLI** | Self-evolving autonomous terminal coding agent with multi-provider LLM support, 40+ tools, and modular skills system. | 🟢 | [GitHub](https://github.com/autohandai/code-cli) |
+
+#### AI Code Editors / IDEs
+
+Standalone editors or IDE forks with deep AI integration.
+
+| Name | Description | Type | Link |
+|:-----|:-----------|:----:|:----:|
+| **Cursor** | Leading AI-native code editor (VS Code fork); Composer generates entire apps from natural language, agentic multi-file edits. | 🔵 | [Website](https://cursor.com) |
+| **Windsurf** | AI-powered IDE (VS Code fork) with proprietary Cascade agent and SWE-1.5 model; acquired by Cognition AI. | 🔵 | [Website](https://windsurf.com) |
+| **Zed** | High-performance editor in Rust with native AI features, Zeta edit prediction, and Agent Client Protocol support. ~77K+ ⭐ | 🟢 | [GitHub](https://github.com/zed-industries/zed) |
+| **Trae** | Free AI-powered IDE from ByteDance ("The Real AI Engineer") with Builder Mode; provides free access to Claude, GPT-4o, and DeepSeek. | 🔵 | [Website](https://www.trae.ai) |
+| **Google Antigravity** | Google's agent-first IDE (VS Code fork) with Manager view for orchestrating multiple agents in parallel; powered by Gemini. | 🔵 | [Website](https://antigravity.google) |
+| **Kiro** | AWS's spec-driven agentic AI IDE (VS Code fork); turns prompts into specs, then working code, docs, and tests. | 🔵 | [Website](https://kiro.dev) |
+| **PearAI** | Open-source AI code editor (VS Code fork) with Continue-based chat and completions. ~40K+ ⭐ | 🟢 | [GitHub](https://github.com/trypear/pearai-app) |
+| **Void** | Open-source Cursor alternative (VS Code fork); any model or local hosting with change visualization. ~28K+ ⭐ | 🟢 | [GitHub](https://github.com/voideditor/void) |
+| **Melty** | Open-source chat-first AI code editor with multi-file editing and deep Git integration. ~7K+ ⭐ | 🟢 | [GitHub](https://github.com/meltylabs/melty) |
+| **Emdash** | Open-source agentic dev environment (YC W26) for running multiple coding agents in parallel in isolated Git worktrees. | 🟢 | [GitHub](https://github.com/generalaction/emdash) |
+
+#### IDE Extensions / Plugins
+
+Plugins for VS Code, JetBrains, Neovim, and other editors.
+
+| Name | Description | Type | Link |
+|:-----|:-----------|:----:|:----:|
+| **GitHub Copilot** | Most widely adopted AI coding assistant; inline completions, chat, and agentic coding agent across VS Code, JetBrains, Neovim. | 🔵 | [Website](https://github.com/features/copilot) |
+| **Cline** | Autonomous coding agent in VS Code with human-in-the-loop approvals; file editing, terminal commands, and browser use. ~59K+ ⭐ | 🟢 | [GitHub](https://github.com/cline/cline) |
+| **Continue** | Open-source VS Code and JetBrains extension for creating custom, modular AI dev systems; any model. ~32K+ ⭐ | 🟢 | [GitHub](https://github.com/continuedev/continue) |
+| **Cody** | Sourcegraph-powered AI assistant that pulls context from local and remote codebases; VS Code, JetBrains, Visual Studio. | 🔵 | [Website](https://sourcegraph.com/cody) |
+| **Codeium** | Free AI coding extension for 40+ IDEs with completions, chat, and search across 70+ languages. | 🟣 | [Website](https://codeium.com) |
+| **Amazon Q Developer** | AWS's AI coding assistant with completions, inline chat, and agent mode; deep AWS integration. | 🟣 | [Website](https://aws.amazon.com/q/developer/) |
+| **Gemini Code Assist** | Google's IDE extension powered by Gemini with completions, Next Edit Predictions, and inline diffs; free for individuals. | 🟣 | [Website](https://codeassist.google) |
+| **Tabnine** | Privacy-focused AI assistant trained on permissive-licensed OSS; supports all major IDEs with on-premises deployment. | 🔵 | [Website](https://www.tabnine.com) |
+| **Augment Code** | Enterprise AI coding assistant with 200K-token Context Engine for deep codebase understanding. | 🔵 | [Website](https://www.augmentcode.com) |
+| **Qodo** | AI code review and quality platform with multi-agent architecture; test generation, code review, CI/CD enforcement. | 🟣 | [Website](https://www.qodo.ai) |
+| **CodeGeeX** | Open-source multilingual code generation model supporting 20+ languages with VS Code and JetBrains extensions. ~11K+ ⭐ | 🟢 | [GitHub](https://github.com/zai-org/CodeGeeX) |
+| **Tabby** | Self-hosted open-source AI coding assistant (Copilot alternative); runs entirely on your infrastructure. ~25K+ ⭐ | 🟢 | [GitHub](https://github.com/TabbyML/tabby) |
+
+#### AI Coding Platforms / Cloud Agents
+
+Browser-based or cloud-hosted agents that build, test, and deploy autonomously.
+
+| Name | Description | Type | Link |
+|:-----|:-----------|:----:|:----:|
+| **Devin** | First fully autonomous cloud-based AI software engineer; plans, codes, tests, and opens PRs independently. | 🔵 | [Website](https://devin.ai) |
+| **Replit Agent** | Cloud-native AI agent that autonomously builds, tests, and deploys full-stack apps in-browser; 50+ languages. | 🔵 | [Website](https://replit.com/products/agent) |
+| **bolt.new** | AI-powered web dev agent; prompt, run, edit, and deploy full-stack apps directly in the browser via WebContainers. ~15K+ ⭐ | 🟢 | [GitHub](https://github.com/stackblitz/bolt.new) |
+| **bolt.diy** | Community fork of bolt.new with extended features and broader LLM flexibility. ~12K+ ⭐ | 🟢 | [GitHub](https://github.com/stackblitz-labs/bolt.diy) |
+| **Lovable** | Full-stack apps from natural language with built-in Supabase, auth, and one-click deploy; fastest European startup to $20M ARR. | 🔵 | [Website](https://lovable.dev) |
+| **v0** | Vercel's AI platform for generating high-quality React/Next.js UI components from natural language. | 🔵 | [Website](https://v0.dev) |
+| **GitHub Copilot Workspace** | Cloud-based coding environment with plan, brainstorm, and repair agents; included with paid Copilot plans. | 🔵 | [Website](https://githubnext.com/projects/copilot-workspace) |
+| **Firebase Studio** | Google's agentic cloud-based development environment. | 🔵 | [Website](https://firebase.google.com/studio) |
+
+#### Open-Source Coding Agent Frameworks
+
+Frameworks and research projects for building autonomous coding agents.
+
+| Name | Description | Type | Link |
+|:-----|:-----------|:----:|:----:|
+| **OpenHands** | Leading open-source platform for cloud coding agents; consistently top on SWE-bench. Formerly OpenDevin. ~69K+ ⭐ | 🟢 | [GitHub](https://github.com/OpenHands/OpenHands) |
+| **SWE-agent** | Takes a GitHub issue and automatically fixes it using a custom agent-computer interface. [NeurIPS 2024] ~19K+ ⭐ | 🟢 | [GitHub](https://github.com/SWE-agent/SWE-agent) |
+| **Open SWE** | LangChain's async cloud-hosted coding agent framework built on LangGraph with Slack/Linear integration. ~8K+ ⭐ | 🟢 | [GitHub](https://github.com/langchain-ai/open-swe) |
+| **Devika** | Open-source agentic software engineer; breaks down instructions, researches, and writes code. Devin alternative. ~18K+ ⭐ | 🟢 | [GitHub](https://github.com/stitionai/devika) |
+| **AutoCodeRover** | Autonomous program improvement combining LLMs with fault localization for GitHub issue resolution. ~2.8K+ ⭐ | 🟢 | [GitHub](https://github.com/nus-apr/auto-code-rover) |
+| **Agentless** | Simple three-phase approach (localize → repair → validate) to solving software development problems. ~2K+ ⭐ | 🟢 | [GitHub](https://github.com/OpenAutoCoder/Agentless) |
+| **Devon** | Open-source pair programmer SWE agent with code writing, planning, and research; supports Claude, GPT-4, Llama, Ollama. ~3.5K+ ⭐ | 🟢 | [GitHub](https://github.com/entropy-research/Devon) |
+
+### Other Notable Repositories
+
+| Name | Description | Link |
+|:-----|:-----------|:----:|
+| **Prompt Engineering Guide (DAIR.AI)** | The definitive open-source guide and resource hub. 3M+ learners. ~55K+ ⭐ | [GitHub](https://github.com/dair-ai/Prompt-Engineering-Guide) |
+| **Awesome ChatGPT Prompts / Prompts.chat** | World's largest open-source prompt library. 1000s of prompts for all major models. | [GitHub](https://github.com/f/awesome-chatgpt-prompts) |
+| **12-Factor Agents** | Principles for building production-grade LLM-powered software. ~17K+ ⭐ | [GitHub](https://github.com/humanlayer/12-factor-agents) |
+| **NirDiamant/Prompt_Engineering** | 22 hands-on Jupyter Notebook tutorials. ~3K+ ⭐ | [GitHub](https://github.com/NirDiamant/Prompt_Engineering) |
+| **Context Engineering Repository** | First-principles handbook for moving beyond prompt engineering to context design. | [GitHub](https://github.com/davidkimai/Context-Engineering) |
+| **AI Agent System Prompts Library** | Collection of system prompts from production AI coding agents (Claude Code, Gemini CLI, Cline, Aider, Roo Code). | [GitHub](https://github.com/tallesborges/agentic-system-prompts) |
+| **Awesome Vibe Coding** | Curated list of 245+ tools and resources for building software through natural language prompts. | [GitHub](https://github.com/taskade/awesome-vibe-coding) |
+| **OpenAI Cookbook** | Official recipes for prompts, tools, RAG, and evaluations. | [GitHub](https://github.com/openai/openai-cookbook) |
+| **Embedchain** | Framework to create ChatGPT-like bots over your dataset. | [GitHub](https://github.com/embedchain/embedchain) |
+| **ThoughtSource** | Framework for the science of machine thinking. | [GitHub](https://github.com/OpenBioLink/ThoughtSource) |
+| **Promptext** | Extracts and formats code context for AI prompts with token counting. | [GitHub](https://github.com/1broseidon/promptext) |
+| **Price Per Token** | Compare LLM API pricing across 200+ models. | [Website](https://pricepertoken.com/) |
+| **OpenPaw** | CLI tool (`npx pawmode`) that turns Claude Code into a personal assistant by generating system prompts (CLAUDE.md + SOUL.md) with personality, memory, and 38 skill routers. | [GitHub](https://github.com/daxaur/openpaw) |
+| **Think Better** | Open-source CLI that permanently injects 10 structured decision frameworks (MECE, Issue Trees, Pre-Mortems) and 12 cognitive bias detectors into AI assistant prompts. Go, MIT. | [GitHub](https://github.com/HoangTheQuyen/think-better) |
+
+---
+
+## APIs
+💻
+
+### OpenAI
+
+| Model | Context | Price (Input/Output per 1M tokens) | Key Feature |
+|:------|:--------|:-----------------------------------|:------------|
+| GPT-5.2 / 5.2 Thinking | 400K | $1.75 / $14 | Latest flagship, 90% cached discount, configurable reasoning |
+| GPT-5.1 | 400K | $1.25 / $10 | Previous generation flagship |
+| GPT-4.1 / 4.1 mini / nano | 1M | $2 / $8 | Best non-reasoning model, 40% faster and 80% cheaper than GPT-4o |
+| o3 / o3-pro | 200K | Varies | Reasoning models with native tool use |
+| o4-mini | 200K | Cost-efficient | Fast reasoning, best on AIME at its cost class |
+| GPT-OSS-120B / 20B | 128K | $0.03 / $0.30 | First open-weight models, Apache 2.0 |
+
+Key features: Responses API, Agents SDK, Structured Outputs, function calling, prompt caching (90% discount), Batch API (50% discount), MCP support. [Platform Docs](https://platform.openai.com/docs/models)
+
+### Anthropic (Claude)
+
+| Model | Context | Price (Input/Output per 1M tokens) | Key Feature |
+|:------|:--------|:-----------------------------------|:------------|
+| Claude Opus 4.6 | 1M (beta) | $5 / $25 | Most powerful, state-of-the-art coding and agentic tasks |
+| Claude Sonnet 4.5 | 200K | $3 / $15 | Best coding model, 61.4% OSWorld (computer use) |
+| Claude Haiku 4.5 | 200K | Fast tier | Near-frontier, fastest model class |
+| Claude Opus 4 / Sonnet 4 | 200K | $15/$75 (Opus) | Opus: 72.5% SWE-bench, Sonnet 4 powers GitHub Copilot |
+
+Key features: Extended Thinking with tool use, Computer Use, MCP (originated here), prompt caching, Claude Code CLI, available on AWS Bedrock and Google Vertex AI. [API Docs](https://docs.anthropic.com/)
+
+### Google (Gemini)
+
+| Model | Context | Price (Input/Output per 1M tokens) | Key Feature |
+|:------|:--------|:-----------------------------------|:------------|
+| Gemini 3 Pro Preview | 1M | $2 / $12 | Most intelligent Google model, deployed to 2B+ Search users |
+| Gemini 2.5 Pro | 1M | $1.25 / $10 | Best for coding/agentic tasks, thinking model |
+| Gemini 2.5 Flash / Flash-Lite | 1M | $0.30/$1.50 · $0.10/$0.40 | Price-performance leaders |
+
+Key features: Thinking (all 2.5+ models), Google Search grounding, code execution, Live API (real-time audio/video), context caching. [Google AI Studio](https://ai.google.dev/)
+
+### Meta (Llama)
+
+| Model | Architecture | Context | Key Feature |
+|:------|:------------|:--------|:------------|
+| Llama 4 Scout | 109B MoE / 17B active | 10M | Fits single H100, multimodal, open-weight |
+| Llama 4 Maverick | 400B MoE / 17B active, 128 experts | 1M | Beats GPT-4o, open-weight |
+| Llama 3.3 70B | Dense | 128K | Matches Llama 3.1 405B |
+
+Available on 25+ cloud partners, Hugging Face, and inference APIs. [Llama](https://ai.meta.com/llama/)
+
+### Other Notable Providers
+
+| Provider | Description | Link |
+|:---------|:-----------|:----:|
+| **Mistral AI** | Mistral Large 3 (675B MoE), Devstral 2, Ministral 3. Apache 2.0. | [Website](https://mistral.ai) |
+| **DeepSeek** | V3.2 (671B MoE), R1 (reasoning, MIT license). $0.15/$0.75 per 1M tokens. | [Website](https://deepseek.com) |
+| **xAI (Grok)** | Grok 4.1 Fast: 2M context, $0.20/$0.50 per 1M tokens. | [Website](https://x.ai) |
+| **Cohere** | Command A (111B, 256K context), Embed v4, Rerank 4.0. Excels at RAG. | [Website](https://cohere.com) |
+| **Together AI** | 200+ open models with sub-100ms latency. | [Website](https://together.ai) |
+| **Groq** | LPU hardware with ~300+ tokens/sec inference. | [Website](https://groq.com) |
+| **Fireworks AI** | Fast inference with HIPAA + SOC2 compliance. | [Website](https://fireworks.ai) |
+| **OpenRouter** | Unified API for 300+ models from all providers. | [Website](https://openrouter.ai) |
+| **Cerebras** | Wafer-scale chips with best total response time. | [Website](https://cerebras.ai) |
+| **Perplexity AI** | Search-augmented API with citations. | [Website](https://perplexity.ai) |
+| **Amazon Bedrock** | Managed multi-model service with Claude, Llama, Mistral, Cohere. | [Website](https://aws.amazon.com/bedrock/) |
+| **Hugging Face Inference** | Access to open models via API. | [Website](https://huggingface.co/docs/api-inference/index) |
+
+---
+
+## Datasets and Benchmarks
+💾
+
+### Major Benchmarks (2024–2026)
+
+| Name | Description | Link |
+|:-----|:-----------|:----:|
+| **Chatbot Arena / LM Arena** | 6M+ user votes for Elo-rated pairwise LLM comparisons. De facto standard for human preference. | [Website](https://lmarena.ai/) |
+| **MMLU-Pro** | 12,000+ graduate-level questions across 14 domains. NeurIPS 2024 Spotlight. | [GitHub](https://github.com/TIGER-AI-Lab/MMLU-Pro) |
+| **GPQA** | 448 "Google-proof" STEM questions; non-expert validators achieve only 34%. | [arXiv](https://arxiv.org/abs/2311.12022) |
+| **SWE-bench Verified** | Human-validated 500-task subset for real-world GitHub issue resolution. | [Website](https://www.swebench.com/) |
+| **SWE-bench Pro** | 1,865 tasks across 41 professional repos; best models score only ~23%. | [Leaderboard](https://scale.com/leaderboard/swe_bench_pro_public) |
+| **Humanity's Last Exam (HLE)** | 2,500 expert-vetted questions; top AI scores only ~10–30%. | [Website](https://agi.safe.ai/) |
+| **BigCodeBench** | 1,140 coding tasks across 7 domains; AI achieves ~35.5% vs. 97% human success. | [Leaderboard](https://huggingface.co/spaces/bigcode/bigcodebench-leaderboard) |
+| **LiveBench** | Contamination-resistant with frequently updated questions. | [Paper](https://openreview.net/forum?id=sKYHBTAxVa) |
+| **FrontierMath** | Research-level math; AI solves only ~2% of problems. | Research |
+| **ARC-AGI v2** | Abstract reasoning measuring fluid intelligence. | Research |
+| **IFEval** | Instruction-following evaluation with formatting/content constraints. | [arXiv](https://arxiv.org/abs/2311.07911) |
+| **MLE-bench** | OpenAI's ML engineering evaluation via Kaggle-style tasks. | [GitHub](https://github.com/openai/mle-bench) |
+| **PaperBench** | Evaluates AI's ability to replicate 20 ICML 2024 papers from scratch. | [GitHub](https://github.com/openai/preparedness) |
+
+### Leaderboards and Meta-Benchmarks
+
+| Name | Description | Link |
+|:-----|:-----------|:----:|
+| **Hugging Face Open LLM Leaderboard v2** | Evaluates open models on MMLU-Pro, GPQA, IFEval, MATH. | [Leaderboard](https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard) |
+| **Artificial Analysis Intelligence Index v3** | Aggregates 10 evaluations. | [Website](https://artificialanalysis.ai/) |
+| **SEAL by Scale AI** | Hosts SWE-bench Pro and agentic evaluations. | [Leaderboard](https://scale.com/leaderboard) |
+
+### Prompt and Instruction Datasets
+
+| Name | Description | Link |
+|:-----|:-----------|:----:|
+| **P3 (Public Pool of Prompts)** | Prompt templates for 270+ NLP tasks used to train T0 and similar models. | [HuggingFace](https://huggingface.co/datasets/bigscience/P3) |
+| **System Prompts Dataset** | 944 system prompt templates for agent workflows (by Daniel Rosehill, Aug 2025). | [HuggingFace](https://huggingface.co/datasets/danielrosehill/system_prompts) |
+| **OpenAssistant Conversations (OASST)** | 161,443 messages in 35 languages with 461,292 quality ratings. | [HuggingFace](https://huggingface.co/datasets/OpenAssistant/oasst1) |
+| **UltraChat / UltraFeedback** | Large-scale synthetic instruction and preference datasets for alignment training. | HuggingFace |
+| **SoftAge Prompt Engineering Dataset** | 1,000 diverse prompts across 10 categories for benchmarking prompt performance. | HuggingFace |
+| **Text Transformation Prompt Library** | Comprehensive collection of text transformation prompts (May 2025). | HuggingFace |
+| **Writing Prompts** | ~300K human-written stories paired with prompts from r/WritingPrompts. | [Kaggle](https://www.kaggle.com/datasets/ratthachat/writing-prompts) |
+| **Midjourney Prompts** | Text prompts and image URLs scraped from MidJourney's public Discord. | [HuggingFace](https://huggingface.co/datasets/succinctly/midjourney-prompts) |
+| **CodeAlpaca-20k** | 20,000 programming instruction-output pairs. | [HuggingFace](https://huggingface.co/datasets/sahil2801/CodeAlpaca-20k) |
+| **ProPEX-RAG** | Dataset for prompt optimization in RAG workflows. | HuggingFace |
+| **NanoBanana Trending Prompts** | 1,000+ curated AI image prompts from X/Twitter, ranked by engagement. | [GitHub](https://github.com/jau123/nanobanana-trending-prompts) |
+
+### Red Teaming and Adversarial Datasets
+
+| Name | Description | Link |
+|:-----|:-----------|:----:|
+| **HarmBench** | 510 harmful behaviors across standard, contextual, copyright, and multimodal categories. | [Website](https://safetyprompts.com/) |
+| **JailbreakBench** | Open robustness benchmark for jailbreaking with 100 prompts. | Research |
+| **AgentHarm** | 110 malicious agent tasks across 11 harm categories. | [arXiv](https://arxiv.org/abs/2410.09024) |
+| **DecodingTrust** | 243,877 prompts evaluating trustworthiness across 8 perspectives. | Research |
+| **SafetyPrompts.com** | Aggregator tracking 50+ safety/red-teaming datasets. | [Website](https://safetyprompts.com/) |
+
+---
+
+## Models
+🧠
+
+### Frontier Models (2025–2026)
+
+| Model | Provider | Context | Key Strength |
+|:------|:---------|:--------|:-------------|
+| **GPT-5.2** | OpenAI | 400K | General intelligence, 100% AIME 2025 |
+| **Claude Opus 4.6** | Anthropic | 1M (beta) | Coding, agentic tasks, extended thinking |
+| **Gemini 3 Pro** | Google | 1M | #1 LMArena (~1500 Elo), multimodal |
+| **Grok 4.1** | xAI | 2M | #2 LMArena (1483 Elo), low hallucination |
+| **Mistral Large 3** | Mistral AI | 256K | Best open-weight (675B MoE/41B active), Apache 2.0 |
+| **DeepSeek-V3.2** | DeepSeek | 128K | Best value (671B MoE/37B active), MIT license |
+| **Llama 4 Maverick** | Meta | 1M | Beats GPT-4o (400B MoE/17B active), open-weight |
+
+### Reasoning Models
+
+| Model | Key Detail |
+|:------|:-----------|
+| **OpenAI o3 / o3-pro** | 87.7% GPQA Diamond. Native tool use. |
+| **OpenAI o4-mini** | Best AIME at its cost class with visual reasoning. |
+| **DeepSeek-R1 / R1-0528** | Open-weight, RL-trained. 87.5% on AIME 2025. MIT license. |
+| **QwQ (Qwen with Questions)** | 32B reasoning model. Apache 2.0. Comparable to R1. |
+| **Gemini 2.5 Pro/Flash (Thinking)** | Built-in reasoning with configurable thinking budget. |
+| **Claude Extended Thinking** | Hybrid mode with visible chain-of-thought and tool use. |
+| **Phi-4 Reasoning / Plus** | 14B reasoning models rivaling much larger models. Open-weight. |
+| **GPT-OSS-120B** | OpenAI's open-weight with CoT. Near-parity with o4-mini. Apache 2.0. |
+
+### Notable Open-Source Models
+
+| Model | Provider | Key Detail |
+|:------|:---------|:-----------|
+| **Qwen3-235B-A22B** | Alibaba | Flagship MoE. Strong reasoning/code/multilingual. Apache 2.0. Most downloaded family on HuggingFace. |
+| **Gemma 3** | Google | 270M to 27B. Multimodal. 128K context. 140+ languages. |
+| **OLMo 2/3** | Allen AI | Fully open (data, code, weights, logs). OLMo 2 32B surpasses GPT-3.5. Apache 2.0. |
+| **SmolLM3-3B** | Hugging Face | Outperforms Llama-3.2-3B. Dual-mode reasoning. 128K context. |
+| **Kimi K2** | Moonshot AI | 32B active. Open-weight. Tailored for coding/agentic use. |
+| **Llama 4 Scout** | Meta | 109B MoE/17B active. 10M token context. Fits single H100. |
+
+### Code-Specialized Models
+
+| Model | Key Detail |
+|:------|:-----------|
+| **Qwen3-Coder (480B-A35B)** | 69.6% SWE-bench — milestone for open-source coding. 256K context. Apache 2.0. |
+| **Devstral 2 (123B)** | 72.2% SWE-bench Verified. 7x more cost-efficient than Claude Sonnet. |
+| **Codestral 25.01** | Mistral's code model. 80+ languages. Fill-in-the-Middle support. |
+| **DeepSeek-Coder-V2** | 236B MoE / 21B active. 338 programming languages. |
+| **Qwen 2.5-Coder** | 7B/32B. 92 programming languages. 88.4% HumanEval. Apache 2.0. |
+
+### Foundational Models (Historical Reference)
+
+These models established key concepts but are largely superseded for practical use:
+
+| Model | Provider | Significance |
+|:------|:---------|:-------------|
+| GLM-130B | Tsinghua | Open bilingual English/Chinese LLM (2023) |
+| Falcon 180B | TII | Large open generative model (2023) |
+| Mixtral 8x7B | Mistral AI | Pioneered MoE architecture for open models (2023) |
+| GPT-NeoX-20B | EleutherAI | Early open autoregressive LLM |
+| GPT-J-6B | EleutherAI | Early open causal language model |
+
+---
+
+## AI Content Detectors
+🔎
+
+### Leading Commercial Detectors
+
+| Name | Accuracy | Key Feature | Link |
+|:-----|:---------|:------------|:----:|
+| **GPTZero** | 99% claimed | 10M+ users, #1 on G2 (2025). Detects GPT-4/5, Gemini, Claude, Llama. Free tier available. | [Website](https://gptzero.me) |
+| **Originality.ai** | 98–100% (peer-reviewed) | Consistently rated most accurate. Combines AI detection + plagiarism + fact checking. From $14.95/month. | [Website](https://originality.ai) |
+| **Turnitin AI Detection** | 98%+ on unmodified AI text | Dominant in academia. Launched AI bypasser/humanizer detection (Aug 2025). Institutional licensing. | [Website](https://www.turnitin.com/solutions/topics/ai-writing/) |
+| **Copyleaks** | 99%+ claimed | Enterprise tool detecting AI in 30+ languages. LMS integrations. | [Website](https://copyleaks.com) |
+| **Winston AI** | 99.98% claimed | OCR for scanned documents, AI image/deepfake detection. 11 languages. | [Website](https://gowinston.ai) |
+| **Pangram Labs** | 99.3% (COLING 2025) | Highest score in COLING 2025 Shared Task. 100% TPR on "humanized" text. 97.7% adversarial robustness. | [Website](https://www.pangram.com) |
+
+### Free and Research Detectors
+
+| Name | Description | Link |
+|:-----|:-----------|:----:|
+| **Binoculars** | Open-source research detector using cross-perplexity between two LLMs. | [arXiv](https://arxiv.org/abs/2401.12070) |
+| **DetectGPT / Fast-DetectGPT** | Statistical method comparing log-probabilities of original text vs. perturbations. | [arXiv](https://arxiv.org/abs/2301.11305) |
+| **Openai Detector** | AI classifier for indicating AI-written text (OpenAI Detector Python wrapper)  | [[GitHub]](https://github.com/promptslab/openai-detector) |
+| **Sapling AI Detector** | Free browser-based detector (up to 2,000 chars). 97% accuracy in some studies. | [Website](https://sapling.ai/) |
+| **QuillBot AI Detector** | Free, no sign-up required. | [Website](https://quillbot.com/ai-content-detector) |
+| **Writer AI Content Detector** | Free tool with color-coded results. | [Website](https://writer.com/ai-content-detector/) |
+| **ZeroGPT** | Popular free detector evaluated in multiple academic studies. | [Website](https://www.zerogpt.com/) |
+
+### Watermarking Approaches
+
+| Name | Description | Link |
+|:-----|:-----------|:----:|
+| **SynthID (Google DeepMind)** | Watermarking for AI text, images, and audio via statistical token sampling. Deployed in Google products. | [Website](https://deepmind.google/technologies/synthid/) |
+| **OpenAI Text Watermarking** | Developed but still experimental as of 2025. Research shows fragility concerns. | Experimental |
+
+**Important caveat:** No detector claims 100% accuracy. Mixed human/AI text remains hardest to detect (50–70% accuracy). Adversarial robustness varies widely. The AI detection market is projected to grow from ~$2.3B (2025) to $15B by 2035.
+
+---
+
+## Books
+📖
+
+### Prompt Engineering
+
+| Title | Author(s) | Publisher | Year |
+|:------|:----------|:---------|:-----|
+| **Prompt Engineering for LLMs** | John Berryman & Albert Ziegler | O'Reilly | 2024 |
+| **Prompt Engineering for Generative AI** | James Phoenix & Mike Taylor | O'Reilly | 2024 |
+| **Prompt Engineering for LLMs** | Thomas R. Caldwell | Independent | 2025 |
+
+### LLM Application Development
+
+| Title | Author(s) | Publisher | Year |
+|:------|:----------|:---------|:-----|
+| **AI Engineering: Building Applications with Foundation Models** | Chip Huyen | O'Reilly | 2025 |
+| **Build a Large Language Model (From Scratch)** | Sebastian Raschka | Manning | 2024 |
+| **Building LLMs for Production** | Louis-François Bouchard & Louie Peters | O'Reilly | 2024 |
+| **LLM Engineer's Handbook** | Paul Iusztin & Maxime Labonne | Packt | 2024 |
+| **The Hundred-Page Language Models Book** | Andriy Burkov | Self-Published | 2025 |
+
+### AI Agents
+
+| Title | Author(s) | Publisher | Year |
+|:------|:----------|:---------|:-----|
+| **Building Applications with AI Agents** | Michael Albada | O'Reilly | 2025 |
+| **AI Agents and Applications** | Roberto Infante | Manning | 2025 |
+| **AI Agents in Action** | Micheal Lanham | Manning | 2025 |
+
+### Production, Reliability, and Security
+
+| Title | Author(s) | Publisher | Year |
+|:------|:----------|:---------|:-----|
+| **LLMs in Production** | Christopher Brousseau & Matthew Sharp | Manning | 2025 |
+| **Building Reliable AI Systems** | Rush Shahani | Manning | 2025 |
+| **The Developer's Playbook for LLM Security** | Steve Wilson | O'Reilly | 2024 |
+
+---
+
+## Courses
+👩‍🏫
+
+### Free Short Courses
+
+- [ChatGPT Prompt Engineering for Developers](https://www.deeplearning.ai/short-courses/chatgpt-prompt-engineering-for-developers/) — Co-taught by Andrew Ng and OpenAI's Isa Fulford. The foundational starting point. (DeepLearning.AI)
+- [Building Systems with the ChatGPT API](https://www.deeplearning.ai/short-courses/building-systems-with-chatgpt/) — Multi-step LLM system design for production. (DeepLearning.AI)
+- [AI Agents in LangGraph](https://www.deeplearning.ai/short-courses/ai-agents-in-langgraph/) — Agentic dataflows with tool use and research agents. (DeepLearning.AI)
+- [Building Agentic RAG with LlamaIndex](https://www.deeplearning.ai/short-courses/building-agentic-rag-with-llamaindex/) — RAG research agent construction. (DeepLearning.AI)
+- [Functions, Tools and Agents with LangChain](https://www.deeplearning.ai/short-courses/functions-tools-agents-langchain/) — Function calling and agent building. (DeepLearning.AI)
+- [Prompt Engineering for Vision Models](https://www.deeplearning.ai/short-courses/prompt-engineering-for-vision-models/) — Visual prompting techniques. (DeepLearning.AI)
+
+### University and Platform Courses
+
+- [Prompt Engineering Specialization (Vanderbilt)](https://www.coursera.org/specializations/prompt-engineering) — 3-course series by Dr. Jules White covering foundational to advanced PE. (Coursera)
+- [Generative AI with LLMs (DeepLearning.AI + AWS)](https://www.coursera.org/learn/generative-ai-with-llms) — LLM lifecycle, transformers, RLHF, deployment. (Coursera)
+- [Stanford CS336: Language Modeling from Scratch](https://cs336.stanford.edu/) — Build an LLM end-to-end. (Stanford, 2024–2026)
+- [MIT 6.S191: Introduction to Deep Learning](https://introtodeeplearning.com/) — Annual course including LLMs and generative AI. (MIT, 2024–2026)
+- [The Complete Prompt Engineering for AI Bootcamp](https://www.udemy.com/course/prompt-engineering-for-ai/) — Covers GPT-5, DSPy, LangGraph, agent architectures. 58K+ ratings. (Udemy, updated Feb 2026)
+
+### Free Platform Courses
+
+- [Google Prompting Essentials](https://grow.google/prompting-essentials/) — 5-step prompt design, meta-prompting, Gemini. Under 6 hours.
+- [Microsoft Azure AI Fundamentals: Generative AI](https://learn.microsoft.com/en-us/training/paths/introduction-generative-ai/) — Free learning path covering LLMs, prompts, agents, Azure OpenAI.
+- [Hugging Face LLM Course](https://huggingface.co/learn/llm-course/chapter1/1) — Community-driven course covering transformers, fine-tuning, building reasoning models.
+- [Hugging Face AI Agents Course](https://huggingface.co/learn) — Agent theory to practice. 100K+ registered students.
+
+### Learn Prompting Courses
+
+- [ChatGPT for Everyone](https://learnprompting.org/courses/chatgpt-for-everyone)
+- [Introduction to Prompt Engineering](https://learnprompting.org/courses/introduction_to_prompt_engineering)
+- [Advanced Prompt Engineering](https://learnprompting.org/courses/advanced-prompt-engineering)
+- [Introduction to Prompt Hacking](https://learnprompting.org/courses/intro-to-prompt-hacking)
+- [Advanced Prompt Hacking](https://learnprompting.org/courses/advanced-prompt-hacking)
+- [Introduction to Generative AI Agents for Business Professionals](https://learnprompting.org/courses/introduction-to-agents)
+- [AI Safety](https://learnprompting.org/courses/ai-safety)
+
+---
+
+## Tutorials and Guides
+📚
+
+### Official Provider Guides
+
+- [OpenAI Prompt Engineering Guide](https://platform.openai.com/docs/guides/prompt-engineering) — Comprehensive, covering GPT-4.1/5 prompting, reasoning models, structured outputs, agentic workflows. Continuously updated.
+- [OpenAI GPT-4.1 Prompting Guide](https://cookbook.openai.com/articles/gpt-4-1-prompting-guide) [2025] — Structured agent-like prompt design: goal persistence, tool integration, long-context processing.
+- [Anthropic Prompt Engineering Overview](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview) — Iterative prompt design, XML tags, chain-of-thought, role assignment. Includes prompt generator.
+- [Anthropic Claude 4 Best Practices](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/claude-4-best-practices) [2025–2026] — Parallel tool execution, thinking capabilities, image processing.
+- [Anthropic: Effective Context Engineering for AI Agents](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents) [2025] — The evolution from prompt engineering to context engineering: agent state, memory, tools, MCP.
+- [Google Gemini Prompting Strategies](https://ai.google.dev/docs/prompt_best_practices) — Multimodal prompting for Gemini via Vertex AI and AI Studio.
+- [Microsoft Prompt Engineering in Azure AI Studio](https://learn.microsoft.com/en-us/azure/ai-services/openai/concepts/prompt-engineering) — Tool calling, function design, few-shot prompting, prompt chaining.
+
+### Community and Independent Guides
+
+- [Prompt Engineering Guide (DAIR.AI / promptingguide.ai)](https://www.promptingguide.ai/) — Most comprehensive open-source guide. 18+ techniques, model-specific guides, research papers. 3M+ learners. Now includes context engineering.
+- [Learn Prompting (learnprompting.org)](https://learnprompting.org/) — Structured free platform. Beginner to advanced PE, AI security, HackAPrompt competition.
+- [IBM 2026 Guide to Prompt Engineering](https://www.ibm.com/think/prompt-engineering) [2026] — Curated tools, tutorials, real-world examples with Python code.
+- [Anthropic Interactive Tutorial](https://github.com/anthropics/prompt-eng-interactive-tutorial) — 9-chapter Jupyter notebook course with hands-on exercises.
+- [Lilian Weng's Prompt Engineering Guide](https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/) [2023] — Highly respected technical blog from OpenAI researcher.
+- [Google Prompt Engineering Guide (68-page PDF)](https://www.reddit.com/r/PromptEngineering/comments/1kggmh0/google_dropped_a_68page_prompt_engineering_guide/) [2025] — Internal-style best-practice guide for Gemini with concrete patterns.
+- [DigitalOcean: Prompt Engineering Best Practices](https://www.digitalocean.com/resources/articles/prompt-engineering-best-practices) [2025] — Updated guide summarizing techniques: few-shot, chain-of-thought, role prompting, etc.
+- [Aakash Gupta: Prompt Engineering in 2025](https://news.aakashg.com) [2025] — Practical guide with wisdom from shipping AI at OpenAI, Shopify, and Google.
+- [Best practices for prompt engineering with OpenAI API](https://help.openai.com/en/articles/6654000-best-practices-for-prompt-engineering-with-openai-api) — OpenAI's introductory best practices.
+- [OpenAI Cookbook](https://github.com/openai/openai-cookbook) — Official recipes for function calling, RAG, evaluation, and complex workflows.
+- [Microsoft Prompt Engineering Docs](https://microsoft.github.io/prompt-engineering) — Microsoft's open prompt engineering resources.
+- [DALLE Prompt Book](https://dallery.gallery/the-dalle-2-prompt-book) — Visual guide for text-to-image prompting.
+- [Best 100+ Stable Diffusion Prompts](https://mpost.io/best-100-stable-diffusion-prompts-the-most-beautiful-ai-text-to-image-prompts) — Community-curated image generation prompts.
+- [Vibe Engineering (Manning)](https://www.manning.com/books/vibe-engineering) — Book by Tomasz Lelek & Artur Skowronski on building software through natural language prompts.
+
+---
+
+## Videos
+🎥
+
+- [Andrej Karpathy: "Deep Dive into LLMs" & "How I Use LLMs"](https://www.youtube.com/@AndrejKarpathy) [2024–2025] — Two of the most influential AI videos of 2024–2025. Comprehensive technical deep dive followed by practical usage patterns.
+- [Karpathy: "Software in the Era of AI" (YC AI Startup School)](https://karpathy.ai/) [2025] — Coined "vibe coding" (Feb 2025) and championed "context engineering" (Jun 2025).
+- [Karpathy: Neural Networks: Zero to Hero](https://www.youtube.com/@AndrejKarpathy) [2023–2024] — Full lecture series building from backpropagation to GPT.
+- [3Blue1Brown: Neural Networks Series](https://www.youtube.com/@3blue1brown) [Updated 2024] — Iconic animated visual explanations of transformers and attention mechanisms. 7M+ subscribers.
+- [AI Explained](https://www.youtube.com/@aiexplained-official) [2024–2025] — Long-form analysis breaking down papers, model capabilities, and PE developments.
+- [Sam Witteveen](https://www.youtube.com/@samwitteveen) [2024–2025] — Practical tutorials on prompt engineering, LangChain, RAG, and agents.
+- [Matthew Berman](https://www.youtube.com/@matthew_berman) [2024–2025] — Popular channel covering model releases and practical LLM usage. 600K+ subscribers.
+- [DeepLearning.AI YouTube](https://www.youtube.com/@Deeplearningai) [2024–2026] — Structured lessons, course previews, and Andrew Ng talks on agents and AI careers.
+- [Lex Fridman Podcast (AI Episodes)](https://www.youtube.com/@lexfridman) [2024–2025] — Long-form interviews with Altman, Hinton, Amodei on LLMs, prompting, and safety.
+- [ICSE 2025: AIware Prompt Engineering Tutorial](https://conf.researchr.org/details/icse-2025/icse-2025-tutorials/) [2025] — Conference tutorial covering prompt patterns, fragility, anti-patterns, and optimization DSLs.
+- [CMU Advanced NLP 2022: Prompting](https://youtube.com/watch?v=5ef83Wljm-M) — Foundational academic lecture on prompting methods.
+- [ChatGPT: 5 Prompt Engineering Secrets For Beginners](https://www.youtube.com/watch?v=2zg3V66-Fzs) — Accessible intro for beginners.
+
+---
+
+## Communities
+🤝
+
+### Discord Servers
+
+- [Learn Prompting](https://learnprompting.org/discord) — 40,000+ members. Largest PE Discord with courses, hackathons, HackAPrompt competitions.
+- [PromptsLab Discord](https://discord.gg/m88xfYMbK6)  - Community
+- [Midjourney](https://discord.gg/midjourney) — 1M+ members. Primary hub for text-to-image prompt sharing.
+- [OpenAI Discord](https://discord.gg/openai) — Official community with channels for GPTs, Sora, DALL-E, and API help.
+- [Anthropic Discord](https://discord.gg/anthropic) — Official Claude community for AI development collaboration.
+- [Hugging Face Discord](https://discord.gg/huggingface) — Model discussions, library support, community events.
+- [FlowGPT](https://flowgpt.com/) — 33K+ members. 100K+ prompts across ChatGPT, DALL-E, Stable Diffusion, Claude.
+
+### Reddit
+
+- [r/PromptEngineering](https://reddit.com/r/PromptEngineering) — Dedicated subreddit for prompt crafting techniques and discussions.
+- [r/ChatGPT](https://reddit.com/r/ChatGPT) — 10M+ members. Primary hub for ChatGPT users and prompt sharing.
+- [r/LocalLLaMA](https://reddit.com/r/LocalLLaMA) — Highly technical community for running open-source LLMs locally.
+- [r/ClaudeAI](https://reddit.com/r/ClaudeAI) — Anthropic's Claude community: prompt sharing, API tips, model comparisons.
+- [r/MachineLearning](https://reddit.com/r/MachineLearning) — Academic-oriented ML research discussions.
+- [r/OpenAI](https://reddit.com/r/OpenAI) — OpenAI product and API discussions.
+- [r/StableDiffusion](https://reddit.com/r/StableDiffusion) — 450K+ members for AI art prompting and workflows.
+- [r/ChatGPTPromptGenius](https://reddit.com/r/ChatGPTPromptGenius) — 35K+ members sharing and refining prompts.
+
+
+### Forums and Platforms
+
+- [OpenAI Developer Community](https://community.openai.com/) — Official forum for API help, best practices, project sharing.
+- [Hugging Face Community](https://huggingface.co/) — Hub for open-source AI collaboration.
+- [DeepLearning.AI Community](https://community.deeplearning.ai/) — Forum for learners discussing courses and AI careers.
+- [LessWrong](https://www.lesswrong.com/) — In-depth technical posts on AI capabilities and safety.
+- [AI Alignment Forum](https://www.alignmentforum.org/) — Specialized alignment research discussions.
+- [CivitAI](https://civitai.com/) — Generative AI creators platform for sharing models, LoRAs, and prompts.
+
+### GitHub Organizations
+
+- [LangChain](https://github.com/langchain-ai) — Open-source LLM app framework. 100K+ stars.
+- [Promptslab](https://github.com/promptslab)  — Generative Models | Prompt-Engineering | LLMs 
+- [Hugging Face](https://github.com/huggingface) — Central hub: Transformers, Diffusers, Datasets, TRL.
+- [DSPy (Stanford NLP)](https://github.com/stanfordnlp/dspy) — Growing community for systematic prompt optimization.
+- [OpenAI](https://github.com/openai) — Open-source models, benchmarks, and tools.
+
+---
+
+<!-- AUTORESEARCH-START -->
+## 🔬 Autonomous Research & Self-Improving Agents
+> Auto-synced from [awesome-autoresearch](https://github.com/alvinunreal/awesome-autoresearch) · Last synced: 2026-07-22
+
+### General-Purpose Descendants
+
+- [kayba-ai/recursive-improve](https://github.com/kayba-ai/recursive-improve) — Recursive self-improvement framework where agents capture execution traces, analyze failure patterns, and apply targeted fixes with keep-or-revert evaluation.
+- [vukrosic/auto-research](https://github.com/vukrosic/auto-research) — Docs-only control plane for an open autonomous AI research lab — file-based operating model for human direction and agent execution.
+- [uditgoenka/autoresearch](https://github.com/uditgoenka/autoresearch) — Claude Code skill that generalizes autoresearch into a reusable loop for software, docs, security, shipping, debugging, and other measurable goals.
+- [leo-lilinxiao/codex-autoresearch](https://github.com/leo-lilinxiao/codex-autoresearch) — Codex-native autoresearch skill with resume support, lessons across runs, optional parallel experiments, and mode-specific workflows.
+- [SeeleAI/Thoth](https://github.com/SeeleAI/Thoth) — Dashboard-first Claude Code and Codex runtime for autoresearch, with durable runs, locked work items, visible ledgers, and reviewable verdicts.
+- [supratikpm/gemini-autoresearch](https://github.com/supratikpm/gemini-autoresearch) — Gemini CLI skill that generalises autoresearch to any measurable goal. Gemini-native: uses Google Search grounding as a live verification source inside the loop, true headless overnight mode via --yolo --prompt, and 1M token context. Also works in Antigravity IDE via .agents/skills/.
+- [davebcn87/pi-autoresearch](https://github.com/davebcn87/pi-autoresearch) — `pi` extension plus dashboard for persistent experiment loops, live metrics, confidence tracking, and resumable autoresearch sessions.
+- [drivelineresearch/autoresearch-claude-code](https://github.com/drivelineresearch/autoresearch-claude-code) — Claude Code plugin/skill port of `pi-autoresearch`, with a clean experiment-loop workflow and a concrete biomechanics case study.
+- [greyhaven-ai/autocontext](https://github.com/greyhaven-ai/autocontext) — Closed-loop control plane for repeated agent improvement, with evaluation, persistent knowledge, staged validation, and optional distillation into cheaper local runtimes.
+- [Necmttn/ax](https://github.com/Necmttn/ax) — Local retro loop for AI coding agents: captures session traces, turns repeated friction into proposals, and tracks accepted fixes as experiments.
+- [jmilinovich/goal-md](https://github.com/jmilinovich/goal-md) — Generalizes autoresearch into a `GOAL.md` pattern for repos where the agent must first construct a measurable fitness function before it can optimize.
+- [james-s-tayler/lazy-developer](https://github.com/james-s-tayler/lazy-developer) — Claude Code skill that orchestrates autoresearch across a prioritized sequence of optimization goals (coverage, test speed, build speed, complexity, LOC, performance) using GOAL.md as the engine. Supports standalone and Ralph Mode multi-instance execution.
+- [mutable-state-inc/autoresearch-at-home](https://github.com/mutable-state-inc/autoresearch-at-home) — Collaborative fork of upstream autoresearch that adds experiment claiming, shared best-config syncing, hypothesis exchange, and swarm-style coordination across many single-GPU agents.
+- [zkarimi22/autoresearch-anything](https://github.com/zkarimi22/autoresearch-anything) — Generalizes autoresearch to **any measurable metric** — system prompts, API performance, landing pages, test suites, config tuning, SQL queries. "If you can measure it, you can optimize it."
+- [Entrpi/autoresearch-everywhere](https://github.com/Entrpi/autoresearch-everywhere) — Cross-platform expansion that auto-detects hardware config and starts the loop. The "glue and generalization" half of autoresearch.
+- [ShengranHu/ADAS](https://github.com/ShengranHu/ADAS) — **Automated Design of Agentic Systems** — ICLR 2025. Meta-agents that invent novel agent architectures by programming them in code.
+- [MaximeRobeyns/self_improving_coding_agent](https://github.com/MaximeRobeyns/self_improving_coding_agent) — **SICA**: Self-Improving Coding Agent that edits its own codebase. ICLR 2025 Workshop paper demonstrating scaffold-level self-improvement on coding benchmarks.
+- [peterskoett/self-improving-agent](https://github.com/peterskoett/self-improving-agent) — Alternative self-improving agent architecture with reflection and meta-learning cycles.
+- [metauto-ai/HGM](https://github.com/metauto-ai/HGM) — **Huxley-Gödel Machine** for coding agents — applies self-improvement to SWE-bench performance via meta-level optimization.
+- [gepa-ai/gepa](https://github.com/gepa-ai/gepa) — **GEPA (Genetic-Pareto)** — ICLR 2026 Oral. Reflective prompt evolution that outperforms RL (GRPO) on benchmarks. Optimizes any textual parameters against any metric using natural language reflection.
+- [sentient-agi/EvoSkill](https://github.com/sentient-agi/EvoSkill) — Automated skill discovery for coding agents: evolves reusable skills and prompts from failed trajectories against benchmarks, with support for Claude Code, Codex CLI, OpenCode, OpenHands, and Goose.
+- [MrTsepa/autoevolve](https://github.com/MrTsepa/autoevolve) — GEPA-inspired autoresearch for self-play: mutate code strategies, evaluate head-to-head, rate with Elo/Bradley-Terry, branch from the Pareto front. Agent reads match traces to target mutations. Works as a Claude Code skill.
+- [HKUDS/ClawTeam](https://github.com/HKUDS/ClawTeam) — Agent swarm intelligence for autoresearch — spawns parallel GPU research directions, distributes work across agents, aggregates results.
+- [Orchestra-Research/AI-Research-SKILLs](https://github.com/Orchestra-Research/AI-Research-SKILLs) — Comprehensive skill library including autoresearch orchestration with two-loop architecture (inner optimization + outer synthesis).
+- [WecoAI/aideml](https://github.com/WecoAI/aideml) — **AIDE**: Tree-search ML engineering agent that autonomously improves model performance via iterative code generation and evaluation.
+- [weco.ai](https://weco.ai) — **Weco**: Cloud platform for AIDE with observability, experiment tracking, and managed runs — brings the autoresearch loop into production.
+
+### Research-Agent Systems
+
+- [aiming-lab/AutoResearchClaw](https://github.com/aiming-lab/AutoResearchClaw) — End-to-end research pipeline that turns a topic into literature review, experiments, analysis, peer review, and paper drafts; broader than autoresearch, but clearly in the same lineage.
+- [OpenRaiser/NanoResearch](https://github.com/OpenRaiser/NanoResearch) — End-to-end autonomous research engine that plans experiments, generates code, runs jobs locally or on SLURM, analyzes real results, and writes papers grounded in those outputs.
+- [kaust-ark/ARK](https://github.com/kaust-ark/ARK) — **ARK (Automatic Research Kit)**: idea + venue → paper pipeline orchestrating 6 agents — proposal analysis, literature search, Slurm experiments, LaTeX drafting, iterative peer review. Controlled via CLI, web dashboard, or Telegram.
+- [wanshuiyin/Auto-claude-code-research-in-sleep](https://github.com/wanshuiyin/Auto-claude-code-research-in-sleep) — Markdown-first research workflows for Claude Code and other agents, centered on autonomous literature review, experiments, paper iteration, and cross-model critique.
+- [skyllwt/AutoSci](https://github.com/skyllwt/AutoSci) — Wiki-centric full-lifecycle research platform built on Claude Code, realizing Karpathy's LLM-Wiki vision. 20+ skills cover the full loop: ingest → ideate → novelty check → experiment design / run / eval → paper writing. Research state lives in a structured knowledge wiki with an interactive graph.
+- [Sibyl-Research-Team/AutoResearch-SibylSystem](https://github.com/Sibyl-Research-Team/AutoResearch-SibylSystem) — Fully autonomous AI scientist built on Claude Code, with explicit AutoResearch lineage, multi-agent research iteration, GPU experiment execution, and a self-evolving outer loop.
+- [eimenhmdt/autoresearcher](https://github.com/eimenhmdt/autoresearcher) — Early open-source package for automating scientific workflows, currently centered on literature-review generation with an ambition toward broader autonomous research.
+- [hyperspaceai/agi](https://github.com/hyperspaceai/agi) — Distributed, peer-to-peer research network where autonomous agents run experiments, gossip findings, maintain CRDT leaderboards, and archive results to GitHub across multiple research domains.
+- [Human-Agent-Society/CORAL](https://github.com/Human-Agent-Society/CORAL) — **CORAL**: Autonomous multi-agent evolution for open-ended discovery ([arXiv:2604.01658](https://arxiv.org/abs/2604.01658)). Long-running agents with shared persistent memory, asynchronous execution, and heartbeat-based interventions; SOTA on 10 math/algorithmic/systems tasks.
+- [SakanaAI/AI-Scientist](https://github.com/SakanaAI/AI-Scientist) — **The AI Scientist**: First comprehensive system for fully automatic scientific discovery. From idea generation to paper writing with minimal human supervision.
+- [SakanaAI/AI-Scientist-v2](https://github.com/SakanaAI/AI-Scientist-v2) — Workshop-level automated scientific discovery via agentic tree search. Removes template dependency from v1, generalizes across research domains.
+- [AweAI-Team/AiScientist](https://github.com/AweAI-Team/AiScientist) — **AiScientist**: long-horizon ML research lab with hierarchical orchestration and File-as-Bus coordination — workspace files act as the durable system of record. Drives autonomous paper-reproduction (PaperBench) and competition-style MLE-Bench iteration loops under fixed compute/time budgets. ([arXiv 2604.13018](https://arxiv.org/abs/2604.13018))
+- [HKUDS/AI-Researcher](https://github.com/HKUDS/AI-Researcher) — NeurIPS 2025 paper. Full end-to-end research automation: hypothesis → experiments → manuscript → peer review. Production version at [novix.science](https://novix.science/chat).
+- [openags/Auto-Research](https://github.com/openags/Auto-Research) — **OpenAGS**: Orchestrates a team of AI agents across the full research lifecycle — lit review, hypothesis generation, experiments, manuscript writing, and peer review.
+- [SamuelSchmidgall/AgentLaboratory](https://github.com/SamuelSchmidgall/AgentLaboratory) — End-to-end autonomous research workflow: idea → literature review → experiments → report. Supports both autonomous and co-pilot modes.
+- [AgentRxiv](https://agentrxiv.github.io/) — Collaborative autonomous research framework where agent laboratories share a preprint server to build on each other's work iteratively.
+- [JinheonBaek/ResearchAgent](https://github.com/JinheonBaek/ResearchAgent) — Iterative research idea generation over scientific literature with LLMs. Multi-agent review and feedback loops.
+- [du-nlp-lab/MLR-Copilot](https://github.com/du-nlp-lab/MLR-Copilot) — Autonomous ML research framework — generates ideas, implements experiments, analyzes results.
+- [MASWorks/ML-Agent](https://github.com/MASWorks/ML-Agent) — Reinforcing LLM agents for autonomous ML engineering. Learns from trial and error to improve model performance.
+- [PouriaRouzrokh/LatteReview](https://github.com/PouriaRouzrokh/LatteReview) — Low-code Python package for **automated systematic literature reviews** via AI-powered agents.
+- [LitLLM/LitLLM](https://github.com/LitLLM/LitLLM) — AI-powered literature review assistant using RAG for accurate, well-structured related-work sections in academic writing.
+- [Agent Laboratory](https://agentlaboratory.github.io/) — Three-phase research pipeline: Literature Review → Experimentation → Report Writing, with specialized agents for each phase.
+- [happyhappy-jun/writing-driven-autoresearch](https://github.com/happyhappy-jun/writing-driven-autoresearch) — Autoresearch-style harness that keeps a submittable paper from the first minute and drives every experiment from the claims in that draft, looping modify → measure → verify → revise. 1st place at the [Ralphthon@ICML 2026](https://luma.com/hjuo7auc) autonomous-research hackathon.
+- [AutoResearch-Factory/Agon](https://github.com/AutoResearch-Factory/Agon) — End-to-end research orchestrator built on one cornerstone principle, Prompt Economy (reusable loops, not one-off prompts), plus five supporting rules; runs scientist/coder/auditor loops across 10+ disciplines, same reusable-loop lineage as autoresearch but scaled to full research programs.
+
+### Platform Ports & Hardware Forks
+
+- [gianfrancopiana/openclaw-autoresearch](https://github.com/gianfrancopiana/openclaw-autoresearch) — OpenClaw port of pi-autoresearch; autonomous experiment loop for any optimization target with statistical confidence scoring.
+- [miolini/autoresearch-macos](https://github.com/miolini/autoresearch-macos) — Widely adopted macOS fork that adapts upstream autoresearch for Apple Silicon / MPS while preserving the original loop shape.
+- [trevin-creator/autoresearch-mlx](https://github.com/trevin-creator/autoresearch-mlx) — MLX-native Apple Silicon port that keeps the upstream fixed-budget `val_bpb` loop while removing the PyTorch/CUDA dependency entirely.
+- [jsegov/autoresearch-win-rtx](https://github.com/jsegov/autoresearch-win-rtx) — Windows-native RTX fork focused on consumer NVIDIA GPUs, with explicit VRAM floors and a practical desktop setup path.
+- [iii-hq/n-autoresearch](https://github.com/iii-hq/n-autoresearch) — Multi-GPU autoresearch infrastructure with structured experiment tracking, adaptive search strategy, crash recovery, and queryable orchestration around the classic `train.py` loop.
+- [lucasgelfond/autoresearch-webgpu](https://github.com/lucasgelfond/autoresearch-webgpu) — Browser/WebGPU port that lets agents generate training code, run experiments in-browser, and feed results back into the loop without a Python setup.
+- [tonitangpotato/autoresearch-engram](https://github.com/tonitangpotato/autoresearch-engram) — Fork with **persistent cognitive memory** — frequency-weighted retrieval of cross-session knowledge for improved experiment continuity.
+- [Colab/Kaggle T4 port](https://github.com/karpathy/autoresearch/issues/208) — Adapts autoresearch for free T4 GPUs (Google Colab / Kaggle) with zero cost and zero local setup. Key changes: Flash Attention 3 → PyTorch SDPA, removes H100-only kernel dependency.
+- [ArmanJR-Lab/autoautoresearch](https://github.com/ArmanJR-Lab/autoautoresearch) — Jetson AGX Orin port with a **director** — a Go binary that acts as a "creative director" injecting novelty (arxiv papers + DeepSeek Reasoner) into the loop to escape local minima. Includes multi-experiment comparison (baseline vs director-guided) with detailed stall analysis.
+
+### Domain-Specific Adaptations
+
+- [mattprusak/autoresearch-genealogy](https://github.com/mattprusak/autoresearch-genealogy) — Applies the autoresearch pattern to genealogy, using structured prompts, archive guides, source checks, and vault workflows to iteratively expand and verify family-history research.
+- [ArchishmanSengupta/autovoiceevals](https://github.com/ArchishmanSengupta/autovoiceevals) — Uses adversarial callers plus keep-or-revert prompt edits to harden voice AI agents across Vapi, Smallest AI, and ElevenLabs.
+- [chrisworsey55/atlas-gic](https://github.com/chrisworsey55/atlas-gic) — Applies the autoresearch keep-or-revert loop to trading agents, optimizing prompts and portfolio orchestration against rolling Sharpe ratio instead of model loss.
+- [RightNow-AI/autokernel](https://github.com/RightNow-AI/autokernel) — Applies the autoresearch loop to GPU kernel optimization: profile bottlenecks, edit one kernel, benchmark, keep or revert, repeat.
+- [ElliotXie/autozyme](https://github.com/ElliotXie/autozyme) — Multi-agent framework that applies the autoresearch keep-or-revert loop to CPU-side scientific software: profile a target function, generate one optimization candidate, benchmark for speed while preserving the original outputs, keep or revert, repeat.
+- [Agent-Analytics/autoresearch-growth](https://github.com/Agent-Analytics/autoresearch-growth) — Applies autoresearch to landing-page positioning and A/B test candidates, using analytics snapshots and measured experiment results to seed subsequent rounds.
+- [Rkcr7/autoresearch-sudoku](https://github.com/Rkcr7/autoresearch-sudoku) — Enhanced autoresearch workflow where an AI agent iteratively rewrites and benchmarks a Rust sudoku solver, ultimately beating leading human-built solvers on hard benchmark sets.
+- [jeongph/autospec](https://github.com/jeongph/autospec) — Reads natural-language business rules and autonomously builds a Spring Boot service with tests via the keep-or-revert loop. Evaluates with Gradle build + JUnit XML. 119-line skeleton to 950 lines in 5 cycles.
+- [vlasenkoalexey/tpu_performance_autoresearch_wiki](https://github.com/vlasenkoalexey/tpu_performance_autoresearch_wiki) — Applies the autoresearch keep-or-revert loop to TPU model performance (MFU / tokens-per-sec) on v6e hardware: profiles each run through an XProf MCP server, makes one model-code change per experiment, and keeps or reverts against measured MFU. Pairs the loop with a Karpathy-style LLM wiki for domain knowledge and per-experiment optimization traces; includes Llama3-8B and Qwen3-8B case studies across JAX and torchax lanes.
+
+### Evaluation & Benchmarks
+
+- [snap-stanford/MLAgentBench](https://github.com/snap-stanford/MLAgentBench) — Benchmark suite for evaluating AI agents on ML experimentation tasks. 13 tasks from CIFAR-10 to BabyLM.
+- [OpenAI/mle-bench](https://github.com/openai/mle-bench) — OpenAI's benchmark for measuring how well AI agents perform at ML engineering.
+- [chchenhui/mlrbench](https://github.com/chchenhui/mlrbench) — MLR-Bench: Evaluating AI agents on open-ended ML research. 201 tasks from NeurIPS/ICLR/ICML workshops.
+- [gersteinlab/ML-Bench](https://github.com/gersteinlab/ML-Bench) — Evaluates LLMs and agents for ML tasks on repository-level code.
+- [THUDM/AgentBench](https://github.com/THUDM/AgentBench) — Comprehensive benchmark for LLM-as-Agent evaluation across 8 distinct environments. ICLR 2024.
+
+### Related Resources
+
+- [ai-agents-2030/awesome-deep-research-agent](https://github.com/ai-agents-2030/awesome-deep-research-agent) — Curated list of deep research agent papers and systems.
+- [YoungDubbyDu/LLM-Agent-Optimization](https://github.com/YoungDubbyDu/LLM-Agent-Optimization) — Papers on LLM agent optimization methods.
+- [VoltAgent/awesome-ai-agent-papers](https://github.com/VoltAgent/awesome-ai-agent-papers) — Curated AI agent papers from 2026 — agent engineering, memory, evaluation, workflows, and autonomous systems.
+- [masamasa59/ai-agent-papers](https://github.com/masamasa59/ai-agent-papers) — AI agent research papers updated biweekly via automated arxiv search with curated selection.
+- [tmgthb/Autonomous-Agents](https://github.com/tmgthb/Autonomous-Agents) — Autonomous agents research papers, updated daily.
+- [HKUST-KnowComp/Awesome-LLM-Scientific-Discovery](https://github.com/HKUST-KnowComp/Awesome-LLM-Scientific-Discovery) — EMNLP 2025 survey on LLMs in scientific discovery.
+- [openags/Awesome-AI-Scientist-Papers](https://github.com/openags/Awesome-AI-Scientist-Papers) — Collection of AI Scientist / Robot Scientist papers.
+- [agenticscience.github.io](https://agenticscience.github.io/) — Survey: "From AI for Science to Agentic Science: A Survey on Autonomous Scientific Discovery."
+- [dspy.ai/GEPA](https://dspy.ai/api/optimizers/GEPA/overview/) — DSPy integration of GEPA reflective prompt optimizer for compound AI systems.
+- [OpenAI Cookbook: Self-Evolving Agents](https://developers.openai.com/cookbook/examples/partners/self_evolving_agents/autonomous_agent_retraining) — Cookbook for autonomous agent retraining using GEPA-style reflective evolution.
+- [WecoAI/awesome-autoresearch](https://github.com/WecoAI/awesome-autoresearch) — Curated list of AutoResearch use cases with verifiable traces and progress charts, organized by domain (LLM training, GPU kernels, voice agents, trading, etc.).
+
+<!-- AUTORESEARCH-END -->
+
+---
+
+## How to Contribute
+
+We welcome contributions to this list! Before contributing, please take a moment to review our [contribution guidelines](contributing.md). These guidelines will help ensure that your contributions align with our objectives and meet our standards for quality and relevance.
+
+**What we're looking for:**
+- New high-quality papers, tools, or resources with a brief description of why they matter
+- Updates to existing entries (broken links, outdated information)
+- Corrections to star counts, pricing, or model details
+- Translations and accessibility improvements
+
+**Quality standards:**
+- All tools should be actively maintained (updated within the last 6 months)
+- Papers should be from peer-reviewed venues or have significant community adoption
+- Datasets should be publicly accessible
+- Please include a one-line description explaining why the resource is valuable
+
+Thank you for your interest in contributing to this project!
+
+<a href="https://github.com/promptslab/Awesome-Prompt-Engineering/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=promptslab/Awesome-Prompt-Engineering" />
+</a>
+
+---
+
+<p align="center">
+  <sub>Maintained by <a href="https://promptslab.github.io">PromptsLab</a> · <a href="https://github.com/promptslab/Awesome-Prompt-Engineering">Star this repo</a> if you find it useful!</sub>
+</p>

upstream/promptslab-awesome-prompt-engineering/catalogue/_source/papers.json

@@ -0,0 +1,345 @@
+---
+title: "Papers"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/promptslab/awesome-prompt-engineering/blob/3b022d69/_source/papers.json
+upstream_sha: 3b022d69
+imported_at: 2026-06-26
+prompt_class: catalogue
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+[
+   {
+      "p":"Hard Prompts Made Easy: Gradient-Based Discrete Optimization for Prompt Tuning and Discovery",
+      "i":"https://arxiv.org/abs/2302.03668",
+      "y":2023,
+      "cc":"Prompt Engineering Techniques"
+   },
+   {
+      "p":"Multimodal Chain-of-Thought Reasoning in Language Models",
+      "i":"https://arxiv.org/abs/2302.00923",
+      "y":2023,
+      "cc":"Reasoning and In-Context Learning"
+   },
+   {
+      "p":"Large Language Models Can Be Easily Distracted by Irrelevant Context",
+      "i":"https://arxiv.org/abs/2302.00093",
+      "y":2023,
+      "cc":"Evaluating and Improving Language Models"
+   },
+   {
+      "p":"Synthetic Prompting: Generating Chain-of-Thought Demonstrations for Large Language Models",
+      "i":"https://arxiv.org/abs/2302.00618",
+      "y":2023,
+      "cc":"Prompt Engineering Techniques"
+   },
+   {
+      "p":"Progressive Prompts: Continual Learning for Language Models",
+      "i":"https://arxiv.org/abs/2301.12314",
+      "y":2023,
+      "cc":"Prompt Engineering Techniques"
+   },
+   {
+      "p":"Batch Prompting: Efficient Inference with LLM APIs",
+      "i":"https://arxiv.org/abs/2301.08721",
+      "y":2023,
+      "cc":"Prompt Engineering Techniques"
+   },
+   {
+      "p":"Prompting for Multimodal Hateful Meme Classification",
+      "i":"https://arxiv.org/abs/2302.04156",
+      "y":2023,
+      "cc":"Applications of Language Models"
+   },
+   {
+      "p":"PLACES: Prompting Language Models for Social Conversation Synthesis",
+      "i":"https://arxiv.org/abs/2302.03269",
+      "y":2023,
+      "cc":"Applications of Language Models"
+   },
+   {
+      "p":"Commonsense-Aware Prompting for Controllable Empathetic Dialogue Generation",
+      "i":"https://arxiv.org/abs/2302.01441",
+      "y":2023,
+      "cc":"Applications of Language Models"
+   },
+   {
+      "p":"Crawling the Internal Knowledge-Base of Language Models",
+      "i":"https://arxiv.org/abs/2301.12810",
+      "y":2023,
+      "cc":"Evaluating and Improving Language Models"
+   },
+   {
+      "p":"On Second Thought, Let's Not Think Step by Step! Bias and Toxicity in Zero-Shot Reasoning",
+      "i":"https://arxiv.org/abs/2212.08061",
+      "y":2022,
+      "cc":"Reasoning and In-Context Learning"
+   },
+   {
+      "p":"Constitutional AI: Harmlessness from AI Feedback",
+      "i":"https://arxiv.org/abs/2212.08073",
+      "y":2022,
+      "cc":"Threat Detection and Adversarial Examples"
+   },
+   {
+      "p":"Successive Prompting for Decompleting Complex Questions",
+      "i":"https://arxiv.org/abs/2212.04092",
+      "y":2022,
+      "cc":"Prompt Engineering Techniques"
+   },
+   {
+      "p":"Discovering Language Model Behaviors with Model-Written Evaluations",
+      "i":"https://arxiv.org/abs/2212.09251",
+      "y":2022,
+      "cc":"Evaluating and Improving Language Models"
+   },
+   {
+      "p":"Structured Prompting: Scaling In-Context Learning to 1,000 Examples",
+      "i":"https://arxiv.org/abs/2212.06713",
+      "y":2022,
+      "cc":"Prompt Engineering Techniques"
+   },
+   {
+      "p":"PAL: Program-aided Language Models",
+      "i":"https://arxiv.org/abs/2211.10435",
+      "y":2022,
+      "cc":"Applications of Language Models"
+   },
+   {
+      "p":"Large Language Models Are Human-Level Prompt Engineers",
+      "i":"https://arxiv.org/abs/2211.01910",
+      "y":2022,
+      "cc":"Prompt Engineering Techniques"
+   },
+   {
+      "p":"Ignore Previous Prompt: Attack Techniques For Language Models",
+      "i":"https://arxiv.org/abs/2211.09527",
+      "y":2022,
+      "cc":"Threat Detection and Adversarial Examples"
+   },
+   {
+      "p":"Machine Generated Text: A Comprehensive Survey of Threat Models and Detection Methods",
+      "i":"https://arxiv.org/abs/2210.07321",
+      "y":2022,
+      "cc":"Threat Detection and Adversarial Examples"
+   },
+   {
+      "p":"Ask Me Anything: A simple strategy for prompting language models",
+      "i":"https://paperswithcode.com/paper/ask-me-anything-a-simple-strategy-for",
+      "y":2022,
+      "cc":"Prompt Engineering Techniques"
+   },
+   {
+      "p":"ReAct: Synergizing Reasoning and Acting in Language Models",
+      "i":"https://arxiv.org/abs/2210.03629",
+      "y":2022,
+      "cc":"Reasoning and In-Context Learning"
+   },
+   {
+      "p":"Prompting GPT-3 To Be Reliable",
+      "i":"https://arxiv.org/abs/2210.09150",
+      "y":2022,
+      "cc":"Prompt Engineering Techniques"
+   },
+   {
+      "p":"Decomposed Prompting: A Modular Approach for Solving Complex Tasks",
+      "i":"https://arxiv.org/abs/2210.02406",
+      "y":2022,
+      "cc":"Prompt Engineering Techniques"
+   },
+   {
+      "p":"Language Models Are Greedy Reasoners: A Systematic Formal Analysis of Chain-of-Thought",
+      "i":"https://arxiv.org/abs/2210.01240v3",
+      "y":2022,
+      "cc":"Reasoning and In-Context Learning"
+   },
+   {
+      "p":"Evaluating the Susceptibility of Pre-Trained Language Models via Handcrafted Adversarial Examples",
+      "i":"https://arxiv.org/abs/2209.02128",
+      "y":2022,
+      "cc":"Threat Detection and Adversarial Examples"
+   },
+   {
+      "p":"Promptagator: Few-shot Dense Retrieval From 8 Examples",
+      "i":"https://arxiv.org/abs/2209.11755",
+      "y":2022,
+      "cc":"Few-shot Learning and Performance Optimization"
+   },
+   {
+      "p":"On the Advance of Making Language Models Better Reasoners",
+      "i":"https://arxiv.org/abs/2206.02336",
+      "y":2022,
+      "cc":"Reasoning and In-Context Learning"
+   },
+   {
+      "p":"Large Language Models are Zero-Shot Reasoners",
+      "i":"https://arxiv.org/abs/2205.11916",
+      "y":2022,
+      "cc":"Reasoning and In-Context Learning"
+   },
+   {
+      "p":"Toxicity Detection with Generative Prompt-based Inference",
+      "i":"https://arxiv.org/abs/2205.12390",
+      "y":2022,
+      "cc":"Threat Detection and Adversarial Examples"
+   },
+   {
+      "p":"The Unreliability of Explanations in Few-shot Prompting for Textual Reasoning",
+      "i":"https://arxiv.org/abs/2205.03401",
+      "y":2022,
+      "cc":"Few-shot Learning and Performance Optimization"
+   },
+   {
+      "p":"A Taxonomy of Prompt Modifiers for Text-To-Image Generation",
+      "i":"https://arxiv.org/abs/2204.13988",
+      "y":2022,
+      "cc":"Text-to-Image Generation"
+   },
+   {
+      "p":"PromptChainer: Chaining Large Language Model Prompts through Visual Programming",
+      "i":"https://arxiv.org/abs/2203.06566",
+      "y":2022,
+      "cc":"Prompt Engineering Techniques"
+   },
+   {
+      "p":"Self-Consistency Improves Chain of Thought Reasoning in Language Models",
+      "i":"https://arxiv.org/abs/2203.11171",
+      "y":2022,
+      "cc":"Reasoning and In-Context Learning"
+   },
+   {
+      "p":"Rethinking the Role of Demonstrations: What Makes In-Context Learning Work?",
+      "i":"https://arxiv.org/abs/2202.12837",
+      "y":2022,
+      "cc":"Reasoning and In-Context Learning"
+   },
+   {
+      "p":"Legal Prompt Engineering for Multilingual Legal Judgement Prediction",
+      "i":"https://arxiv.org/abs/2212.02199",
+      "y":2022,
+      "cc":"Applications of Language Models"
+   },
+   {
+      "p":"Investigating Prompt Engineering in Diffusion Models",
+      "i":"https://arxiv.org/abs/2211.15462",
+      "y":2022,
+      "cc":"Prompt Engineering Techniques"
+   },
+   {
+      "p":"Learn to Explain: Multimodal Reasoning via Thought Chains for Science Question Answering",
+      "i":"https://arxiv.org/abs/2209.09513v2",
+      "y":2022,
+      "cc":"Reasoning and In-Context Learning"
+   },
+   {
+      "p":"Conversing with Copilot: Exploring Prompt Engineering for Solving CS1 Problems Using Natural Language",
+      "i":"https://arxiv.org/abs/2210.15157",
+      "y":2022,
+      "cc":"Applications of Language Models"
+   },
+   {
+      "p":"Piloting Copilot and Codex: Hot Temperature, Cold Prompts, or Black Magic?",
+      "i":"https://arxiv.org/abs/2210.14699",
+      "y":2022,
+      "cc":"Overviews"
+   },
+   {
+      "p":"Plot Writing From Scratch Pre-Trained Language Models",
+      "i":"https://aclanthology.org/2022.inlg-main.5",
+      "y":2022,
+      "cc":"Applications of Language Models"
+   },
+   {
+      "p":"Chain of Thought Prompting Elicits Reasoning in Large Language Models",
+      "i":"https://arxiv.org/abs/2201.11903",
+      "y":2021,
+      "cc":"Reasoning and In-Context Learning"
+   },
+   {
+      "p":"Show Your Work: Scratchpads for Intermediate Computation with Language Models",
+      "i":"https://arxiv.org/abs/2112.00114",
+      "y":2021,
+      "cc":"Prompt Engineering Techniques"
+   },
+   {
+      "p":"Generated Knowledge Prompting for Commonsense Reasoning",
+      "i":"https://arxiv.org/abs/2110.08387",
+      "y":2021,
+      "cc":"Reasoning and In-Context Learning"
+   },
+   {
+      "p":"Reframing Instructional Prompts to GPTk's Language",
+      "i":"https://arxiv.org/abs/2109.07830",
+      "y":2021,
+      "cc":"Prompt Engineering Techniques"
+   },
+   {
+      "p":"Design Guidelines for Prompt Engineering Text-to-Image Generative Models",
+      "i":"https://arxiv.org/abs/2109.06977",
+      "y":2021,
+      "cc":"Text-to-Image Generation"
+   },
+   {
+      "p":"Making Pre-trained Language Models Better Few-shot Learners",
+      "i":"https://aclanthology.org/2021.acl-long.295",
+      "y":2021,
+      "cc":"Few-shot Learning and Performance Optimization"
+   },
+   {
+      "p":"Fantastically Ordered Prompts and Where to Find Them: Overcoming Few-Shot Prompt Order Sensitivity",
+      "i":"https://arxiv.org/abs/2104.08786",
+      "y":2021,
+      "cc":"Prompt Engineering Techniques"
+   },
+   {
+      "p":"BERTese: Learning to Speak to BERT",
+      "i":"https://aclanthology.org/2021.eacl-main.316",
+      "y":2021,
+      "cc":"Reasoning and In-Context Learning"
+   },
+   {
+      "p":"The Power of Scale for Parameter-Efficient Prompt Tuning",
+      "i":"https://arxiv.org/abs/2104.08691",
+      "y":2021,
+      "cc":"Prompt Engineering Techniques"
+   },
+   {
+      "p":"Prompt Programming for Large Language Models: Beyond the Few-Shot Paradigm",
+      "i":"https://arxiv.org/abs/2102.07350",
+      "y":2021,
+      "cc":"Prompt Engineering Techniques"
+   },
+   {
+      "p":"Calibrate Before Use: Improving Few-Shot Performance of Language Models",
+      "i":"https://arxiv.org/abs/2102.09690",
+      "y":2021,
+      "cc":"Evaluating and Improving Language Models"
+   },
+   {
+      "p":"Prefix-Tuning: Optimizing Continuous Prompts for Generation",
+      "i":"https://arxiv.org/abs/2101.00190",
+      "y":2021,
+      "cc":"Prompt Engineering Techniques"
+   },
+   {
+      "p":"AutoPrompt: Eliciting Knowledge from Language Models with Automatically Generated Prompts",
+      "i":"https://arxiv.org/abs/2010.15980",
+      "y":2020,
+      "cc":"Applications of Language Models"
+   },
+   {
+      "p":"Language Models are Few-Shot Learners",
+      "i":"https://arxiv.org/abs/2005.14165",
+      "y":2020,
+      "cc":"Few-shot Learning and Performance Optimization"
+   },
+   {
+      "p":"How Can We Know What Language Models Know?",
+      "i":"https://direct.mit.edu/tacl/article/doi/10.1162/tacl_a_00324/96460/How-Can-We-Know-What-Language-Models-Know",
+      "y":2020,
+      "cc":"Threat Detection and Adversarial Examples"
+   }
+]

upstream/promptslab-awesome-prompt-engineering/catalogue/code-of-conduct.md

@@ -0,0 +1,141 @@
+---
+title: "Contributor Covenant Code of Conduct"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/promptslab/awesome-prompt-engineering/blob/3b022d69/code-of-conduct.md
+upstream_sha: 3b022d69
+imported_at: 2026-06-26
+prompt_class: unknown
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

upstream/promptslab-awesome-prompt-engineering/catalogue/contributing.md

@@ -0,0 +1,27 @@
+---
+title: "Contribution Guidelines:"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/promptslab/awesome-prompt-engineering/blob/3b022d69/contributing.md
+upstream_sha: 3b022d69
+imported_at: 2026-06-26
+prompt_class: catalogue
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+# Contribution Guidelines:
+
+Thank you for considering contributing to our Github project. To ensure a smooth and efficient contribution process, please adhere to the following guidelines:
+
+- **Test your tools:**
+  - Before submitting a pull request, make sure to test the tools yourself. This ensures that they are functional and free from any errors or bugs.
+- **Ensure tool quality:** 
+  - Only link to tools that are of high quality and meet our project standards.
+
+## Updating your PR
+
+If the maintainers notice any changes that are required in your pull request, we will ask you to update it before merging. Instead of opening a new PR, simply edit the existing one.
+
+Thank you for your suggestions and contributions!

upstream/promptslab-awesome-prompt-engineering/catalogue/website/README.md

@@ -0,0 +1,35 @@
+---
+title: "Readme"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/promptslab/awesome-prompt-engineering/blob/3b022d69/website/README.md
+upstream_sha: 3b022d69
+imported_at: 2026-06-26
+prompt_class: catalogue
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+## Awesome Prompt Engineering — Website
+
+This is the website for the [Awesome Prompt Engineering](https://github.com/promptslab/Awesome-Prompt-Engineering) collection.
+
+### How it works
+
+- Built with Next.js (App Router) + Tailwind CSS
+- Fetches README.md from GitHub at runtime (ISR, 5-minute revalidation)
+- Parses markdown into structured typed data
+- No manual data sync needed — README is the single source of truth
+
+### Development
+
+```bash
+cd website
+npm install
+npm run dev
+```
+
+### Deploy
+
+Set Vercel root directory to `website/`. No additional config needed.

upstream/promptslab-awesome-prompt-engineering/catalogue/website/package.json

@@ -0,0 +1,42 @@
+---
+title: "Package"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/promptslab/awesome-prompt-engineering/blob/3b022d69/website/package.json
+upstream_sha: 3b022d69
+imported_at: 2026-06-26
+prompt_class: unknown
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+{
+  "name": "website",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "eslint"
+  },
+  "dependencies": {
+    "fuse.js": "^7.1.0",
+    "next": "15.5.12",
+    "react": "19.1.0",
+    "react-dom": "19.1.0",
+    "resend": "^6.9.2"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3",
+    "@tailwindcss/postcss": "^4",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "eslint": "^9",
+    "eslint-config-next": "15.5.12",
+    "tailwindcss": "^4",
+    "typescript": "^5"
+  }
+}

upstream/promptslab-awesome-prompt-engineering/catalogue/website/tsconfig.json

@@ -0,0 +1,40 @@
+---
+title: "Tsconfig"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/promptslab/awesome-prompt-engineering/blob/3b022d69/website/tsconfig.json
+upstream_sha: 3b022d69
+imported_at: 2026-06-26
+prompt_class: unknown
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}

upstream/trailofbits-awesome-ml-security/catalogue/README.md

@@ -0,0 +1,228 @@
+---
+title: "Awesome-ML-Security"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/trailofbits/awesome-ml-security/blob/d7fe4fa9/README.md
+upstream_sha: d7fe4fa9
+imported_at: 2026-06-26
+prompt_class: catalogue
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+# Awesome-ML-Security
+
+A curated list of awesome machine learning security references, guidance, tools, and more.
+
+**Table of Contents**
+
+- [Awesome-ML-Security](#awesome-ml-security)
+  - [Relevant work, standards, literature](#relevant-work-standards-literature)
+    - [CIA of the model](#cia-of-the-model)
+      - [Confidentiality](#confidentiality)
+      - [Integrity](#integrity)
+      - [Availability](#availability)
+    - [Degraded model performance](#degraded-model-performance)
+    - [ML-Ops](#ml-ops)
+    - [AI’s effect on attacks/security elsewhere](#ais-effect-on-attackssecurity-elsewhere)
+      - [Self-driving cars](#self-driving-cars)
+      - [LLM Alignment](#llm-alignment)
+  - [Regulatory actions](#regulatory-actions)
+    - [US](#us)
+    - [EU](#eu)
+    - [Other](#other)
+  - [Safety standards](#safety-standards)
+  - [Taxonomies and frameworks](#taxonomies-and-frameworks)
+  - [Security tools and techniques](#security-tools-and-techniques)
+    - [API probing](#api-probing)
+    - [Model backdoors](#model-backdoors)
+    - [Other](#other-1)
+  - [Background information](#background-information)
+  - [DeepFakes, disinformation, and abuse](#deepfakes-disinformation-and-abuse)
+  - [Notable incidents](#notable-incidents)
+  - [Notable harms](#notable-harms)
+
+## Relevant work, standards, literature
+
+### CIA of the model
+Membership attacks, model inversion attacks, model extraction, adversarial perturbation, prompt injections, etc.
+* [Towards the Science of Security and Privacy in Machine Learning](https://arxiv.org/abs/1611.03814)
+* [SoK: Machine Learning Governance](https://arxiv.org/abs/2109.10870)
+* [Not with a Bug, But with a Sticker: Attacks on Machine Learning Systems and What To Do About Them](https://www.goodreads.com/book/show/125075266-not-with-a-bug-but-with-a-sticker)
+* [On the Impossible Safety of Large AI Models](https://arxiv.org/abs/2209.15259)
+
+#### Confidentiality
+Reconstruction (model inversion; attribute inference; gradient and information leakage), theft of data, Membership inference and reidentification of data, Model extraction (model theft), property inference (leakage of dataset properties), etc.
+* [awesome-ml-privacy-attacks](https://github.com/stratosphereips/awesome-ml-privacy-attacks)
+* [Privacy Side Channels in Machine Learning Systems](https://arxiv.org/abs/2309.05610#:~:text=Most%20current%20approaches%20for%20protecting,%2C%20output%20monitoring%2C%20and%20more)
+* [Beyond Labeling Oracles: What does it mean to steal ML models?](https://arxiv.org/abs/2310.01959)
+* [Text Embeddings Reveal (Almost) As Much As Text](https://arxiv.org/abs/2310.06816?ref=upstract.com)
+* [Language Model Inversion](https://arxiv.org/abs/2311.13647)
+* [Extracting Training Data from ChatGPT](https://not-just-memorization.github.io/extracting-training-data-from-chatgpt.html)
+* [Recovering the Pre-Fine-Tuning Weights of Generative Models](https://arxiv.org/abs/2402.10208)
+
+#### Integrity
+Backdoors/neural trojans (same as for non-ML systems), adversarial evasion (perturbation of an input to evade a certain classification or output), data poisoning and ordering (providing malicious data or changing the order of the data flow into an ML model).
+* [A Systematic Survey of Backdoor Attack, Weight Attack and Adversarial Examples](https://arxiv.org/abs/2302.09457)
+* [Poisoning Web-Scale Training Datasets is Practical](https://arxiv.org/abs/2302.10149)
+* [Planting Undetectable Backdoors in Machine Learning Models](https://arxiv.org/abs/2204.06974)
+* [Motivating the Rules of the Game for Adversarial Example Research](https://arxiv.org/abs/1807.06732)
+* [On Evaluating Adversarial Robustness](https://arxiv.org/abs/1902.06705)
+* [Tree of Attacks: Jailbreaking Black-Box LLMs Automatically](https://arxiv.org/abs/2312.02119)
+* [Universal and Transferable Adversarial Attacks on Aligned Language Models](https://llm-attacks.org/)
+* [Manipulating SGD with Data Ordering Attacks](https://arxiv.org/abs/2104.09667)
+* [Adversarial reprogramming](https://arxiv.org/abs/1806.11146) - repurposing a model for a different task than its original intended purpose
+* [Model spinning attacks](https://arxiv.org/abs/2107.10443) (meta backdoors) - forcing a model to produce output that adheres to a meta task (for ex. making a general LLM produce propaganda)
+* [LLM Censorship: A Machine Learning Challenge or a Computer Security Problem?](https://arxiv.org/abs/2307.10719)
+* [Securing LLM Systems Against Prompt Injection](https://developer.nvidia.com/blog/securing-llm-systems-against-prompt-injection/) & [Mitigating Stored Prompt Injection Attacks Against LLM Applications](https://developer.nvidia.com/blog/mitigating-stored-prompt-injection-attacks-against-llm-applications/)
+  * [Best Practices for Securing LLM-Enabled Applications](https://developer.nvidia.com/blog/best-practices-for-securing-llm-enabled-applications/)
+  * [NVIDIA NeMo Guardrails: Security Guidelines](https://docs.nvidia.com/nemo/guardrails/security/guidelines.html)
+* [Multi-Agent Systems Execute Arbitrary Malicious Code](https://arxiv.org/abs/2503.12188)
+* [Agentic Autonomy Levels and Security](https://developer.nvidia.com/blog/agentic-autonomy-levels-and-security/)
+* [Rerouting LLM Routers](https://arxiv.org/abs/2501.01818)
+* [Defeating Prompt Injections by Design](https://arxiv.org/abs/2503.18813)
+* [Arcanum Prompt Injection Taxonomy](https://github.com/Arcanum-Sec/arc_pi_taxonomy)
+
+
+#### Availability
+* [Energy-latency attacks](https://arxiv.org/abs/2006.03463) - denial of service for neural networks
+
+### Degraded model performance
+* [Trail of Bits's Audit of YOLOv7](https://blog.trailofbits.com/2023/11/15/assessing-the-security-posture-of-a-widely-used-vision-model-yolov7/)
+* [Robustness Testing of Autonomy Software](https://users.ece.cmu.edu/~koopman/pubs/hutchison18_icse_robustness_testing_autonomy_software.pdf)
+* [Can robot navigation bugs be found in simulation? An exploratory study](https://hal.science/hal-01534235/file/PID4832685.pdf)
+* [Bugs can optimize for bad behavior (OpenAI GPT-2)](https://openai.com/research/fine-tuning-gpt-2)
+* [You Only Look Once Run time errors](https://www.york.ac.uk/assuring-autonomy/guidance/body-of-knowledge/implementation/2-3/2-3-3/cross-domain-automotive/)
+
+### ML-Ops
+* [Incubated ML Exploits: Backdooring ML Pipelines using Input-Handling Bugs](https://www.youtube.com/watch?v=Z38pTFM0FyU)
+* [Auditing the Ask Astro LLM Q&A app](https://blog.trailofbits.com/2024/07/05/auditing-the-ask-astro-llm-qa-app/)
+* [Exploiting ML models with pickle file attacks: Part 1](https://blog.trailofbits.com/2024/06/11/exploiting-ml-models-with-pickle-file-attacks-part-1/) & [Exploiting ML models with pickle file attacks: Part 2](https://blog.trailofbits.com/2024/06/11/exploiting-ml-models-with-pickle-file-attacks-part-2/)
+* [PCC: Bold step forward, not without flaws](https://blog.trailofbits.com/2024/06/14/pcc-bold-step-forward-not-without-flaws/)
+* [Trail of Bits's Audit of the Safetensors Library](https://github.com/trailofbits/publications/blob/master/reviews/2023-03-eleutherai-huggingface-safetensors-securityreview.pdf)
+* [Facebook’s LLAMA being openly distributed via torrents](https://news.ycombinator.com/item?id=35007978)
+* [Summoning Demons: The Pursuit of Exploitable Bugs in Machine Learning](https://arxiv.org/abs/1701.04739)
+* [DeepPayload: Black-box Backdoor Attack on Deep Learning Models through Neural Payload Injection](https://arxiv.org/abs/2101.06896)
+* [Weaponizing Machine Learning Models with Ransomware](https://hiddenlayer.com/research/weaponizing-machine-learning-models-with-ransomware/) (and [Machine Learning Threat Roundup](https://hiddenlayer.com/research/machine-learning-threat-roundup/))
+* [Bug Characterization in Machine Learning-based Systems](https://arxiv.org/abs/2307.14512)
+* [LeftoverLocals: Listening to LLM responses through leaked GPU local memory](https://blog.trailofbits.com/2024/01/16/leftoverlocals-listening-to-llm-responses-through-leaked-gpu-local-memory/)
+* [Offensive ML Playbook](https://wiki.offsecml.com/Welcome+to+the+Offensive+ML+Playbook)
+* [MCP security briefing](https://www.wiz.io/blog/mcp-security-research-briefing)
+
+
+### AI’s effect on attacks/security elsewhere
+* [How AI will affect cybersecurity: What we told the CFTC](https://blog.trailofbits.com/2023/07/31/how-ai-will-affect-cybersecurity-what-we-told-the-cftc/)
+* [Lost at C: A User Study on the Security Implications of Large Language Model Code Assistants](https://arxiv.org/abs/2208.09727)
+* [Examining Zero-Shot Vulnerability Repair with Large Language Models](https://arxiv.org/pdf/2112.02125.pdf)
+* [Do Users Write More Insecure Code with AI Assistants?](https://arxiv.org/pdf/2211.03622.pdf)
+* [Learned Systems Security](https://arxiv.org/abs/2212.10318)
+* [Beyond the Hype: A Real-World Evaluation of the Impact and Cost of Machine Learning-Based Malware Detection](https://arxiv.org/abs/2012.09214)
+* [Data-Driven Offense](https://player.vimeo.com/video/133292422) from Infiltrate 2015
+* [Codex (and GPT-4) can’t beat humans on smart contract audits](https://blog.trailofbits.com/2023/03/22/codex-and-gpt4-cant-beat-humans-on-smart-contract-audits/)
+
+#### Self-driving cars
+* [Driving to Safety: How Many Miles of Driving Would It Take to Demonstrate Autonomous Vehicle Reliability?](https://www.rand.org/pubs/research_reports/RR1478.html)
+
+#### LLM Alignment
+* [When Your AIs Deceive You: Challenges with Partial Observability of Human Evaluators in Reward Learning](https://arxiv.org/abs/2402.17747)
+
+## Regulatory actions
+
+### US
+* [FTC: Keep your AI claims in check](https://www.ftc.gov/business-guidance/blog/2023/02/keep-your-ai-claims-check)
+* [FAA - Unmanned Aircraft Vehicles](https://www.faa.gov/regulations_policies/rulemaking/committees/documents/index.cfm/committee/browse/committeeID/837)
+* [NHTSA - Automated Vehicle safety](https://www.nhtsa.gov/technology-innovation/automated-vehicles-safety)
+* [AI Bill of Rights](https://www.whitehouse.gov/ostp/ai-bill-of-rights/)
+* [Executive Order on Safe, Secure, and Trustworthy Artificial Intelligence](https://www.whitehouse.gov/briefing-room/statements-releases/2023/10/30/fact-sheet-president-biden-issues-executive-order-on-safe-secure-and-trustworthy-artificial-intelligence/#:~:text=With%20this%20Executive%20Order%2C%20the,information%20with%20the%20U.S.%20government.)
+
+### EU
+* [The Artificial Intelligence Act](https://artificialintelligenceact.eu/) (proposed)
+
+### Other
+* [TIME Ideas: How AI Can Be Regulated Like Nuclear Energy](https://time.com/6327635/ai-needs-to-be-regulated-like-nuclear-weapons/)
+* [Trail of Bits’s Response to OSTP National Priorities for AI RFI](https://blog.trailofbits.com/2023/07/18/trail-of-bitss-response-to-ostp-national-priorities-for-ai-rfi/)
+* [Trail of Bits’s Response to NTIA AI Accountability RFC](https://blog.trailofbits.com/2023/07/18/trail-of-bitss-response-to-ostp-national-priorities-for-ai-rfi/)
+
+## Safety standards
+* [Toward Comprehensive Risk Assessments and Assurance of AI-Based Systems](https://blog.trailofbits.com/2023/03/14/ai-security-safety-audit-assurance-heidy-khlaaf-odd/)
+* ISO/IEC 42001 — Artificial intelligence — Management system
+* ISO/IEC 22989 — Artificial intelligence — Concepts and terminology
+* ISO/IEC 38507 — Governance of IT — Governance implications of the use of artificial intelligence by organizations
+* ISO/IEC 23894 — Artificial Intelligence — Guidance on Risk Management
+* ANSI/UL 4600 Standard for Safety for the Evaluation of Autonomous Products — addresses fully autonomous systems that move such as self-driving cars, and other vehicles including lightweight unmanned aerial vehicles (UAVs). Includes safety case construction, risk analysis, design process, verification and validation, tool qualification, data integrity, human-machine interaction, metrics and conformance assessment.
+* High-Level Expert Group on AI in European Commission — Ethics Guidelines for Trustworthy Artificial Intelligence
+
+## Taxonomies and frameworks
+* [NIST AI 100-2e2023](https://csrc.nist.gov/publications/detail/white-paper/2023/03/08/adversarial-machine-learning-taxonomy-and-terminology/draft)
+* [MITRE ATLAS](https://atlas.mitre.org/)
+* [AI Incident Database](https://incidentdatabase.ai/)
+* [OWASP Top 10 for LLMs](https://owasp.org/www-project-top-10-for-large-language-model-applications/)
+* [OWASP AI Exchange](https://owaspai.org) - comprehensive AI security guide with 300+ pages of practical guidance on protecting AI systems
+* [Guidelines for secure AI system development](https://www.ncsc.gov.uk/files/Guidelines-for-secure-AI-system-development.pdf)
+
+## Security tools and techniques
+### API probing
+* [PrivacyRaven](https://github.com/trailofbits/PrivacyRaven): runs different privacy attacks against ML models; the tool only runs black-box label-only attacks
+* [Counterfit](https://github.com/Azure/counterfit): runs different adversarial ML attacks against ML models
+* [Garak](https://github.com/NVIDIA/garak)
+
+### Model backdoors
+* [Fickling](https://github.com/trailofbits/fickling): a decompiler, static analyzer, and bytecode rewriter for Python pickle files; injects backdoors into ML model files
+* [Semgrep rules for ML](https://blog.trailofbits.com/2022/10/03/semgrep-maching-learning-static-analysis/)
+
+### Other
+* [Awesome Large Language Model Tools for Cybersecurity Research](https://github.com/tenable/awesome-llm-cybersecurity-tools)
+* [Watermarks in the Sand: Impossibility of Strong Watermarking for Generative Models](https://arxiv.org/abs/2311.04378)
+
+
+## Background information
+* [Building A Generative AI Platform (Chip Huyen)](https://huyenchip.com/2024/07/25/genai-platform.html)
+* [Machine Learning Glossary | Google Developers](https://developers.google.com/machine-learning/glossary)
+* [Hugging Face NLP course](https://huggingface.co/learn/nlp-course/chapter1/1)
+* [Making Large Language Models work for you](https://simonwillison.net/2023/Aug/27/wordcamp-llms/)
+* [Andrej Karpathy's Intro to Large Language Models](https://www.youtube.com/watch?v=zjkBMFhNj_g) and [Neural Networks: Zero to Hero](https://www.youtube.com/watch?v=VMj-3S1tku0&list=PLAqhIrjkxbuWI23v9cThsA9GvCAUhRvKZ)
+* [Normcore LLM Reading List](https://gist.github.com/veekaybee/be375ab33085102f9027853128dc5f0e) especially [Building LLM applications for production](https://huyenchip.com/2023/04/11/llm-engineering.html)
+* [3blue1brown's Guide to Neural Networks](https://www.youtube.com/playlist?list=PLZHQObOWTQDNU6R1_67000Dx_ZCJB-3pi)
+* Licensing:
+  * [From RAIL to Open RAIL: Topologies of RAIL Licenses](https://www.licenses.ai/blog/2022/8/18/naming-convention-of-responsible-ai-licenses)
+  * [Hugging Face - OpenRAIL ](https://huggingface.co/blog/open_rail)
+  * [Hugging Face - AI Release Models](https://arxiv.org/abs/2302.04844)
+  * [Open LLMs](https://github.com/eugeneyan/open-llms)
+  * [Prompt Engineering Guide](https://github.com/trailofbits/awesome-ml-security/blob/main/prompt-engineering.md)
+* [How to Build an Agent](https://ampcode.com/how-to-build-an-agent)
+* [Building effective agents](https://www.anthropic.com/engineering/building-effective-agents)
+* [Chip Huyen on Agents](https://huyenchip.com/2025/01/07/agents.html)
+
+
+## DeepFakes, disinformation, and abuse
+* [How to Prepare for the Deluge of Generative AI on Social Media](https://knightcolumbia.org/content/how-to-prepare-for-the-deluge-of-generative-ai-on-social-media)
+* [Generative ML and CSAM: Implications and Mitigations](https://purl.stanford.edu/jv206yg3793)
+
+## Notable incidents
+| **Incident** | **Type** | **Loss** |
+| ----- | ----- | ----- |
+| Tay | Poor training set selection | Reputational |
+| [Apple NeuralHash](https://www.theverge.com/2021/8/18/22630439/apple-csam-neuralhash-collision-vulnerability-flaw-cryptography) | Adversarial evasion (led to hash collisions) | Reputational |
+| [PyTorch Compromise](https://pytorch.org/blog/compromised-nightly-dependency/) | Dependency confusion |
+| [Proofpoint - CVE-2019-20634](https://github.com/moohax/Proof-Pudding) | Model extraction |
+| [ClearviewAI Leak](https://techcrunch.com/2020/04/16/clearview-source-code-lapse/) | Source Code misconfiguration |
+| [Kubeflow Crypto-mining attack ](https://sysdig.com/blog/crypto-mining-kubeflow-tensorflow-falco/) | System misconfiguration |
+| [OpenAI - takeover someone's account, view their chat history, and access their billing information ](https://twitter.com/naglinagli/status/1639343866313601024) | Web Cache Deception | Reputational |
+| [OpenAI- first message of a newly-created conversation was visible in someone else’s chat history](https://openai.com/blog/march-20-chatgpt-outage) | [Cache - Redis Async I/O](https://github.com/redis/redis-py/issues/2624) | Reputational |
+| [OpenAI- ChatGPT's new Browser SDK was using some relatively recently known-vulnerable code (specifically MinIO CVE-2023-28432)](https://twitter.com/Andrew___Morris/status/1639325397241278464) | [Security vulnerability resulting in information disclosure of all environment variables, including MINIO_SECRET_KEY and MINIO_ROOT_PASSWORD.](https://www.greynoise.io/blog/openai-minio-and-why-you-should-always-use-docker-cli-scan-to-keep-your-supply-chain-clean) | Reputational              |
+| ML Flow | [MLFlow - combined Local File Inclusion/Remote File Inclusion vulnerability which can lead to a complete system or cloud provider takeover.](https://protectai.com/blog/hacking-ai-system-takeover-exploit-in-mlflow) | Monetary and Reputational |
+| [HuggingFace Spaces - Rubika](https://hiddenlayer.com/research/crossing-the-rubika-the-use-and-abuse-of-ai-cloud-services/) | System misuse |
+| [Microsoft AI Data Leak](https://www.wiz.io/blog/38-terabytes-of-private-data-accidentally-exposed-by-microsoft-ai-researchers) | SAS token misconfiguration |
+| [HuggingFace Hub- Takeover of the Meta and Intel organizations](https://twitter.com/huggingface/status/1675242955962032129) | Password Reuse |
+| [HuggingFace API token exposure](https://twitter.com/huggingface/status/1675242955962032129) | API token exposure |
+| [ShadowRay - Active Cryptominer campaign against Ray clusters](https://www.oligo.security/blog/shadowray-attack-ai-workloads-actively-exploited-in-the-wild) | Improper authentication | Monetary and Reputational
+| [Nullbudge attacks on ML supply chain](https://www.sentinelone.com/labs/nullbulge-threat-actor-masquerades-as-hacktivist-group-rebelling-against-ai/) |  Supply chain compromise | Monetary and Reputational
+| | |
+
+## Notable harms
+| **Incident** | **Type** | **Loss** |
+| ----- | ----- | ----- |
+| Google Photos Gorillas | Algorithmic bias | Reputational |
+| [Uber hits a pedestrian](https://incidentdatabase.ai/cite/4/) | Model failure |
+| [Facebook mistranslation leads to arrest](https://incidentdatabase.ai/cite/72/) | Algorithmic bias |

upstream/trailofbits-awesome-ml-security/catalogue/impossibility_research.md

@@ -0,0 +1,36 @@
+---
+title: "List of Papers"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/trailofbits/awesome-ml-security/blob/d7fe4fa9/impossibility_research.md
+upstream_sha: d7fe4fa9
+imported_at: 2026-06-26
+prompt_class: catalogue
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+# List of Papers
+
+- [You can’t solve AI security problems with more AI](https://simonwillison.net/2022/Sep/17/prompt-injection-more-ai/)
+- [Adversaries Can Misuse Combinations of Safe Models](https://arxiv.org/abs/2406.14595?utm_source=twitter&utm_campaign=elie)
+- [On the Necessity of Auditable Algorithmic Definitions for Machine Unlearning](https://www.usenix.org/system/files/sec22fall_thudi.pdf)
+- [Data Poisoning Won't Save You From Facial Recognition](https://arxiv.org/abs/2106.14851)
+- [On the Impossible Safety of Large AI Models](https://arxiv.org/abs/2209.15259)
+- [Beyond Labeling Oracles: What does it mean to steal ML models?](https://arxiv.org/abs/2310.01959)
+- [Text Embeddings Reveal (Almost) As Much As Text](https://arxiv.org/abs/2310.06816?ref=upstract.com)
+- [Planting Undetectable Backdoors in Machine Learning Models](https://arxiv.org/abs/2204.06974)
+- [Motivating the Rules of the Game for Adversarial Example Research](https://arxiv.org/abs/1807.06732)
+- [On Evaluating Adversarial Robustness](https://arxiv.org/abs/1902.06705)
+- [LLM Censorship: A Machine Learning Challenge or a Computer Security Problem?](https://arxiv.org/abs/2307.10719)
+- [Watermarks in the Sand: Impossibility of Strong Watermarking for Generative Models](https://arxiv.org/abs/2311.04378)
+- [When Your AIs Deceive You: Challenges of Partial Observability in Reinforcement Learning from Human Feedback](https://arxiv.org/abs/2402.17747)
+- [Adversarial Examples Are Not Bugs, They Are Features](https://arxiv.org/abs/1905.02175)
+- [On Adaptive Attacks to Adversarial Example Defenses](https://arxiv.org/abs/2002.08347)
+- [Fundamental Tradeoffs between Invariance and Sensitivity to Adversarial Perturbations](https://arxiv.org/abs/2002.04599)
+- [Data Authenticity, Consent, & Provenance for AI are all broken: what will it take to fix them?](https://arxiv.org/abs/2404.12691)
+- [Proof-of-Learning is Currently More Broken Than You Think](https://ieeexplore.ieee.org/abstract/document/10190491)
+- [On the (In)feasibility of ML Backdoor Detection as an Hypothesis Testing Problem](https://arxiv.org/abs/2402.16926)
+- [Breach By A Thousand Leaks: Unsafe Information Leakage in `Safe' AI Responses](https://arxiv.org/abs/2407.02551)
+- [UnUnlearning: Unlearning is not sufficient for content regulation in advanced generative AI](https://arxiv.org/abs/2407.00106)

upstream/trailofbits-awesome-ml-security/catalogue/prompt-engineering.md

@@ -0,0 +1,150 @@
+---
+title: "Prompt Engineering"
+task: ""
+lineage_type: import
+upstream_source: https://github.com/trailofbits/awesome-ml-security/blob/d7fe4fa9/prompt-engineering.md
+upstream_sha: d7fe4fa9
+imported_at: 2026-06-26
+prompt_class: catalogue
+upstream_changes: accepted
+author: upstream
+validated: false
+---
+
+**This is out-of-date.**
+
+
+
+This is a survey of recent prompt engineering research. Tips and tricks have been extracted from relevant works. Each of these techniques should be taken with a grain of salt as it may not generalize to the chosen task, model, or settings.
+
+### General advice
+- [Everything I'll forget about prompting LLMs](https://olickel.com/everything-i-know-about-prompting-llms)
+
+- [Prompt Programming for Large Language Models: Beyond the Few-Shot Paradigm](https://arxiv.org/abs/2102.07350) 
+    - "Use declarative and direct signifiers for tasks such as translate or rephrase this paragraph so that a 2nd grader can understand it.
+    -  Use few-shot demonstrations when the task requires a bespoke format, recognizing that few-shot examples may be interpreted holistically by the model rather than as independent samples.
+    - Specify tasks using characters or characteristic situations as a proxy for an intention such as asking Gandhi or Nietzsche to solve a task. Here you are tapping into LLMs' sophisticated understanding of analogies.
+    - Constrain the possible completion output using careful syntactic and lexical prompt formulations such as saying "Translate this French sentence to English" or by adding quotes around the French sentence.
+
+- [Encourage the model to break down problems into subproblems via step-by-step reasoning](https://www.mihaileric.com/posts/a-complete-introduction-to-prompt-engineering/)
+
+- [Prompt Engineering Tips and Tricks with GPT-3](https://blog.andrewcantino.com/blog/2021/04/21/prompt-engineering-tips-and-tricks/) 
+    - Make sure your inputs are grammatically correct and have good writing quality as LLMs tend to preserve stylistic consistency in their completions.
+    - Rather than generating a list of N items, generate a single item N times. This avoids the language model getting stuck in a repetitive loop.
+    - In order to improve output quality, [generate many completions and then rank them heuristically](https://www.mihaileric.com/posts/a-complete-introduction-to-prompt-engineering/)."
+
+- [Reframing Instructional Prompts to GPTk's Language](https://arxiv.org/abs/2109.07830) 
+    - Use low-level patterns from other examples to make a given prompt easier to understand for an LLM.
+    - Explicitly itemize instructions into bulleted lists. 
+    - Turn negative statements such as don't create questions which are not to create questions which are.
+    - When possible, break down a top-level task into different sub-tasks that can be executed in parallel or sequentially.
+    - [Avoid repeated and generic statements when trying to solve a very specific task](https://www.mihaileric.com/posts/a-complete-introduction-to-prompt-engineering/)
+
+- [How to get Codex to produce the code you want!](https://microsoft.github.io/prompt-engineering/)
+    - Provide the model with high-level task descriptions, high-level context, examples, and previous user input.  
+    - Set the temperature to 0 if you want the same output each time. 
+    -  Use the stop sequence to stop Codex from generating variations of similar code. 
+    - "Imagine that you already live in a timeline where the output you want exists. If you were using/quoting it in a blog post, what caption or context might you write for it?" ([Twitter](https://twitter.com/davidad/status/1551143240065228800))
+
+- [Ask Me Anything: A simple strategy for prompting language models](https://arxiv.org/abs/2210.02441)
+    - Prioritize open-ended questions over restricted ones. 
+    - Consider using AMA prompting, which combines collections of open-ended prompts with weak supervision. 
+
+- [Legal Prompting: Teaching a Language Model to Think Like a Lawyer](https://arxiv.org/abs/2212.01326)
+
+### Few-Shot and Least-to-Most Prompting
+
+- [Fantastically Ordered Prompts and Where to Find Them: Overcoming Few-Shot Prompt Order Sensitivity](https://arxiv.org/abs/2104.08786)
+    - The order of the examples matter; Consider using a probing technique to identify the optimal order. 
+
+- [Calibrate Before Use: Improving Few-Shot Performance of Language Models](https://arxiv.org/abs/2102.09690) 
+    - Few-shot examples can have majority label bias, recency bias, or common token bias. You can use a calibration technique to overcome this. 
+
+- [Zero-Label Prompt Selection](https://arxiv.org/abs/2211.04668) 
+    - Consider using ZPS, a statistical prompt selection technique. 
+
+-  [Least-to-Most Prompting Enables Complex Reasoning in Large Language Models](https://arxiv.org/abs/2205.10625) 
+    - This is how you use least-to-most prompting:
+      - The first stage is problem reduction. The prompt in this stage contains constant examples that demonstrate the reduction followed by the specific question to be reduced. 
+      - The second stage is for problem-solving -- sequentially solve the generated subproblems from the first stage. The prompt in this stage consists of three parts: (1) constant examples demonstrating how subproblems are solved; (2) a potentially empty list of previously answered subquestions and generated solutions; (3) the question to be answered next.
+
+- [Compositional Semantic Parsing with Large Language Models](https://arxiv.org/abs/2209.15003)
+   - "We address these challenges with dynamic least to-most prompting, a generic refinement of least-to-most prompting that involves the following steps: (1) tree-structured decomposition of natural language inputs through LM-predicted syntactic parsing, (2) use the decomposition to dynamically select exemplars, and (3) linearize the decomposition tree and prompt the model to sequentially generate answers to subproblems."
+
+- [Pre-train, Prompt, and Predict: A Systematic Survey of Prompting Methods in Natural Language Processing](https://arxiv.org/abs/2107.13586)   
+    - This is an older survey of prompt engineering techniques.
+
+### Chain-of-Thought Prompting
+
+- [Large Language Models are Zero-Shot Reasoners](https://arxiv.org/abs/2205.11916) 
+    - You can add the exact phrase "Let's think step by step" for chain-of-thought (CoT) prompting.  
+
+- [Chain of Thought Prompting Elicits Reasoning in Large Language Models](https://arxiv.org/abs/2201.11903)  
+    -  You can write a sequence of questions to force the model to think through the problem step-by-step in what is known as handcrafted CoT. 
+
+- [Complexity-Based Prompting for Multi-Step Reasoning](https://arxiv.org/abs/2210.00720)
+    - You can use a complexity-based scheme to choose answers from prompts with higher reasoning complexity. More broadly, when using CoT, chains with more reasoning steps can perform better. 
+
+- [Measuring and Narrowing the Compositionality Gap in Language Models](https://arxiv.org/abs/2210.03350) ([Twitter thread](https://twitter.com/ofirpress/status/1577302733383925762))
+    - For complex tasks, force the model to ask follow-up questions to arrive at the answer (add "Are follow-up questions needed here? Yes" to the prompt"). In addition, consider integrating a search engine.
+
+### Soft Prompting 
+
+- [Injecting World Knowledge into Language Models through Soft Prompts](https://arxiv.org/abs/2210.04726) 
+    -  Using soft prompting, provide the LLM with an external memory with domain-specific knowledge by adding continuous vectors to the input sequence. 
+
+-  [XPrompt: Exploring the Extreme of Prompt Tuning](https://arxiv.org/abs/2210.04457) 
+    - Consider learning and tuning soft prompts. 
+
+- [Learning to Compose Soft Prompts for Compositional Zero-Shot Learning](https://arxiv.org/abs/2204.03574)
+    - Try using compositional soft prompting for compositional problems.
+
+### Automated Prompt Generation 
+
+- [Large Language Models Are Human-Level Prompt Engineers](https://arxiv.org/abs/2211.01910) & [AutoPrompt: Eliciting Knowledge from Language Models with Automatically Generated Prompts](https://arxiv.org/abs/2010.15980) 
+    - You can use an automated prompt generation technique that relies on gradient-based optimization. 
+
+- [How Can We Know What Language Models Know?](https://direct.mit.edu/tacl/article/doi/10.1162/tacl_a_00324/96460/How-Can-We-Know-What-Language-Models-Know) 
+    - You can use an automated prompt generation technique that relies on mining and paraphrasing.  
+
+- [Prefix-Tuning: Optimizing Continuous Prompts for Generation](https://arxiv.org/abs/2101.00190) 
+    - You can optimize continuous prefixes for the input instead of discrete trigger words in the prompt. 
+
+- [Automatic Chain of Thought Prompting in Large Language Models](https://arxiv.org/abs/2210.03493)
+    - You can sample a diverse set of questions to automatically generate reasoning chains.
+
+### Evaluation Research & Applications
+
+- [A Hazard Analysis Framework for Code Synthesis Large Language Models](https://arxiv.org/abs/2207.14157) 
+- [Evaluating Large Language Models Trained on Code](https://arxiv.org/abs/2107.03374) 
+- [Examining Zero-Shot Vulnerability Repair with Large Language Models](https://arxiv.org/abs/2112.02125) 
+- [Security Implications of Large Language Model Code Assistants: A User Study](https://arxiv.org/abs/2208.09727)
+- [Asleep at the Keyboard? Assessing the Security of GitHub Copilot's Code Contributions](https://arxiv.org/abs/2108.09293)
+- [Pop Quiz! Can a Large Language Model Help With Reverse Engineering?](https://arxiv.org/abs/2202.01142)   
+- [Conversing with Copilot: Exploring Prompt Engineering for Solving CS1 Problems Using Natural Language](https://arxiv.org/abs/2210.15157) 
+- [Red Teaming Language Models with Language Models](https://arxiv.org/abs/2202.03286) & [Red Teaming Language Models to Reduce Harms: Methods, Scaling Behaviors, and Lessons Learned](https://www.anthropic.com/red_teaming.pdf)
+- [Evaluate & Evaluation on the Hub: Better Best Practices for Data and Model Measurements](https://arxiv.org/abs/2210.01970) 
+- [A Systematic Evaluation of Large Language Models of Code](https://arxiv.org/abs/2202.13169) 
+- [Large Language Models Struggle to Learn Long-Tail Knowledge](https://arxiv.org/abs/2211.08411) 
+- [Do Users Write More Insecure Code with AI Assistants?](https://arxiv.org/pdf/2211.03622.pdf)
+
+### Prompt Engineering Libraries
+
+- [PromptSource: An Integrated Development Environment and Repository for Natural Language Prompts](https://arxiv.org/abs/2202.01279#:~:text=PromptSource%3A%20An%20Integrated%20Development%20Environment%20and%20Repository%20for%20Natural%20Language%20Prompts,-Stephen%20H.&text=PromptSource%20is%20a%20system%20for,language%20input%20and%20target%20output)
+- [Interactive and Visual Prompt Engineering for Ad-hoc Task Adaptation with Large Language Models](https://arxiv.org/abs/2208.07852)
+- [PromptChainer: Chaining Large Language Model Prompts through Visual Programming](https://arxiv.org/abs/2203.06566)  
+- [microsoft/prompt-engine: A library for helping developers craft prompts for LLMs](https://github.com/microsoft/prompt-engine)
+- [GPT with Python interpreter](https://twitter.com/sergeykarayev/status/1569377881440276481?s=46&t=voSylmKII0grJoj8juIOYQ)
+- [GPT with a browser](https://twitter.com/sharifshameem/status/1405462642936799247) ([GitHub](https://github.com/nat/natbot))
+
+### Fine-Tuning; Similar Techniques; and Other Experiments 
+
+- [Aligning Language Models to Follow Instructions](https://openai.com/blog/instruction-following/)
+- [Large Language Models Can Self-Improve](https://arxiv.org/abs/2210.11610)
+- [Learning by Distilling Context](https://arxiv.org/abs/2209.15189)
+- [Large Language Models with Controllable Working Memory](https://arxiv.org/abs/2211.05110) 
+- [Prompt Injection: Parameterization of Fixed Inputs](https://arxiv.org/abs/2206.11349) 
+- [Do Prompt-Based Models Really Understand the Meaning of their Prompts?](https://arxiv.org/abs/2109.01247)
+- [Self-Programming Artificial Intelligence Using Code-Generating Language Models](https://openreview.net/forum?id=SKat5ZX5RET)
+- [GitHub - semiosis/prompts: A free and open-source curation of prompts](https://github.com/semiosis/prompts)
+- [Machine Learning for Big Code and Naturalness](https://ml4code.github.io/)