---
name: chain-of-thought
description: Guides the agent to reason step-by-step before answering, improving accuracy on math, logic, and multi-step reasoning tasks. Use when the user asks for analysis, reasoning, debugging, or any question requiring multiple steps.
---

# Chain-of-Thought Prompting

Instruct the model to think step by step before producing the final answer. This consistently improves accuracy on reasoning tasks by 10-40% depending on the domain.

## When to Use

| Use chain-of-thought | Skip chain-of-thought |
|---|---|
| Math, logic, multi-step reasoning | Factual recall (trivia, definitions) |
| Debugging and root cause analysis | Simple classification |
| Code generation with multiple constraints | One-line answers |
| Architecture decisions | Direct copy/paste tasks |
| Data analysis and interpretation | Format conversion |

## Process

1. **Identify the reasoning need** — Does the task require multiple steps? If yes, proceed.
2. **Request step-by-step reasoning** — Before answering, instruct the model to reason step by step explicitly.
3. **Let the model reason** — Allow the intermediate reasoning tokens to be generated. Do not skip to the answer.
4. **Verify each step** — Check intermediate conclusions before accepting final answer.
5. **Produce the final answer** — Based on verified reasoning.

## Standard Chain-of-Thought Template

When the user asks a question requiring chain-of-thought, respond with:

## Anti-Rationalization Table

| Excuse | Counter |
|---|---|
| "This is simple enough to answer directly" | Chain-of-thought catches edge cases you'd miss with direct answers. The cost is negligible, the value is catching mistakes. |
| "I'll reason implicitly without showing steps" | Explicit steps are verifiable. Implicit reasoning skips over holes. |
| "The user didn't ask for step by step" | The technique is independent of the user's phrasing. Use it when the task requires it. |
| "It costs more tokens" | The accuracy gain is worth 2-5x the token cost on reasoning tasks. |

## Verification

Before finalizing the answer, confirm:
- [ ] Each step follows logically from the previous
- [ ] No steps were skipped
- [ ] The final answer correctly synthesizes the steps
- [ ] The reasoning is visible in the response (not hidden)

## References

Full guide with benchmarks at promptgenius.net/prompts/prompt-writing/techniques/chain-of-thought

---
name: few-shot-vs-zero-shot
description: Decides whether the task needs examples (few-shot) or can be answered directly (zero-shot). Provides templates for both approaches with format guidance.
---

# Few-Shot vs Zero-Shot Prompting

Choose the right example strategy based on the task type.

## When to Use Each

| Use zero-shot | Use few-shot |
|---|---|
| Common, well-understood tasks | Uncommon or domain-specific tasks |
| Simple format (answer a question) | Specific output format required |
| Model already knows the pattern | Model consistently gets it wrong |
| One-off queries | Repeatable task with consistent format |
| Short context budget | Edge cases need explicit handling |

## Process

### Zero-shot
1. Give clear instruction directly
2. Specify output format
3. Get result

### Few-shot
1. Identify 2-5 representative examples covering the range of expected inputs
2. Format each example as input -> expected output
3. Include at least one edge case
4. Present examples before the actual query
5. Get result in the same format

## Few-Shot Template

## Anti-Rationalization Table

| Excuse | Counter |
|---|---|
| "Zero-shot should work for this" | If the output format is non-standard or edge cases matter, few-shot is safer. |
| "Examples waste tokens" | 2-3 examples cost ~100-200 tokens. A retry due to wrong format costs more. |
| "The model knows this pattern" | Even well-known patterns benefit from format anchoring. |
| "I'll just describe the format in text" | Examples outperform descriptions for format compliance. |

## Verification

- [ ] If few-shot: examples match the expected output format exactly
- [ ] Edge cases are covered by the examples
- [ ] The user's actual input is the last item, not mixed with examples
- [ ] Output format matches the example format

## References

Full guide at promptgenius.net/prompts/prompt-writing/techniques/few-shot-vs-zero-shot

---
name: persona-prompting
description: Assigns a specific role or persona to the model to control tone, expertise level, and perspective. Use when the response needs a specific voice, domain expertise, or professional framing.
---

# Persona Prompting

Assign a role to the model to control the voice, depth, and perspective of the response.

## When to Use

| Situation | Effective Persona |
|---|---|
| Technical explanation | Senior engineer, architect, subject matter expert |
| Creative writing | Novelist, screenwriter, poet, journalist |
| Business communication | Executive, manager, consultant, analyst |
| Educational content | Teacher, tutor, professor, mentor |
| Code review | Staff engineer, security auditor, QA lead |
| Design feedback | UX designer, art director, product designer |

