Act as a staff engineer reviewing a pull request. Review the code below for: correctness bugs, edge cases, security issues, naming, and unnecessary complexity — in that priority order.

For each issue: quote the exact line, explain why it's a problem in one sentence, and show the fixed code. Skip style nitpicks a linter would catch. End with a verdict — approve, approve-with-nits, or request-changes — plus the single most important fix.

Language: [LANGUAGE]
Context: [WHAT THIS CODE DOES AND WHERE IT RUNS]

Code:
[PASTE CODE]

Debug this error systematically. Don't guess.

1. Read the stack trace and tell me the exact line where it throws and what the runtime was trying to do.
2. List the 3 most likely root causes, ranked by probability, each with the evidence from the trace that supports it.
3. For the top cause, give me the smallest change that fixes the root cause (not a try/catch that hides it).
4. Tell me what to log or check to confirm the diagnosis before I ship the fix.

Error and stack trace:
[PASTE FULL ERROR]

Relevant code:
[PASTE THE FUNCTIONS IN THE TRACE]

What I already tried: [WHAT YOU TRIED]

Refactor the function below. Rules:

- Behavior must stay identical, including edge cases and error paths. List any behavior you're unsure about BEFORE refactoring.
- First write 3-5 test cases (input → expected output) that pin the current behavior, including one edge case and one failure case.
- Then show the refactored version, noting each change and why it's safe.
- Do not add abstractions, config options, or "flexibility" the current code doesn't need.

[PASTE FUNCTION]

Write unit tests for the function below using [TEST FRAMEWORK, e.g. pytest / Jest / RSpec].

Cover, in this order: the happy path (1-2 tests), boundary values (empty input, zero, max size, unicode), invalid input (wrong type, null/undefined), and failure modes (what should throw vs return a default).

For each test, add a one-line comment saying what regression it would catch. If you spot an input the function currently handles incorrectly, write the test the code SHOULD pass and flag it as a probable bug.

[PASTE FUNCTION]

I just opened this file in a codebase I don't know. Explain it top-down:

1. One paragraph: what this file is responsible for and what probably calls it.
2. A map of the pieces: each function/class in one line, marked [core logic], [glue], or [config/boilerplate].
3. The one function I should read first to understand the rest, walked through line by line.
4. Anything surprising: hidden side effects, global state, weird naming, or code that doesn't match what it claims to do.

File ([LANGUAGE], from [PROJECT TYPE]):
[PASTE FILE]

Write a SQL query for [DATABASE: PostgreSQL / MySQL / SQLite].

Schema:
[PASTE CREATE TABLE STATEMENTS OR COLUMN LISTS]

What I want: [PLAIN ENGLISH, e.g. "monthly revenue per customer segment for the last 6 months, only segments with 10+ customers"]

Requirements: use explicit JOINs, alias every table, comment each non-obvious clause, and avoid SELECT *. After the query, state one assumption you made about the schema and how the query breaks if that assumption is wrong.

Build a regex for this pattern: [DESCRIBE WHAT TO MATCH, e.g. "US phone numbers with optional country code and any common separator"].

Flavor: [JavaScript / PCRE / Python re / grep -E]

Give me:
1. The regex.
2. A piece-by-piece breakdown of what each part matches.
3. A test table: 5 strings that should match and 5 that shouldn't (including near-misses), with the result for each.
4. Known limitations — inputs it will wrongly accept or reject.

If the pattern genuinely can't be done reliably in regex (nested structures, full email validation), say so and give the practical 95% version.

Review this REST API design like an engineer who will be woken up when it breaks.

Endpoints:
[LIST ENDPOINTS: METHOD, PATH, REQUEST/RESPONSE SHAPE]

Check: resource naming and HTTP verb correctness, status codes, pagination strategy, error response shape (consistent and machine-readable?), versioning, idempotency of writes, and what happens under partial failure.

For each problem: severity (breaking / painful / cosmetic), why it hurts in practice, and the fix. Then show the corrected endpoint table.

Convert this [SOURCE LANGUAGE] code to [TARGET LANGUAGE].

Rules:
- Write idiomatic [TARGET LANGUAGE], not a line-by-line transliteration — use the target's standard library, error-handling style, and naming conventions.
- Keep behavior identical. Where the languages genuinely differ (integer division, string encoding, null handling, concurrency), add a comment at that exact line explaining the difference.
- List any dependencies the target version needs and their install commands.

[PASTE CODE]

Profile this code by reading it. Find performance problems in priority order:

1. Algorithmic complexity: anything O(n²) or worse that could be O(n log n) or O(n) — show the reasoning.
2. Hidden I/O in loops: queries, network calls, file reads that should be batched or hoisted.
3. Memory: unnecessary copies, unbounded growth, large intermediate structures.

For each: the line, estimated impact at [EXPECTED SCALE, e.g. "10k items, 100 requests/sec"], and the fixed code. Don't micro-optimize anything outside a hot path. If it's already fine at my scale, say "this is fine" — don't invent problems.

[PASTE CODE]

Write a commit message and PR description for this diff.

Commit message: imperative mood, title under 70 characters, body explaining WHY (the problem) — the diff already shows what.

PR description with these sections: Problem (2-3 sentences), What changed (bulleted, grouped by area), How to test (exact commands or click-path), Risk (what could break and what to watch after deploy).

Don't invent context — if the diff doesn't tell you why, put [FILL: reason] where I need to add it.

Diff:
[PASTE git diff OUTPUT]

Security-review this code as if it will face the public internet tomorrow.

Trace every path where external input enters, and check each against: injection (SQL/command/template), XSS, path traversal, insecure deserialization, authorization gaps (does it verify the user owns the resource?), secrets in code or logs, and unsafe defaults.

For each finding: severity (critical/high/medium/low), the vulnerable line, a realistic attack input, and the fixed code. Missing input validation at a trust boundary counts as a finding even without a proven exploit. End with the top 1-2 fixes to make today.

Context: [WHERE THIS RUNS, WHO CAN REACH IT]
[PASTE CODE]

Write a Dockerfile (and docker-compose.yml if services are needed) for this project:

Stack: [LANGUAGE + VERSION, FRAMEWORK, DATABASE, OTHER SERVICES]
Package files: [PASTE package.json / requirements.txt / Gemfile SUMMARY]

Requirements: multi-stage build (small final image), dependency layer cached separately from source code, non-root user, health check, and .dockerignore contents. Comment each non-obvious instruction with the problem it prevents. Then give me the exact commands to build, run, and verify it's healthy.

Help me pick between two implementations. Argue both sides properly before deciding.

