6 techniques drawn from the 12 in our corpus tagged to this work,
each with the paper it came from. Across the techniques below the recurring targets are answers that are close but wrong, the same prompt giving different answers, invented facts and citations.
The techniques
01
Zero-Shot
Revisiting Chain-of-Thought Prompting: Zero-shot Can Be Stronger than Few-shot, arXiv:2506.14641
A technique for activating LLM reasoning mode through a simple instruction "Think step by step" instead of providing solution examples. Research proves that modern models already possess reasoning ability and do not need training examples, only a trigger and clear description of answer format.
Use it whenUse Zero-shot CoT when working with modern powerful LLMs and you need to get a reasoned answer to a task requiring reasoning, analysis or step-by-step solution. Especially effective for mathematical problems, logic puzzles, planning and decision-making. Apply instead of complex few-shot prompts with examples when you want to save tokens and simplify the prompt. Be sure to clearly specify the desired output format through instructions rather than examples.
Prompt
You are a highly skilled developer tasked with planning a complex feature implementation. Your goal is to break down the problem, identify dependencies, and outline a clear, step-by-step execution plan.
### Task Description:
Develop a new "User Profile Management" feature for a web application.
### Core Requirements:
1. **User Authentication:** Secure login and registration.
2. **Profile Editing:** Allow users to update personal information (name, email, avatar).
3. **Password Management:** Secure password reset and change functionality.
4. **Account Deactivation:** Option for users to deactivate their account.
5. **Data Storage:** Persist user data securely in a database.
6. **API Endpoints:** Create RESTful APIs for all functionalities.
7. **Frontend Integration:** Develop UI components for profile management.
### Constraints:
- Adhere to industry-standard security practices (e.g., OWASP Top 10).
- Ensure data privacy compliance (e.g., GDPR if applicable).
- The solution should be scalable and maintainable.
- Target completion for the first iteration: 2 weeks.
### Execution Instructions (Zero-Shot CoT - Step-by-Step Reasoning):
**1. Decompose the Task:**
Break down the overall "User Profile Management" feature into its smallest logical components and sub-tasks. Think step by step about each distinct piece of functionality required.
**2. Identify Dependencies:**
For each component identified in step 1, determine its dependencies on other components, external services, or specific technologies. Map out the order in which tasks must be completed.
**3. Plan Implementation Steps:**
Outline a detailed, sequential plan for implementing the feature. This should include:
* Technology stack choices (backend, frontend, database).
* Specific implementation details for each component (e.g., hashing algorithms for passwords, API request/response structures).
* Testing strategy (unit tests, integration tests).
* Deployment considerations.
**4. Define Output Format:**
Present the final plan in a structured format using Markdown. Use clear headings, bullet points, and code blocks where appropriate.
**Output Structure:**
## Feature: User Profile Management
### 1. Task Decomposition:
- **Authentication:**
- Registration API
- Login API
- Token Generation/Validation
- **Profile Management:**
- Fetch Profile API
- Update Profile API
- Avatar Upload API
- **Password Management:**
- Change Password API
- Password Reset Request API
- Password Reset Confirmation API
- **Account Management:**
- Deactivate Account API
- **Database Schema:**
- `users` table definition
- `password_reset_tokens` table definition
- **Frontend Components:**
- Registration Form
- Login Form
- Profile Edit Form
- Password Change Form
- Account Settings Page
### 2. Dependencies & Technology Stack:
- **Backend:** [Specify Language/Framework, e.g., Python/FastAPI]
- **Database:** [Specify DB, e.g., PostgreSQL]
- **Authentication:** [Specify method, e.g., JWT, OAuth]
- **Frontend:** [Specify Framework, e.g., React]
- **Security Libraries:** [Specify, e.g., bcrypt for hashing]
- **Order of Implementation:** [List key dependencies, e.g., Database Schema -> Auth APIs -> Profile APIs -> Frontend Components]
### 3. Detailed Implementation Plan:
#### 3.1. Backend Development:
- **Database Setup:**
```sql
-- Example SQL for users table
CREATE TABLE users (
id UUID PRIMARY KEY,
email VARCHAR(255) UNIQUE NOT NULL,
password_hash VARCHAR(255) NOT NULL,
first_name VARCHAR(100),
last_name VARCHAR(100),
avatar_url VARCHAR(255),
created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
is_active BOOLEAN DEFAULT TRUE
);
```
- **Authentication APIs:**
- `POST /auth/register`: [Details on request body, validation, password hashing, response]
- `POST /auth/login`: [Details on request body, password verification, JWT generation, response]
- **Profile APIs:**
- `GET /users/me`: [Details on authentication, data retrieval, response]
- `PUT /users/me`: [Details on request body, validation, security checks, response]
- **Password Management APIs:**
- `POST /auth/reset-password/request`: [Details on email sending, token generation]
- `POST /auth/reset-password/confirm`: [Details on token validation, password update]
- **Account Management APIs:**
- `DELETE /users/me`: [Details on soft delete vs hard delete, confirmation]
#### 3.2. Frontend Development:
- **UI Components:**
- Registration Form: [Key fields, validation logic]
- Login Form: [Key fields, error handling]
- Profile Edit Form: [Fields, avatar upload integration]
- **State Management:** [Briefly mention approach]
- **API Integration:** [How components will interact with backend APIs]
#### 3.3. Testing Strategy:
- **Unit Tests:** [Areas to cover, e.g., password hashing, validation logic]
- **Integration Tests:** [Key API endpoints to test, e.g., login flow]
#### 3.4. Security Considerations:
- [List specific security measures, e.g., input sanitization, rate limiting, HTTPS]
#### 3.5. Timeline & Milestones (2 Weeks):
- **Week 1:** Backend API development (Auth, Profile), Database Schema.
- **Week 2:** Frontend Component development, API integration, Testing, Deployment preparation.
### 4. Conclusion:
Summarize the plan and highlight any potential risks or areas requiring further refinement.
ThinkPatterns-21k: A Systematic Study on the Impact of Thinking Patterns in LLMs, arXiv:2503.12918
The Think-then-Respond method makes the model "think" in a specific way before responding. Effectiveness depends on model size: larger models work better with free-form monologue, smaller ones with structured instructions (decomposition, self-questioning, debates, self-criticism). An advanced Chain-of-Thought variant adapted for model size.
Use it whenApply this technique when working on tasks requiring reasoning and analysis. For large models (>32B parameters), use unstructured monologue, giving the model freedom in choosing a solution path. For small models (<30B parameters), apply structured patterns: task decomposition, self-questioning, internal debates, or self-criticism. Particularly effective for complex analytical tasks, decision-making, content generation, and research queries where reasoning quality matters.
Prompt
# ROLE
You are an AI assistant tasked with planning a complex project.
# CONTEXT
The user needs to plan a multi-step project. The specific details of the project are not provided, but the core requirement is a structured, systematic approach to planning.
# TECHNIQUE: ThinkPatterns 21k - Decomposition (for smaller models)
This technique is chosen because the user's task is a complex planning problem, and the prompt needs to be structured to guide the LLM effectively. We are assuming the LLM might be a smaller model (<30 billion parameters) that benefits from clear, structured instructions.
# EXECUTION INSTRUCTIONS: DECOMPOSITION THINK-THROUGH
Before providing the final plan, you must meticulously break down the task into smaller, manageable components and analyze each one. Follow these 6 stages of decomposition:
## Stage 1: Problem Scoping & Understanding
- Clearly define the overall objective of the project.
- Identify the primary goal(s) and desired outcome(s).
- What are the key constraints or limitations (e.g., time, resources, scope)?
- What is the expected final deliverable?
## Stage 2: Component Identification
- Decompose the main project into its core, high-level components or phases.
- List these components in a logical sequence.
## Stage 3: Sub-Problem Analysis
- For each identified component from Stage 2, perform a detailed analysis:
- What are the specific tasks within this component?
- What are the dependencies for these tasks?
- What resources are needed for each task?
- What are the potential challenges or risks associated with this component?
## Stage 4: Connection Mapping
- Analyze the relationships and dependencies between the components identified in Stage 2.
- How does the completion of one component enable or affect the next?
- Map out the critical path if applicable.
## Stage 5: Integration Strategy
- Outline a strategy for integrating all components into a cohesive, executable plan.
- How will progress be tracked and managed across different components?
- Define milestones for key stages of integration.
## Stage 6: Solution Validation
- Review the entire decomposed plan against the initial problem statement (Stage 1).
- Does the plan comprehensively address all objectives and constraints?
- Is the plan realistic and actionable?
- Identify any potential gaps or areas for refinement.
# FINAL DELIVERABLE
After completing the detailed 6-stage decomposition and validation process above, present the final, integrated project plan. Structure this plan clearly, perhaps using sections for phases, key tasks, timelines, and resource allocation.
Reasoning Transfer for an Extremely Low-Resource and Endangered Language: Bridging Languages Through Sample-Efficient Language Understanding, arXiv:2504.02890
A method that forces a language model to perform internal reasoning in English, even if the request and final answer are in another language. The process is divided into two stages: first the model 'thinks' in English, then formulates the answer in the target language. This leverages the advantage of the model's stronger logical abilities in English due to the predominance of English data in training.
Use it whenUse this technique when working with language models in low-resource languages (non-English) and solving complex logical, mathematical or analytical tasks. Particularly effective for multilingual scenarios where a request comes in one language but requires deep reasoning. Apply when you notice a decline in the quality of model responses in non-English languages on tasks requiring multi-step thinking. The method is suitable for situations where you can separate the process into a reasoning stage
Never Come Up Empty: Adaptive HyDE Retrieval for Improving LLM Developer Support, arXiv:2507.16754
A two-stage prompting technique: first, a hypothetical 'ideal answer' to a question is generated, then it's used as a semantic template for creating the final answer. The model stops guessing content and follows the sample structure, yielding 2-3 times more complete and accurate results compared to direct questioning.
The model stops guessing content and follows the sample structure, yielding 2-3 times more complete and accurate results compared to direct questioning.checked against the paper
Use it whenUse Adaptive HyDE when you receive superficial or incomplete answers to complex questions, especially in highly specialized fields. Ideally suited for working with RAG systems, when a short query doesn't find relevant information in the knowledge base. Apply when deep, structured answers are needed instead of general formulations. Particularly effective for technical questions, research tasks, and situations where detail and accuracy are important. The technique helps when the model 'doesn't
S2LPP: Small-to-Large Prompt Prediction across LLMs, arXiv:2505.20097
A cross-model prompt validation method that finds optimal formulations for large LLMs by testing variants on small fast models. Based on discovering similar prompt preferences across models of different sizes from the same family. Reduces prompt engineering costs while maintaining result quality.
Use it whenUse the S2LPP method when you need to optimize prompts for expensive or slow large language models while reducing testing costs. Especially effective when working with multiple prompt formulation variants and it's unclear which will produce better results. Suitable for situations where you have access to smaller versions of the same model family or free alternatives. Ideal for systematic prompt optimization in production where resource efficiency is important while maintaining
Vikhr: The Family of Open-Source Instruction-Tuned Large Language Models for Russian, arXiv:2405.13929
Language adaptation method for tokenizer to create effective LLMs in non-English languages. Includes developing a specialized token dictionary for the target language and fine-tuning the model on the corresponding text corpus. Solves problems of inefficient word segmentation, context loss, and reduced understanding quality in multilingual models.
Use it whenApply this technique when creating or adapting language models to work with non-English languages, especially Russian. Critically important when developing LLM applications requiring efficient processing of large text volumes in the target language. Use when encountering inefficient tokenization problems: the model poorly understands context, quickly exhausts the context window, generates slow responses, or makes semantic errors. Particularly relevant for chatbot developers, RAG systems, and content generators working with Russian-speaking users, where text processing quality and speed directly impact user experience.
A missing brief. No structure around a request invents the context the model
does not have: your constraints, your audience, your prior decisions. Technique work pays off
after the brief is right, not instead of it.
Stale tricks. Persona lines, politeness and offers of a reward have been
measured repeatedly through 2025 and 2026 and come out close to noise. Anything selling you
those is selling 2023.
Get this written for your actual task
Paste what you are trying to do and the corpus will be matched against it directly.
Free, no account, about ten seconds.
Free · no signup · ~10s
0.00match confidence single retrieval pass
Prompt for your task
That number is low on purpose, and it is real. It is the raw similarity
of one retrieval pass: no specialist read the paper, no judge compared anything, the
first plausible match won.
6,235techniques in the corpus one of which is this page
Picking the right one for a specific task is the work, and it is the work GetDecision does.
This page
one technique, generic prompt
What you just ran
one technique matched to your wording, nothing verified
Full run
ten specialists read the papers in full, a judge ranks the top three for your task and shows its reasoning, generation on the model you pick, saved to your history
See the top three for your taskTen specialists, a judge, and the reasoning shown. Free account, first run included.