Write a reply to the email below. Tone: {professional but warm}. Goal: {decline the request without burning the relationship}. Keep it under {120} words. Don't apologise more than once.

Email:
```
{paste email here}
```

Write a cold email to {target_name}, {their_role} at {company}. I'm {your_name}, {your_role}. We help {what_you_help_with}. Hook: {something specific you noticed about them}. Keep it under 120 words. End with one specific question they can answer in one line.

Summarise the document below in three layers:

1. **TL;DR** — one sentence.
2. **Key points** — bullet list, max 7.
3. **Action items** — what should I actually do based on this?

Document:
```
{paste here}
```

Write a Twitter post (max 280 chars) about: {topic}.

Tone: {casual, direct, mildly opinionated}. No hashtags. Include exactly {one} concrete detail or stat. Avoid AI-cliche phrases like 'in today's world' or 'unlock the power of'.

Rewrite the text below to sound more human and less AI-generated. Vary sentence length more. Use occasional contractions. Cut hedges ("may", "can be", "perhaps"). Keep the same factual content.

Text:
```
{paste here}
```

Edit the text below for clarity only. Don't change the voice or tone. Find: redundant phrases, unclear pronouns, sentences over 30 words, jargon without context. Return: the edited text + a numbered list of what you changed and why.

Text:
```
{paste here}
```

Review the code below. Focus on:
1. Bugs or logic errors
2. Security issues
3. Readability / naming
4. Performance issues that actually matter

Skip nitpicks (style, formatting). Be direct — assume I'm a senior engineer.

```{language}
{paste code here}
```

Explain the code below at the level of a {junior developer who just learned the language}. Annotate each block with what it does and why. End with a one-paragraph summary of the overall design choice.

```{language}
{paste code here}
```

Translate the SQL query below into plain English a non-technical PM would understand. Don't include the table names — just describe what we're getting and any filters / aggregations applied.

```sql
{paste SQL here}
```

Write a regex that matches: {describe what you want to match, with examples and counter-examples}. Return:
1. The regex itself
2. A line-by-line explanation
3. 5 test inputs with expected match / no-match results

Write {pytest} tests for the function below. Cover: happy path, edge cases (empty/None/large), boundary values, and at least one realistic failure mode. Use parametrize where it makes sense.

```python
{paste function here}
```

Refactor the function below for readability. Same behaviour, clearer code. Extract sub-functions only if it actually helps. Use early returns. Name variables for what they mean, not what they are. Briefly explain each change at the end.

```{language}
{paste code here}
```

I'm hitting this error:

```
{paste full stack trace here}
```

Code that produced it:
```{language}
{paste relevant code}
```

Tell me:
1. The most likely root cause (with reasoning)
2. The fix
3. Two other things that could cause this same error if I'm wrong about #1

I currently believe: {your_position}.

Steelman the opposing view in the strongest possible terms. Use 4-5 paragraphs. Don't strawman, don't write 'some say'. Make the strongest version of someone who actually disagrees with me. End with: 'A reasonable person might still disagree because…'

I'm choosing between these options:
1. {option_A}
2. {option_B}
3. {option_C}

My priorities (most important first): {priorities}.

Build a decision matrix. Rate each option (1-10) on each priority. Sum and recommend. Tell me which factor would change your recommendation if it shifted.

I'm about to {decision or project}. Run a pre-mortem: assume it's 6 months later and this failed badly. Walk me through the most likely failure modes, ranked by probability × impact. For each, give one specific thing I should do now to prevent it.

Apply the 5-Whys technique to: {problem}.

After each 'why', take the answer and ask 'why' again. Stop when you hit a root cause that's actionable. Then: propose two specific fixes, one tactical and one systemic.

Brainstorm 20 ideas for: {topic}.

Quantity over quality. Include some weird, impractical or risky ones. Group them at the end into: 'safe', 'medium', 'wild'. Don't number-pad — if you only have 12 good ones, give me 12.

Explain {topic} like I'm 12 years old and curious. Use one analogy from everyday life. Avoid jargon — if you must use a technical term, define it the first time.

Quiz me on {topic} with 10 multiple-choice questions. Mix difficulty (3 easy, 5 medium, 2 hard). Show me one question at a time. After I answer, tell me if I'm right and why. Track my score.

Compare and contrast {thing_A} and {thing_B}. Structure:

1. **What they have in common** — bullet list
2. **Key differences** — bullet list
3. **When to pick each** — one paragraph each
4. **Common mistakes** — what people get wrong about the difference

I want to learn {topic} starting from {current_level}. I have {hours_per_week} hours per week and a goal of {what_you_want_to_achieve} in {timeframe}.

Build me a week-by-week study plan. Include resources (books, courses, practice problems). Budget time for spaced review. End each week with a self-test.

Turn these meeting notes into a professional summary email. Sections:

1. **Decisions made**
2. **Action items** — owner, deadline, what specifically
3. **Open questions** — what we still need to figure out
4. **Next meeting** — date and agenda preview

Notes:
```
{paste notes here}
```

I'm prepping for a 1-1 with {my_manager}. My current focus: {what_you're_working_on}. Recent wins: {wins}. Recent struggles: {struggles}.

Help me prepare:
1. 3 things I should proactively share
2. 2 questions I should ask my manager
3. 1 ask (resource, decision, support) I should make

Rewrite this Slack message so it's more likely to actually get a reply. It's currently too long / vague / passive. Make it scannable, end with a clear ask with a deadline.

Message:
```
{paste message here}
```

I'm setting OKRs for {team or project} for {Q1 / Q2 / etc}. Top-level goal: {goal}. Constraints: {team size / budget / time}.

Suggest 3 candidate Objectives. For each, propose 3 Key Results — measurable, time-bound, ambitious-but-not-impossible. Flag any KRs that risk gaming.

Brainstorm 30 product name candidates for: {product description}. Mix of styles: invented words, descriptive compounds, metaphors, person names, abstract verbs. Include a 1-line tagline for each. End with your top 3 picks and why.

Write 5 different opening paragraphs for a story about: {premise}. Each should use a different technique: in-medias-res, dialogue-first, single haunting image, unreliable-narrator confession, sensory immersion. Each opening: 80-150 words.

Workshop my story logline.

Current logline: {your_logline}

1. What's working
2. What's confused or weak
3. Three rewrites — each emphasising a different angle (character / conflict / theme)
4. Recommend one rewrite as the strongest, with reasoning

Generate 25 taglines for: {product / company}. Tone: {bold and witty}. Mix lengths: 3-word punchy, 7-word descriptive, 12-word storytelling. Include a couple of self-deprecating ones. Don't use the words {forbidden_words}.

I'm thinking about: {idea}. 

Roast it. Be honest, specific, slightly mean — but constructive. Find 5 weak spots in the idea. For each, suggest one way to fix or sidestep it. End with: 'Here's how I'd actually pitch this if I was forced to.'