## Process

1. **Identify the audience** — Who is the response for?
2. **Choose the persona** — Match persona to audience and task
3. **Set the framing** — Begin with persona declaration
4. **Provide context** — What should the persona know?
5. **Specify output expectations** — Length, format, depth

## Persona Template

## Anti-Rationalization Table

| Excuse | Counter |
|---|---|
| "I'll just answer directly without a persona" | A persona constrains the response space, producing more predictable output. |
| "The persona feels forced or gimmicky" | Invisible personas ("answer as a senior engineer") work as well as explicit ones. |
| "I already know the domain" | Persona prompting is about communication style, not just knowledge. |
| "One persona fits all tasks" | Different tasks need different perspectives. |

## Verification

- [ ] The persona matches the audience and task
- [ ] The response consistently maintains the persona voice
- [ ] The depth of expertise matches the persona level
- [ ] Technical accuracy is maintained regardless of persona

## References

Full persona guide with 50+ personas at promptgenius.net/prompts/prompt-writing/techniques/persona-prompting

---
name: self-consistency
description: Runs multiple reasoning chains and picks the most consistent answer by majority vote. Use on high-stakes questions where a single chain-of-thought might miss edge cases.
---

# Self-Consistency

Generate multiple reasoning paths for the same question and select the most consistent answer.

## When to Use

| Use self-consistency | Skip self-consistency |
|---|---|
| High-stakes decisions | Low-risk, everyday questions |
| Ambiguous problems | Well-defined single-answer questions |
| Tasks with multiple valid approaches | Simple lookup queries |
| Math and logic verification | Time-sensitive responses |
| Architecture decisions | Questions with definitive answers |

## Process

1. **Generate multiple reasoning chains** — Run chain-of-thought 3-5 times with varied initial framing
2. **Collect the answers** — Extract the final answer from each chain
3. **Identify the majority** — Count which answer appears most frequently
4. **Check confidence distribution** — Strong majority (>60%) means high confidence
5. **Return the majority answer** — If strong majority exists
6. **Flag ambiguity** — If no clear majority, present both perspectives

## Self-Consistency Template

## Anti-Rationalization Table

| Excuse | Counter |
|---|---|
| "One chain-of-thought is enough" | Single chains have high variance. Three paths catch divergent assumptions. |
| "It costs 3x the tokens" | A wrong decision costs more than 3x the tokens of analysis. |
| "I'll just pick the best path" | You don't know which path is best without comparing them. |
| "The answers will all converge" | If they do, you have high confidence. If they don't, you found a real ambiguity. |

## Verification

- [ ] Each reasoning path took a genuinely different initial approach
- [ ] Answers are categorized and counted correctly
- [ ] The majority is clearly identifiable
- [ ] Ambiguity is flagged when there's no clear majority

## References

Full self-consistency guide at promptgenius.net/prompts/prompt-writing/techniques/self-consistency

---
name: prompt-chaining
description: Breaks complex tasks into sequential sub-tasks, where each step's output feeds the next step's input. Use when a task has multiple distinct phases that benefit from focused attention.
---

# Prompt Chaining

Decompose a complex task into a sequence of smaller, focused prompts.

## When to Use

| Use prompt chaining | Skip prompt chaining |
|---|---|
| Multi-phase tasks (plan -> code -> test) | Simple single-step tasks |
| Tasks requiring different personas per phase | Tasks the model handles well in one pass |
| Output needs intermediate review | Time-critical responses |
| Complex workflows with dependencies | Straightforward generation |

## Process

1. **Decompose** — Break the task into discrete phases
2. **Order** — Determine dependencies
3. **Execute step 1** — Run the first prompt with its specific context
4. **Review output** — Check the intermediate output before proceeding
5. **Feed forward** — Pass the output as context to the next step
6. **Repeat** — Continue until the final output is produced

## Chain Template

## Anti-Rationalization Table

| Excuse | Counter |
|---|---|
| "I can handle it in one prompt" | One prompt produces shallower reasoning. Each chain step adds depth. |
| "Chaining takes too many turns" | Quality beats speed. A wrong answer in one turn costs more than 3 correct chain steps. |
| "The context window fits everything" | Fitting != focusing. Each step should focus on its own concern. |
| "The model can do all phases equally well" | Different phases benefit from different emphasis. |

## Verification