Problem: [WHAT YOU'RE BUILDING AND FOR WHOM]
Option A: [DESCRIBE]
Option B: [DESCRIBE]
Constraints: [TEAM SIZE, DEADLINE, SCALE, EXISTING STACK]

Steelman each option in one paragraph. Then compare only on criteria that actually differ: complexity now vs later, failure modes, migration cost if we chose wrong, and time to ship. Give a decision with a confidence level, the strongest argument against your own pick, and the early signal that would tell me I chose wrong.

Edit this text like a ruthless magazine editor. Goals, in order: cut length 30% without losing meaning, kill hedging ("quite", "very", "I think", "in order to"), convert passive voice to active, and break any sentence over 25 words.

Show me: (1) the edited version, (2) a short list of my worst habits with one example each, so I stop repeating them.

Keep my voice and any technical terms — make it tighter, not different.

[PASTE TEXT]

Create a blog post outline for: "[WORKING TITLE]"
Target reader: [WHO THEY ARE, WHAT THEY ALREADY KNOW]

First, state in one line what someone typing this into Google is actually trying to do — then build the outline to satisfy that in the first third of the post.

Outline format: H2/H3 structure with one line per section on what it must cover, where my unique angle goes ([MY EXPERIENCE / DATA / OPINION]), and which section targets the featured snippet (write the exact 40-60 word answer for it). Flag any section that exists on every competing post — I'll either beat it or cut it.

Learn my writing voice from these samples, then use it.

Samples of my writing:
[PASTE 2-3 SAMPLES, 100+ WORDS EACH]

First: describe my voice in 5 specific traits (sentence length, formality, humor, how I open and close, words I overuse) — so I can correct you if you misread me.

Then write: [WHAT TO WRITE, e.g. "a 200-word announcement that we're sunsetting the free plan"]

Do not smooth out my quirks. If my samples are blunt, be blunt.

Write 10 headlines for: [WHAT THE PIECE IS, e.g. "a case study on cutting AWS costs 60%"].
Audience: [WHO] · Where it appears: [BLOG / NEWSLETTER / LINKEDIN / YOUTUBE]

Mix these types, labeled: 2 curiosity-gap, 2 specific-number, 2 how-to, 2 contrarian, 2 direct-benefit. For each, one clause on why it might win.

Then pick your top 2 for THIS audience and platform, and say what you'd A/B test between them. No clickbait the piece can't cash.

Write 5 opening paragraphs for this piece, each using a different hook:

1. A specific scene or moment
2. A surprising number or fact
3. The reader's problem, stated better than they'd state it themselves
4. A strong claim someone will disagree with
5. A short story with the outcome withheld

The piece: [TOPIC AND MAIN POINT]
Reader: [WHO]

Each hook: 2-4 sentences, must flow naturally into the piece. No "In today's world" or "Have you ever" openings. Mark which hook you'd choose and why.

Explain [TECHNICAL CONCEPT] to [AUDIENCE, e.g. "a smart product manager with no engineering background"].

Rules: one core analogy from everyday life, carried consistently through the whole explanation — don't switch analogies mid-way. Maximum 300 words. Define any term you can't avoid.

End with "where the analogy breaks": one sentence on what the simplification hides, so I'm not accidentally lying to them.

No bullet lists — write flowing prose I could say out loud.

Summarize this document for [WHO WILL READ IT, e.g. "a CFO deciding budget"].

Format:
- Bottom line: one sentence — the single thing they must know.
- Three key points, each: the point in bold, then 1-2 sentences of the strongest supporting evidence (quote numbers exactly).
- Decision needed / action requested, if any, with the deadline.
- What I cut: one line listing important-but-secondary topics, so they can ask.

Under 200 words total. Don't soften bad news — executives are paid to hear it.

[PASTE DOCUMENT]

Turn this transcript into a readable article.

Rules: keep the speaker's actual phrases where they're vivid — quote them. Cut filler, false starts, and repetition. Reorganize by idea, not by chronology, with descriptive H2s. Anything ambiguous, mark [CHECK: ...] rather than guessing.

Target length: [WORDS]. Tone: like a good editor cleaned it up, not like AI rewrote it.

Add: a 2-sentence intro saying who's speaking and why it matters, plus one pull-quote suggestion.

Transcript:
[PASTE TRANSCRIPT]

Write a customer case study from these facts. Don't invent numbers, quotes, or details — anything missing, mark [NEED: ...].

Facts:
- Customer: [NAME, INDUSTRY, SIZE]
- Problem: [WHAT WAS BROKEN AND WHAT IT COST THEM]
- Solution: [WHAT THEY DID WITH US]
- Results: [METRICS, TIMEFRAME]
- Quote material: [ANY REAL QUOTES OR CALL NOTES]

Structure: headline with the strongest number, a 100-word "at a glance" box, then Challenge → Solution → Results, 400-600 words. Write for a skeptical buyer in the same industry: specifics over adjectives, no "delighted to partner with".

Draft my newsletter issue from these raw notes and links.

My newsletter: [NAME, TOPIC, TONE, TYPICAL LENGTH]
Audience: [WHO]
Raw material:
[PASTE LINKS + ROUGH NOTES]

For each item: a punchy section header, 2-4 sentences of MY take (built from my notes — don't pad with generic commentary), and why the reader should care. Order items by strength, lead with the best.

Write a subject line (under 45 characters) and preview text that doesn't repeat the subject. Where my notes have no opinion, mark [ADD TAKE] instead of faking one.

Structure a [MINUTES]-minute talk: "[TALK TITLE]"
Audience: [WHO, EXPERTISE LEVEL]
The one thing they should remember: [YOUR TAKEAWAY]

Build: a cold open (first 60 seconds, word-for-word), then sections with minute marks, each tagged [story], [data], [demo], or [concept] — never two [concept] blocks back-to-back. Include one deliberate laugh-line spot and one "write this down" moment.

End with the closing line, word-for-word. Flag where I'm most likely to run over and what to cut live if I do.

Critique this draft. Do not rewrite it — make me fix it.

Grade each 1-10 with one sentence of evidence: Hook (would a stranger read past line 3?), Argument (airtight logic or vibes?), Evidence (claims vs support), Structure (if sections could be reordered without loss, structure is weak), Ending (earned or fizzled?).

Then: the single weakest paragraph, quoted, with WHY it fails. Three questions a hostile reader would ask that I haven't answered. And one thing that's working that I shouldn't touch.

[PASTE DRAFT]

Write an announcement for: [WHAT'S CHANGING, e.g. "we're raising prices 20% in March"].
Audience: [CUSTOMERS / TEAM / USERS] · Channel: [EMAIL / BLOG / IN-APP]

Structure: what's changing in the first two sentences — no throat-clearing. Why, with the real reason stated plainly. What it means for THEM specifically: dates, actions required, what happens if they do nothing. Where to ask questions.

If the news is bad: no spin, no "exciting update" — acknowledge the cost to them in one honest sentence. Under [WORD COUNT] words. Include the subject line.

Build a content brief for the keyword: "[KEYWORD]"

Include:
1. Search intent (informational / commercial / transactional) and the searcher's actual situation in one sentence.
2. Recommended format (guide / listicle / comparison / tool page) and a word count based on what fully answers the query — not an arbitrary "2,000 words".
3. H2/H3 outline with what each section must answer.
4. 5-10 related keywords and entities to work in naturally, with placement suggestions.
5. Title tag (under 60 chars) and meta description (under 155 chars), keyword near the front.
6. What would make this piece win: the angle, data, or asset competitors likely lack.

Assume the writer knows the topic but not SEO.

Write landing page copy for: [PRODUCT, ONE SENTENCE]
Customer: [WHO, AND THE MOMENT THEY HIT THIS PAGE — e.g. "clicked an ad right after their deploy broke"]
Proof I actually have: [TESTIMONIALS / NUMBERS / LOGOS / NONE YET]

Sections: hero headline (their problem or outcome, 10 words max, product name optional) + subhead + CTA button text; a problem section that describes their pain better than they would themselves (3 sentences max); how it works in 3 steps; a proof section using ONLY what I listed; an objection block answering the top 3 hesitations; final CTA with urgency that's true.

Write everything in the customer's words, not ours — no "leverage", "seamless", or "empower".

Write title tags and meta descriptions for these pages.

Rules: titles 60 characters max with the primary keyword in the first half, no clickbait a searcher would feel cheated by. Descriptions 155 characters max, keyword once, ending with a reason to click (a benefit or specific detail — never "Learn more"). Each title must be distinct enough that Google won't treat any two as duplicates.

Pages (URL — topic — primary keyword):
[LIST PAGES]

Output a table: URL | Title (char count) | Description (char count). Flag any page where the keyword suggests a different search intent than the topic covers.

Cluster these keywords by search intent — group keywords one page could rank for together, and split keywords that need separate pages even if they look similar.

For each cluster: a name, the primary keyword (best intent-to-volume balance), supporting keywords, the intent type, and the page format that fits (guide / comparison / product / tool).

Also flag: keywords that hide multiple intents in one phrase, and keywords worth ignoring entirely (too broad, wrong audience).

Keywords:
[PASTE KEYWORD LIST, WITH VOLUMES IF YOU HAVE THEM]

Write a 3-email cold outreach sequence.

Me: [WHO I AM, WHAT I'M OFFERING]
Them: [ROLE, COMPANY TYPE, AND THE TRIGGER — why them, why now]
The one thing I want: [SPECIFIC ASK, e.g. "a 15-min call", "a reply describing their current process"]

Email 1: 90 words max, first line personalized from the trigger, one clear ask, no "hope this finds you well". Email 2 (3 days later): a new angle or proof point — not "just bumping this". Email 3 (7 days later): short breakup with an easy out.

Subject lines: 5 words max each. Zero flattery, zero "quick question" — write like a person with something genuinely relevant to say.

Write a launch thread for: [WHAT I'M LAUNCHING]
The story behind it: [WHY I BUILT IT / THE KEY INSIGHT / THE STRUGGLE]
Proof or demo: [SCREENSHOTS, NUMBERS, LINK]

Structure: tweet 1 hooks with the outcome or the tension — never "I'm excited to announce". Tweets 2-5 tell the story, one idea per tweet. Then the reveal with the link, and a final tweet asking for one specific action.

280 characters max each, written like a person: no hashtags, one emoji per tweet maximum. Give me 3 alternative first tweets ranked by scroll-stopping power.

Turn this article into a LinkedIn post — not a summary with a link, a post that delivers the value itself.

Structure: first line is the most surprising or contrarian point (it's all people see before "...more"). Then the core insight in 3-6 short paragraphs, 1-2 sentences each, line break between all. One concrete example or number from the article. A closing line that invites disagreement or experience-sharing — not "Thoughts?".

Then a separate line I can post as the first comment with the article link. Hashtags: 3 max, at the end. No "I'm humbled".

Article:
[PASTE ARTICLE OR KEY POINTS]

Write ad copy for [PRODUCT] targeting [AUDIENCE] on [PLATFORM: Google / Meta / LinkedIn].

First, develop 4 distinct angles: pain-avoidance, aspiration, social proof, and speed/ease. For EACH angle: 2 headlines (respect the platform's character limits) and 1 description, plus which audience temperature it fits (cold / warm / retargeting).

Then rank the 4 angles for MY product with one line of reasoning each.

Rules: specifics beat superlatives ("deploy in 4 minutes" beats "blazing fast"), and no claim I can't back with [PROOF I HAVE].

Analyze positioning for [MY PRODUCT] against these competitors: [LIST COMPETITORS].

What I know about each: [PASTE THEIR HOMEPAGE HEADLINES / PRICING / TARGET CUSTOMER]

Build: a table of who each product is really for and the exact words they use to say it; the dimension where everyone crowds (which I shouldn't fight on); the dimension nobody owns that I could take; and 3 positioning statements for me in the form "For [WHO] who [SITUATION], we're the one that [DIFFERENCE]".

Flag anything you asserted about competitors from memory that I should verify before using.

Generate an FAQ section for this article, optimized for People Also Ask.

Extract 4-6 questions real searchers would type — phrased the way people search, not the way marketers write. Each answer: 40-60 words, self-contained (makes sense without reading the article), with the direct answer in the first sentence.

Then output valid FAQPage JSON-LD covering all the Q&As, matching the visible text exactly.

Article:
[PASTE ARTICLE OR TOPIC + KEY POINTS]

Sharpen my value proposition.

Current one-liner: "[CURRENT DESCRIPTION]"
Who actually buys: [CUSTOMERS] · What they say in their own words: [PASTE REVIEW OR CALL QUOTES IF ANY]
What they compare us to: [COMPETITORS, OR "doing it manually"]

Diagnose first: is my current line about me or about them? Category claim, benefit, or noise?

Then write 5 alternatives: outcome-led, enemy-led (against the old way), specificity-led (a number or time), identity-led (who it's for), and simplicity-led (6 words max). For each: where it works best (homepage / ads / pitch). Pick the winner and say what evidence would prove it converts.

Plan internal links for my site section.

Pages (URL — topic — target keyword):
[LIST 10-30 PAGES]

For each page: 2-4 links it should send to other listed pages, with exact anchor text — a natural phrase containing the target page's keyword or a close variant. Never "click here", and never the same anchor twice site-wide.

Identify: the pillar page that should receive the most links, orphan risks (pages nothing links to), and 2 missing pages that would complete the topic cluster.

Output a table: From → To → Anchor text.

Package this YouTube video for search and click-through.

Video content: [WHAT HAPPENS IN THE VIDEO, KEY MOMENTS, WHO IT'S FOR]
Target query: [WHAT SOMEONE SEARCHES TO FIND THIS]

Give me: 5 titles, 60 characters max (mix: outcome, curiosity, number, mistake-warning, direct how-to), ranked with the constraint that the video must deliver what the title promises. A description with the payoff in the first 2 lines (visible before "show more"), timestamps from my key moments, and the target query used naturally twice. 10-15 tags ordered specific to broad. And a pinned comment that drives one action: [SUBSCRIBE / LINK / QUESTION].

commercial product photography of [PRODUCT, e.g. "matte black wireless earbuds in an open charging case"], on a [SURFACE: polished concrete / white marble / walnut wood], [BACKGROUND: seamless studio grey / soft gradient], dramatic side lighting with soft shadows, subtle reflection, ultra sharp focus on product, shallow depth of field, shot on Phase One, 120mm macro, professional color grading --ar 4:5 --style raw --v 6.1

cinematic portrait of [SUBJECT, e.g. "a middle-aged fisherman with weathered skin"], [SETTING: on a fog-covered dock at dawn], anamorphic lens, 35mm film still, shallow depth of field, teal and amber color grade, volumetric light, detailed skin texture, quiet expression, off-center composition with negative space --ar 21:9 --style raw --v 6.1

isometric 3D icon of [OBJECT, e.g. "a mail envelope"], soft clay render style, smooth rounded edges, pastel [COLOR] palette, single centered object on a plain [BACKGROUND COLOR] background, soft studio lighting, subtle ambient occlusion, consistent 45-degree angle, no text --ar 1:1 --v 6.1

flat vector illustration of [SCENE, e.g. "a developer at a desk with two monitors and a coffee cup"], minimal geometric shapes, clean lines, limited palette of [3-4 COLORS, e.g. navy, coral, cream, sage], solid color background, no gradients, no outlines, generous negative space, editorial style like a modern SaaS blog header

Negative prompt: photo, realistic, 3d render, texture, noise, watermark, text

minimalist logo mark for [COMPANY TYPE, e.g. "a developer tools startup"], [CONCEPT: abstract geometric fox / letterform "K" / overlapping circles], flat 2D vector, single color on white background, bold simple shapes readable at 16px, timeless not trendy, no text, no lettering, no gradients --ar 1:1 --style raw --v 6.1 --no photorealistic, 3d, shadow

epic matte painting of [SCENE, e.g. "a lone lighthouse on a basalt cliff, bioluminescent waves below"], [TIME/WEATHER: storm clearing at dusk], atmospheric perspective with three distinct depth layers, painterly brushwork, muted palette with one accent color, classic film concept art style, wide establishing shot --ar 21:9 --v 6.1

abstract 3D render for a tech website hero section, [SHAPES: flowing glass ribbons / floating translucent cubes / soft organic blobs], [BRAND COLORS] color scheme on a dark background, depth of field, studio lighting with soft rim light, large empty area on the [LEFT / RIGHT] side reserved for headline text, premium minimal aesthetic, 8k render quality

die-cut sticker design of [SUBJECT, e.g. "a grumpy cat drinking coffee"], bold clean outline, thick white sticker border, vibrant flat colors with simple cel shading, glossy vinyl look, isolated on plain background, kawaii style but not childish, no text --ar 1:1 --v 6.1

architectural photography of [BUILDING, e.g. "a minimalist concrete house with floor-to-ceiling windows"], [SETTING: built into a pine forest hillside], golden hour, warm interior lights glowing, ultra wide lens held level with no keystoning, photorealistic materials — board-formed concrete, black steel frames, natural stone path — mist between the trees --ar 16:9 --style raw --v 6.1

overhead food photography of [DISH, e.g. "a rustic sourdough pizza with burrata and basil"], on [SURFACE: dark slate / worn wooden table], natural window light from the left, deep shadows, steam rising, scattered [GARNISH / INGREDIENTS] around the plate, linen napkin, editorial cookbook style, shot on medium format, rich color depth --ar 4:5 --style raw --v 6.1

16-bit pixel art sprite of [SUBJECT, e.g. "a potion shop building"], SNES JRPG style, limited [PALETTE: warm autumn / cool night] color palette, clean readable silhouette, black outline, isolated on a solid background for easy cutout, detailed but not noisy, crisp pixels without anti-aliasing --ar 1:1 --v 6.1

wide editorial illustration for an article about [TOPIC, e.g. "AI code review"], conceptual metaphor: [METAPHOR, e.g. "a magnifying glass revealing gears inside code brackets"], modern flat design with subtle grain texture, [2-3 BRAND COLORS] palette, dark mode friendly, strong focal point center-left, clean margins, no text anywhere in the image

character design sheet of [CHARACTER, e.g. "a young astronaut girl with curly red hair, yellow suit with green accents"], the same character shown in three poses — standing front view, side profile, walking — plus two facial expressions: smiling, surprised. Consistent proportions and outfit in every view, clean [STYLE: Pixar-like 3D / flat 2D animation] style, plain light background, model sheet layout --ar 16:9 --v 6.1

double exposure portrait blending [SUBJECT, e.g. "a woman's profile silhouette"] with [SCENE, e.g. "a misty pine forest and flying birds"], the scene visible inside the silhouette, high contrast white background, delicate line details where the two images merge, muted [COLOR] tones with one accent, fine art print quality, emotional and quiet --ar 4:5 --style raw --v 6.1

Plan an exploratory data analysis for this dataset before I write any code.

Dataset: [WHAT IT IS, ROW COUNT, WHAT ONE ROW REPRESENTS]
Columns: [LIST: name — type — example value]
The question I ultimately care about: [BUSINESS QUESTION]

Give me:
1. The 5 checks to run first (nulls, duplicates, ranges, category cardinality, date gaps) with the exact pandas one-liner for each.
2. The 3 distributions or relationships most likely to matter for my question, and the right plot for each.
3. Traps specific to THIS schema — leakage, mixed units, IDs that look numeric.
4. What "this data is unusable" would look like, so I fail fast.

Interpret these results like a skeptical senior analyst, not a cheerleader.

Context: [WHAT WAS MEASURED, OVER WHAT PERIOD, WHY]
Results:
[PASTE NUMBERS / TABLE / OUTPUT]

Tell me: the one-sentence honest takeaway; what the numbers do NOT say (that someone will inevitably claim they say); at least 2 alternative explanations for the pattern (seasonality, selection effects, a changing denominator, regression to the mean); the single follow-up query or cut of the data that would best distinguish between explanations; and your confidence — would you bet on this holding next month?

Write a [DATABASE] query using window functions for: [GOAL, e.g. "each customer's second purchase date and the days between first and second"].

Schema: [TABLES AND RELEVANT COLUMNS]

Requirements: prefer window functions over self-joins. Comment each OVER() clause in plain English — what's the partition, what's the ordering, what's the frame. Handle ties explicitly: state whether you used ROW_NUMBER, RANK, or DENSE_RANK and why it's the right one here. Show expected output for 3 example rows so I can sanity-check the logic before running it on real data.

Write a pandas script to clean this messy data.

The mess: [DESCRIBE, e.g. "dates in 3 formats, currency strings like '$1,204.50', duplicated rows from a bad export, 'N/A' / 'null' / '-' as missing values"]
Columns: [LIST]
Loaded from: [CSV / EXCEL / JSON]

Rules: never mutate the raw dataframe — work on a copy. Print what each step changed (rows dropped, values coerced) with counts. Coerce, don't delete: bad values become NaN with a _raw backup column. End with an assertions block that fails loudly if cleaning missed something — dtypes, null percentage, duplicate count. Comment WHY per step, not what.

Help me pick the right statistical test.

What I measured: [METRIC, e.g. "conversion rate", "time on task in seconds"]
Groups: [HOW MANY, INDEPENDENT OR PAIRED, SAMPLE SIZES]
Question: [e.g. "is variant B better than A?"]
Data shape: [ROUGHLY NORMAL? SKEWED? COUNTS? PROPORTIONS?]

Walk through: the test that fits and why; its assumptions and which ONE is most likely violated in my case, with a quick check for it; the non-parametric fallback; the exact Python call (scipy or statsmodels); and how to report the result in one sentence that includes the effect size — not just the p-value.

Define KPIs for: [TEAM / PRODUCT AREA, e.g. "our onboarding flow"]
The business goal they serve: [GOAL]

For each of 3-5 KPIs: the exact definition (numerator, denominator, time window, who's excluded); why this and not its vanity cousin (activation rate, not signups); how it gets gamed and the guardrail metric that catches the gaming; target-setting logic (baseline plus a defensible delta, not a round number); and the data needed at query level.

Then: the ONE metric if we could only track one, and what choosing it deliberately sacrifices.

Review my A/B test results and stop me from shipping a false winner.

Setup: [WHAT CHANGED, THE HYPOTHESIS, HOW USERS WERE SPLIT]
Duration: [DAYS] · Sample: [N PER VARIANT]
Results: [METRIC: CONTROL X% vs VARIANT Y%, PLUS ANY SECONDARY METRICS]

Check in order: was the sample size decided before the test, or am I peeking? Did it run at least 1-2 full business cycles? Significance AND effect size with a confidence interval. Secondary metrics that moved the wrong way. Novelty effect risk. Segments where the effect might reverse.

Verdict: ship / keep running N more days / rerun with a fix — plus the single biggest threat to validity.

Write a formula for [EXCEL / GOOGLE SHEETS].

My data: [DESCRIBE COLUMNS AND RANGES, e.g. "A: dates, B: rep names, C: deal amounts, one row per deal"]
What I want: [PLAIN ENGLISH, e.g. "sum of deals per rep for the current month only, ignoring rows where the amount is blank"]

Give me: the formula; a plain-English read-through of each function from the inside out; a simpler alternative if one exists (pivot table? SUMIFS instead of an array formula?); and what breaks it — sorted data, inserted columns, more than 10k rows — with the more robust version if I need it.

Turn this analysis into a 5-slide data story for [AUDIENCE, e.g. "the exec team deciding next quarter's budget"].

My findings:
[PASTE KEY NUMBERS AND WHAT YOU FOUND]

Slide by slide: (1) the takeaway as a full-sentence headline — not "Q3 Results"; (2) the one chart that proves it — say exactly what to plot, the axes, and what to annotate; (3) why it's happening; (4) what we should do — options plus your recommendation; (5) risks and what we'd watch.

Every slide: headline sentence plus supporting content. Kill any number that doesn't change the decision.

[METRIC] moved [X%] [UP / DOWN] on [DATE OR PERIOD] and I need the cause.

Context: [PRODUCT, THE METRIC'S NORMAL RANGE, ANYTHING SHIPPED RECENTLY]

Give me an ordered investigation checklist: instrumentation first (did tracking change or break — and how to verify), then denominator vs numerator (which side actually moved), then segmentation cuts in order of likely payoff (platform, geo, traffic source, new vs returning), then external causes (seasonality, holidays, a competitor, press).

For each step: the specific query or cut to run, and what result would confirm or kill that hypothesis. End with the 3 most likely causes for MY specifics, ranked.

Extract structured data from the text below.

Fields I need: [LIST FIELDS + TYPES, e.g. "company (string), amount (number, USD), date (ISO 8601), sentiment (positive / neutral / negative)"]

Rules: output a JSON array, one object per record. Missing field = null, never a guess. Add a "confidence" field (high / medium / low) per record, and an "evidence" field quoting the source phrase for the trickiest field. Normalize dates and numbers strictly. If a record is ambiguous, extract it with confidence "low" rather than skipping it.

After the JSON, list any systematic problems in the source I should fix upstream.

Text:
[PASTE MESSY TEXT / EMAILS / NOTES]

Analyze this survey data properly.

Survey: [TOPIC, NUMBER OF RESPONSES, HOW RESPONDENTS WERE RECRUITED]
Questions: [LIST QUESTIONS + TYPES: scale / multiple choice / free text]

Plan: response bias check first — who answered vs who didn't, and how to estimate the skew. For scale questions, distributions, not just averages (a 5.5 mean can be all 3s, or half 1s and half 10s). The crosstabs worth running given my topic. For free text: a coding scheme with 5-8 categories and 2 example verbatims each. The 3 findings-shaped sentences my report should be able to complete.

Then warn me: which conclusions can my sample NOT support?

Run my weekly review. Ask me these one at a time and wait for each answer:

1. What actually got done this week? (I'll list — then you tell me what pattern you see.)
2. What did I avoid, and what was I avoiding about it?
3. What took 3x longer than it should have — and was it the task or me?
4. What's the ONE thing next week that makes everything else easier?
5. What am I saying yes to that I should quit?

After my answers: summarize the week in 3 sentences, name one habit to change with a specific implementation ("when X happens, do Y"), and set my top 3 for next week with the first physical action for each.

Process these meeting notes into something useful.

Extract into sections:
1. DECISIONS made — exact wording, who has final say, what alternatives were rejected.
2. ACTIONS: task — owner — deadline. Anything without an owner or a date goes into "UNOWNED — needs assignment" (those are the ones that die).
3. OPEN QUESTIONS raised but not answered, and who was supposed to follow up.
4. PARKING LOT: things mentioned that deserve their own meeting.

Then draft the 5-line follow-up message to attendees. Flag anything in my notes that sounds like a decision but is actually still vague.

Notes:
[PASTE RAW NOTES]

Prioritize this task list. Push back on my instincts.

My tasks:
[PASTE LIST, WITH DEADLINES AND CONTEXT WHERE KNOWN]
My actual goal this [WEEK / MONTH]: [GOAL]

Sort into: DO FIRST (moves the goal directly), SCHEDULE (matters, not now — assign each a day), DELEGATE OR AUTOMATE (say to whom or how), and DELETE (be aggressive — I'll defend the ones that hurt). For each DELETE, tell me the real cost of keeping it.

Then flag: which task am I probably doing because it feels productive but isn't? And which scary task am I disguising as "waiting on something"?

Help me write a message I've been putting off.

Situation: [WHAT HAPPENED / WHAT I NEED TO SAY, e.g. "declining a project from an important client", "telling my manager the deadline will slip"]
Relationship: [WHO THEY ARE TO ME, THE POWER DYNAMIC]
What I want to protect: [THE RELATIONSHIP / MY BOUNDARY / THE TIMELINE]

Write it: the point in the first 2 sentences, no cushioning paragraph before the news. One honest reason, not three weak excuses. What I CAN offer, concretely. One "sorry" maximum, and only if warranted. Under 120 words.

Then give me a version 20% warmer and a version 20% firmer, so I can pick the register.

Time-block tomorrow from my task list and constraints.

Must-do tasks: [LIST WITH ROUGH TIME ESTIMATES]
Fixed commitments: [MEETINGS WITH TIMES]
My energy pattern: [e.g. "sharp 8-11am, dead after lunch, second wind around 4pm"]
Work hours: [START-END]

Rules: deep work goes in my peak hours — meetings and email do NOT get my best brain. Multiply my estimates by 1.5 (I'm optimistic). Maximum 90-minute focus blocks with 10-minute breaks. One 30-minute buffer block for the day's inevitable surprise. Batch shallow tasks into one block.

Output a simple schedule table, then tell me what didn't fit and should move to another day rather than get squeezed in.

Help me decide: [DECISION, e.g. "take the job offer at X vs stay where I am"]

My options: [LIST]
What matters to me: [LIST CRITERIA IN ROUGH ORDER]

Process: propose weights for my criteria (100 points split across them) based on my ordering — I'll correct them. Score each option per criterion with a one-line justification. Compute totals — BUT then ask the real question: "The math says X. Notice your reaction — relieved or disappointed?" That reaction is data.

Also run: the regret test (which choice hurts more to look back on in 5 years) and the cheap experiment that could reduce uncertainty before I commit.

Turn my brain dump into an actual plan.

Everything in my head about this project:
[PASTE UNSTRUCTURED THOUGHTS — DON'T CLEAN THEM UP]

Organize into: the actual goal in one sentence (infer it, then let me correct it); what's IN scope vs OUT (be strict — I will scope-creep); the work broken into 3-7 chunks, each with a "done means..." definition; dependencies (what blocks what); the first task small enough to do in 30 minutes today; and the questions I haven't answered that will bite me later, ranked by how much they'd change the plan.

Design an email triage system for my situation.

My email reality: [VOLUME PER DAY, TYPES: e.g. "client requests, internal CCs, newsletters, support escalations"]
My tools: [GMAIL / OUTLOOK, PLUS ANYTHING ELSE]
What keeps going wrong: [e.g. "urgent things get buried, I re-read the same mail 5 times"]

Give me: 4-6 filter/label rules with exact setup steps for my client; a touch-it-once decision tree (reply now if under 2 minutes / schedule / delegate / archive) written as a simple text flowchart; canned response templates for my 3 most repeated reply types: [DESCRIBE THEM]; and a checking schedule that fits my real response-time obligations — ask me what those are first.

Turn my loose description into an SOP someone else can follow without asking me anything.

The process as I'd explain it over coffee:
[DESCRIBE HOW YOU DO IT, INCLUDING THE "OH AND ALSO" PARTS]

Write: purpose (when to use this SOP — and when NOT to); prerequisites (access, tools, files); numbered steps, one action per step, with a "how do I know it worked" check after any step that can fail silently; the judgment calls — wherever the process needs a decision, give the rule of thumb I'd use; and a failure section: the 3 most likely ways it goes wrong and what to do.

Flag every place my description was vague with [ASK: ...] so I fill the gaps before publishing.

Write a delegation brief for handing off: [TASK / PROJECT]
To: [WHO — AND THEIR EXPERIENCE LEVEL WITH THIS KIND OF WORK]

Structure: the outcome, not the process — what done looks like, measurably. Context they need: why this matters and who cares about it. Boundaries: what they can decide alone vs what needs a check-in first — be explicit, this is where delegation fails. Resources and access they'll need on day one. Check-in structure: when and in what format — not "keep me posted". And the failure I'm most worried about, stated openly so they can watch for it too.

Tone: trusting, not hovering.

Prep me for a conversation with [WHO: my manager / a struggling report / a difficult peer].

What I want from it: [OUTCOME]
The history: [RELEVANT CONTEXT, LAST CONVERSATION, TENSIONS]
What I'm afraid happens: [THE SCENARIO YOU'RE DREADING]

Build: my opening line — sets the frame in one sentence. My 3 points, each with the evidence or example ready. The 3 hardest things they might say, with a non-defensive response to each. The question I should ask them that I probably haven't thought of. And my walk-away line: the minimum acceptable outcome, so I don't concede past it in the room.

Draft my [QUARTER] goals and stress-test them.

My role: [ROLE] · Team/company priorities: [WHAT THE ORG NEEDS]
What I think my goals should be: [ROUGH LIST]
Last quarter's goals and what actually happened: [BE HONEST]

For each goal: rewrite it as outcome + number + date; the leading indicator I'd see by week 4 if it's on track; the named risk that killed a similar goal before (check my last quarter); and its minimum viable version if the quarter goes sideways.

Then audit me: which goal exists to look good rather than to matter? And what am I leaving off this list because it's hard to measure — should it be goal #1?

Write a production system prompt for an AI assistant.

The assistant: [WHAT IT DOES, e.g. "answers billing questions for our SaaS"]
Users: [WHO TALKS TO IT] · Tone: [VOICE]
It must NEVER: [HARD LIMITS, e.g. "promise refunds, discuss competitors, guess at account data"]
It has access to: [TOOLS / DATA]

Structure the prompt as: role and goal (2 sentences); capabilities and tools with WHEN to use each; behavioral rules as numbered directives (positive framing — "do X" beats "don't Y" where possible); the escalation rule — exactly when to hand off to a human and what to say; output format constraints; and 2 few-shot examples covering one normal case and one edge case where it must refuse.

Then list 5 user messages that would stress-test this prompt.

Decompose this goal into steps an AI agent can execute reliably.

Goal: [WHAT THE AGENT SHOULD ACCOMPLISH, e.g. "research a company and produce a sales brief"]
Tools available: [WEB SEARCH / CODE / FILE ACCESS / SPECIFIC APIS]

For each step: input → action → output, with a machine-checkable success condition (not "research done" — "at least 3 sources found, each with a URL"). Mark which steps can run in parallel. For each step, where the agent is most likely to go off the rails and the guardrail instruction for it. What state must pass between steps — be explicit, implicit state is where agent chains break. And the final validation step before output reaches a human.

Design JSON function/tool definitions for my AI agent.

The agent needs to: [CAPABILITIES, e.g. "search our product catalog, check order status, create support tickets"]
Backend reality: [THE ACTUAL APIS / DATABASES BEHIND THESE]

For each tool: a verb_noun name; a description written FOR THE MODEL — when to use it, when NOT to use it, and what it returns (this is the highest-leverage text, spend your words here); parameters with types, enums wherever values are a closed set, and descriptions that include format examples; required vs optional applied strictly.

Then run the overlap check: any two tools the model could confuse, and the description edit that disambiguates them.

Review my AI feature for prompt-injection and misuse risks. I'm building the defense, so think like the attacker first.

The feature: [WHAT IT DOES]
Untrusted input it touches: [USER MESSAGES / UPLOADED DOCS / SCRAPED PAGES / EMAIL CONTENT]
What the model can do: [TOOLS, DATA ACCESS, ACTIONS]

Map: every place untrusted text enters the context; what an instruction embedded in that text could make the model do, ranked by blast radius (data exfiltration, then wrong actions, then bad output); which mitigations fit my case — privilege separation, input demarcation, output validation, human confirmation on consequential actions, tool allow-listing; and the 5 test inputs I should add to CI to catch regressions.

Design an automation for this workflow before I build it in [ZAPIER / MAKE / N8N].

The manual process today: [DESCRIBE STEP BY STEP, INCLUDING THE ANNOYING PARTS]
Apps involved: [LIST]
Volume: [HOW OFTEN IT RUNS]

Give me: the trigger choice, and why polling vs instant matters here; each step with the exact app + action; where data needs transforming between steps (formatter or code step, with the logic); error handling — what happens when a step fails at 2am (retry? alert? dead-letter?); the edge cases my description ignores (duplicates, empty fields, deleted records); and a monthly task-count estimate so I know the plan cost before building.

Define a customer support bot for [PRODUCT / COMPANY].

Our support reality — top 5 question types: [LIST]. Brand tone: [DESCRIBE]. What support can't do without a human: [REFUNDS OVER $X / ACCOUNT DELETION / ETC.]

Write: the persona (voice traits plus 2 example replies — one easy customer, one frustrated one); the scope contract — which question types it answers fully, answers partially with a caveat, or hands off immediately; a handoff script that doesn't feel like a brush-off; rules for uncertainty — when the docs don't cover it, say so and offer a human, NEVER improvise policy; and the metrics that would show it's actually helping rather than just deflecting.

Build an eval plan for my LLM feature.

The feature: [WHAT IT DOES, INPUT → OUTPUT]
What "good" means: [YOUR QUALITY BAR]
Cost of a wrong output: [WHAT HAPPENS]

Create: 15-20 test cases as a table — input, expected behavior, and category: happy path / edge / adversarial / out-of-scope (where the model should refuse or defer). For subjective quality, a 1-5 rubric with concrete anchors at 1, 3, and 5 that an LLM judge could apply consistently. The 3 regression cases to run on EVERY prompt change. And a realistic pass threshold per category — 100% on refusals, maybe 85% on style.

Design the retrieval setup for my RAG system.

Documents: [TYPE, e.g. "300 support articles, ~800 words each, with headers" / "legal contracts, 40 pages each"]
Queries look like: [3 REAL EXAMPLE QUERIES]
The failure I care about most: [CONFIDENT WRONG ANSWER / MISSING INFO THAT EXISTS / SLOW]

Recommend with reasoning: chunk size and overlap FOR MY DOC TYPE (structure-aware vs fixed-size, and why); the metadata to attach per chunk and which query filters it enables; embedding model tradeoffs at my scale; whether I need hybrid search (BM25 + vector) — test my example queries against this mentally; whether re-ranking is worth it for my failure mode; and the 10-question retrieval eval to run before touching generation quality.

Add a self-verification loop to my agent's workflow.

The agent's task: [WHAT IT PRODUCES, e.g. "writes SQL from natural language and returns results"]
Current failure mode: [HOW IT'S WRONG TODAY, e.g. "confident queries against the wrong table"]

Design: the check step after each draft — a SEPARATE prompt that critiques against a checklist (write the 4-6 checklist items for my task); the machine-verifiable checks that don't need an LLM at all (does the SQL parse? do the referenced tables exist? is the row count sane?) — always prefer these; the revision loop: max attempts, what context the reviser gets, and the give-up behavior (return best attempt plus caveats — never silently return a failed check); and one log line per iteration so I can see WHERE it self-corrects most. That log is my prompt-improvement backlog.

Find the automation opportunities in my week, then spec the top one.

My role: [JOB]
Recurring tasks: [LIST EVERYTHING ROUGHLY WEEKLY, WITH MINUTES EACH]
My tools: [GOOGLE WORKSPACE / SLACK / CRM / SCRIPTS / AI ASSISTANTS]

Step 1: score each task on frequency × minutes × how rule-based it is (1-5). Show the table — high scores are automation candidates, low rule-based ones stay human.
Step 2: spec the #1 candidate: trigger (schedule or event), steps, which parts need AI vs plain rules, where a human stays in the loop, and how I'd notice if it silently broke.
Step 3: an honest build-vs-skip call — some 10-minute tasks aren't worth 5 hours of setup.

Write instructions for an AI that drafts email replies for me to review before sending.

My inbox: [ROLE, TYPES OF EMAIL YOU GET]
My voice: [PASTE 2 SENT EMAILS AS SAMPLES]
Rules of my world: [e.g. "never commit to deadlines without checking the team", "clients get a warmer tone than vendors"]

The instructions must cover: triage first — which emails get a draft vs get flagged for me only (anything emotional, legal, or from [VIP LIST] = no auto-draft); voice rules extracted from my samples, specific ones — greeting style, sign-off, sentence length; the commitments firewall — things a draft may never do: promise, apologize on my behalf, or accept meetings without [CALENDAR CHECK]; and the draft format: the reply plus a one-line note on anything it wasn't sure about.

You are a data extraction engine. Extract from the input below into EXACTLY this JSON schema — no extra fields, no commentary outside the JSON.

Schema:
{
  "[FIELD]": "[TYPE + FORMAT, e.g. string / ISO 8601 date / one of: a|b|c]"
}

Rules: missing or unstated = null, never inferred. Dates normalized to ISO 8601. Numbers as numbers, not strings. If the input contains multiple records, return a JSON array. If it contains ZERO valid records, return [] — not an explanation.

Validate before answering: does your output parse? Does every field match its declared type?

Input:
[PASTE TEXT]

Help me connect my AI assistant to my actual tools.

What I want it to reach: [SYSTEMS, e.g. "our Postgres DB, GitHub, Slack, the internal wiki"]
Assistant/platform: [CLAUDE / CHATGPT / CURSOR / CUSTOM]
Sensitivity: [WHAT DATA MUST NEVER LEAVE / WHO CAN USE THIS]

For each system: whether an existing connector or MCP server likely covers it vs needs custom work; the minimal permission scope to grant — read-only first, write access is a later decision; the risky operations to gate behind a confirmation; and the setup order — start with the one that saves the most time at the least risk.

End with a 30-minute pilot plan: one system, one real task, and what success looks like.

I'm going to explain [TOPIC] to you as if you're a curious 12-year-old. Your job:

1. Listen to my explanation, then point at every spot where I used a term I didn't explain, skipped a step, or where my logic wouldn't convince a smart kid.
2. Ask me the ONE question that best exposes the gap in my understanding.
3. After I patch my explanation, grade it: what I clearly understand vs what I'm reciting without understanding.

Repeat until my explanation holds. Do NOT explain the topic to me — that defeats the point. Make ME do the work.

My explanation (from memory, no looking it up):
[WRITE YOUR EXPLANATION]

Be my Socratic study partner for [TOPIC]. Never lecture. Rules:

- Ask me one question at a time, starting from what I claim to know.
- When I answer correctly, go one level deeper or add a complicating case.
- When I'm wrong, don't correct me — ask the question that makes the contradiction obvious.
- When I say "I don't know", give the smallest possible hint, not the answer.
- Every 5 questions, summarize: solid ground vs shaky ground, as two lists.

My current level: [BEGINNER / TOOK A COURSE / WORK WITH IT DAILY]

Start by probing whether my foundation is real.

Turn my notes into spaced-repetition flashcards (Anki-style).

Rules for good cards: atomic — one fact per card, never whole lists to memorize. The front is a QUESTION that forces recall ("What does the CAP theorem trade off during a partition?"), never a bare topic ("CAP theorem"). Include ~20% reversed cards (definition → term). For concepts, add an application card: "You see [SYMPTOM] — which principle applies?". Skip anything I'd never need from memory (look-up-able details).

Format: Q: / A: pairs, grouped by subtopic. Flag notes too vague to make a card from — those are the gaps in my notes.

Notes:
[PASTE NOTES]

Build me a 30-day plan to learn [SKILL] at [MINUTES PER DAY].

My starting point: [WHAT I ALREADY KNOW]
Goal: by day 30 I can [SPECIFIC CAPABILITY, e.g. "build and deploy a small API"]. If my goal is vague, sharpen it before planning.

Structure: 4 weekly themes, each ending in a small BUILD/DO milestone — knowledge without output doesn't stick. Daily entries: topic + the specific exercise (not "study X" — "implement X from scratch without looking"). The 80/20 cut: what beginners waste time on that I should skip. One "desert day" per week: no new material, only revisiting what didn't stick. And the day-30 test I must pass to prove the goal.

Summarize and critique this paper like a peer reviewer who wants it to be true but won't let that slide.

Summary layer: the claim in one sentence; the method in three; the headline result with effect size, not just significance.

Critique layer: sample and selection — who or what was studied, and who's missing; the leap from evidence to claim — where's the gap; confounds the authors dismissed too quickly; would this replicate — what detail makes you doubt it.

Practical layer: if I can take only ONE thing from this paper into practice, what is it — and what caveat is attached?

Paper (or abstract + key sections):
[PASTE]

Compare [CONCEPT A] vs [CONCEPT B] for someone who keeps mixing them up.

Start with the confusion: why do people conflate them — what's the surface similarity? Then the ONE-sentence distinction that separates them forever. Then a comparison table covering only the dimensions where they actually differ — skip the ones where they're the same, that's noise.

Then 3 scenarios: one clearly A, one clearly B, one genuinely borderline — walk the reasoning on the borderline one.

End with a memory hook: one vivid line that makes the distinction stick.

Explain [CONCEPT] four times, each level building on the last:

Level 1 — to a 10-year-old: one analogy, 3 sentences.
Level 2 — to a college freshman: the mechanism, with correct vocabulary introduced and defined, one paragraph.
Level 3 — to a practitioner in an adjacent field: the real model, the math or method if there is one, and what the Level 1 analogy got wrong.
Level 4 — to a skeptical expert: current debates, limitations, what the textbook version oversimplifies, open questions.

My actual question about it: "[YOUR QUESTION]" — tell me at which level it gets properly answered, and answer it there.

Be my [LANGUAGE] conversation partner. My level: [A2 / B1 / B2 / DESCRIBE].

Rules: converse about [TOPIC I ACTUALLY CARE ABOUT]; speak [LANGUAGE] at my level plus 10% difficulty. When I make an error: respond to my MEANING first, then one correction line — what I said → the fix → why, in one clause. Don't lecture; we're talking.

Every 10 exchanges: list my 3 recurring errors and drill me with 2 quick exercises on the worst one. If I switch to English because I'm stuck, give me the phrase I needed and have me retry the sentence.

Start the conversation now with a question about [TOPIC].

I'm reading [BOOK by AUTHOR]. Instead of a summary, extract its operating system:

1. The 3-5 mental models or core moves the author actually uses — named plainly, not chapter titles.
2. For each: the claim → the best evidence the book offers → the strongest counter-argument NOT in the book.
3. Decision rules I could apply this week: "when [SITUATION], the book says do [MOVE]" — concrete, not inspirational.
4. What the book overextends — every book overextends its one idea somewhere. Where does this one?
5. The 20% of chapters carrying 80% of the value, so I read those closely and skim the rest.

Scaffold a literature review on: [RESEARCH QUESTION]

Build: the 3-5 schools of thought on this question and what each would claim — name representative authors or papers where you're confident, and MARK anything uncertain as [verify]; I will check every citation. The timeline of how the debate evolved and what shifted it. The methodological divide: who measures what, and why they disagree partly because of it. The gap map: what's under-studied that my question could occupy. And a search strategy: terms, key venues or journals, and the 2-3 seed papers whose citation trails I should walk.

Prep me for a [ROLE] interview at [COMPANY TYPE / NAME].

My background: [2-3 LINES]
The role wants: [PASTE KEY REQUIREMENTS FROM THE JOB POST]

Run it as drills, one at a time: ask a likely question, wait for my real answer, then grade it — structure (did I answer THE question?), specificity (a story or number, or just vibes?), length (where I rambled) — and show the upgraded version of MY answer, keeping my facts.

Mix: 3 behavioral questions built from the requirements, 2 technical/craft, 1 "why us", 1 curveball. At the end: my 2 weakest patterns, plus the 3 questions I should ask THEM that signal seniority.

Steelman both sides of: [DEBATE / QUESTION, e.g. "should startups hire generalists or specialists early?"]

Rules: argue each side as its smartest advocate would — the strongest evidence and best real-world examples for each, not the average ones. No strawmen: each argument must be one its actual proponents would endorse. Identify the crux: the underlying disagreement (values? predictions? definitions?) that explains why smart people land differently. State what evidence would change each side's mind.

Only THEN give your read: which side is stronger under which conditions — not a mushy "both have merit".

Quiz me on [TOPIC] with adaptive difficulty.

Rules: start at medium. Each right answer raises difficulty; each miss drops it one level AND revisits that concept from a different angle 2-3 questions later — don't announce when, catch me. Mix formats: recall, application ("what happens if..."), spot-the-error, and "explain why the wrong answer is tempting". Never the same format twice in a row.

After each answer: verdict, ONE sentence of why, and the misconception behind my error if I made one. Every 8 questions: score, level reached, and my weakest subtopic with what to review.

Go — first question.