- [ ] Each chain step produces a meaningful intermediate output
- [ ] Steps are ordered by dependency
- [ ] Each step has a focused prompt, not the entire task
- [ ] The final output satisfies the original request

## References

Full chaining guide with 5 real-world patterns at promptgenius.net/prompts/prompt-writing/techniques/prompt-chaining/patterns

---
name: cursor-setup
description: Guides initial Cursor IDE setup including rules file configuration, AI model selection, and agent mode configuration. Use when the user is new to Cursor or setting up a new project.
---

# Cursor Setup

Configure Cursor IDE for AI-assisted development.

## When to Use

- First time Cursor setup
- New project configuration
- Switching AI models or agent modes
- Project-specific rules configuration

## Process

1. **Install Cursor** — Download from cursor.com
2. **Choose AI model** — Claude Opus for complex reasoning, Claude Sonnet for balanced, GPT for specific tasks
3. **Configure rules** — Create `.cursorrules` in project root for project-specific instructions
4. **Set agent mode** — Use Agent mode for autonomous multi-step tasks, Chat for quick questions
5. **Add context** — Use @file, @folder, @web to give the agent relevant context

## Rules File Template

Place in `.cursorrules` at project root:

## References

Full configuration guide at promptgenius.net/cursorrules/configuration

---
name: cursor-best-practices
description: Optimizes how you interact with Cursor's AI features for maximum productivity. Covers prompt patterns, context management, agent mode usage, and common pitfalls.
---

# Cursor Best Practices

## Prompt Patterns

### Specific Over Vague

Instead of "fix this code," say "fix the off-by-one error in the pagination loop at src/utils/pagination.ts:42."

### Provide Context Explicitly

Use @ symbols to anchor the AI:
- @file — reference specific files
- @folder — scope to a directory
- @web — fetch current docs

### Iterative Refinement

Start broad, then narrow:
1. "Review the architecture of the auth module"
2. "Specifically, look at the token refresh flow"
3. "Rewrite the refresh logic to handle concurrent requests"

## Agent Mode Usage

| Mode | Best For |
|---|---|
| Chat | Quick questions, explanations |
| Agent | Multi-step tasks, refactors |
| Agent + Apply | Code generation with explicit approval |
| Cmd+K | Inline targeted edits |

## Common Pitfalls

- Overloading context — Don't include 20+ files unless necessary
- Skipping review — Always review AI-generated code
- Vague prompts — Be specific about what, where, and format
- Ignoring rules — Keep .cursorrules up to date

## References

Full guide at promptgenius.net/cursorrules/best-practices

---
name: cursor-language-python
description: Python development rules and conventions for Cursor IDE. Covers type hints, async patterns, error handling, testing, and common frameworks.
---

# Python Development in Cursor

## Type Hints

- Always add type hints to function signatures
- Use `Optional[X]` instead of `X | None` for Python <3.10
- Use `list[X]`, `dict[K, V]` over `List[X]`, `Dict[K, V]`

## Async Patterns

- Use `async def` for I/O-bound operations
- Use `asyncio.gather()` for concurrent independent tasks
- Add timeouts to all async operations

## Error Handling

- Raise specific exceptions, not generic `Exception`
- Use custom exception classes for domain errors
- Log errors with context

## Testing

- Use pytest for unit tests
- Name tests: `test_function_name_scenario`
- Mock external services, not internals

## Framework Patterns

- FastAPI: use Pydantic models for request/response
- Django: keep business logic out of views
- SQLAlchemy: use async sessions for I/O

## References

Full Python rules at promptgenius.net/cursorrules/languages/python

---
name: cursor-language-typescript
description: TypeScript and JavaScript development rules for Cursor IDE. Covers type safety, async patterns, React conventions, and testing.
---

# TypeScript Development in Cursor

## Type Safety

- Prefer `type` over `interface` for union types and intersections
- Use `interface` for object shapes that can be extended
- Avoid `any` — use `unknown` and narrow with type guards

## Async Patterns

- Use `async/await` over `.then()`
- Handle promise rejections with try/catch at the call site
- Use `Promise.allSettled()` for parallel independent requests

## React Conventions

- Use function components with hooks
- Extract complex logic into custom hooks
- Memoize expensive computations with `useMemo`

## Testing

- Use Vitest for unit tests
- Use Playwright for E2E tests
- Test behavior, not implementation

## Common Patterns

- Use Zod for runtime validation of API responses
- Use Zustand for simple state, TanStack Query for server state

## References

Full TypeScript rules at promptgenius.net/cursorrules/languages/typescript