aaron

Quick hook: Use AI to turn messy user quotes into 1–2 high-impact product hypotheses you can test in 2–3 weeks.

The problem: Qualitative research is rich but noisy. Teams sit on insights because they can’t convert themes into measurable product decisions.

Why this matters: Teams that convert qualitative themes into clear hypotheses run faster, reduce development waste, and improve conversion or retention with confidence.

Do / Don’t checklist

• Do: Put one quote per row, include source ID, and anonymize.
• Do: Require an evidence count (how many quotes support a theme) before prioritising.
• Do: Attach one primary metric and a success threshold to each hypothesis.
• Don’t: Ship features based on a single anecdote.
• Don’t: Ask leading AI prompts that bias themes.

What you’ll need

• Raw user quotes (interviews, tickets, survey open-ends).
• Spreadsheet with one quote per row + source ID.
• An AI tool you can paste text into (chat or API).
• A shared doc to capture themes, hypotheses, metrics and experiment designs.

Step-by-step (what to do, how to do it, what to expect)

1. Consolidate: Copy all quotes into a sheet. Remove duplicates, anonymize, trim to 1–2 sentences.
2. Extract themes: Paste 50–200 quotes into the AI and ask for 3–5 themes with supporting quotes and counts.
3. Convert to hypotheses: For each theme use: If we [change], then [measurable outcome] because [user insight]. Attach one primary metric and a threshold.
4. Prioritise: Score each hypothesis on impact, feasibility, confidence (1–3). Pick top 1–2 for fast tests.
5. Design experiment: Define sample size, variant, duration (2 weeks typical), metric, and success threshold. Run A/B or prototype usability test.
6. Act on results: Keep, iterate, or kill. Record learnings back into the sheet.

Metrics to track

• Primary metric per hypothesis (e.g., conversion rate, task completion rate, retention at 7 days).
• Evidence count supporting theme (number and % of quotes).
• Experiment lift % and p-value or confidence interval.

Common mistakes & fixes

• Mistake: Treating AI output as final. Fix: Validate counts in the spreadsheet and run a pilot.
• Mistake: Vague metrics. Fix: Require a single primary metric and a numeric threshold.
• Mistake: Prioritising low-feasibility wins. Fix: Use impact/feasibility/confidence scoring and pick quick wins.

Worked example

• Raw data: 30 checkout comments. Evidence: 12 mention confusion about promo codes (40%).
• Hypothesis: If we add a clearly labelled promo-code field on the cart page, then cart-to-purchase conversion will increase by 5 percentage points in two weeks because users can find and apply discounts without dropping off. Metric: cart-to-purchase conversion. Experiment: A/B test new cart UI vs current for 14 days with minimum n=1,000 carts.

Copy-paste AI prompt (use as-is)

You are a product researcher. I will give you up to 200 anonymized user quotes. Do the following: 1) Identify 3–5 concise themes (title + 1-sentence evidence summary + number of supporting quotes). 2) For each theme provide one product hypothesis using: If we [product change], then [measurable outcome] because [user insight]. 3) For each hypothesis suggest one primary metric, a numeric success threshold, and one simple experiment to test it (A/B or usability). 4) Show 2–3 representative quotes per theme. Output as a numbered list.

7-day action plan

1. Day 1–2: Consolidate and anonymize quotes in a spreadsheet.
2. Day 3: Run the AI prompt above and extract themes + counts.
3. Day 4: Convert themes to hypotheses, score, pick 1–2.
4. Day 5–7: Design and launch quick experiments, track primary metric, reconvene with results.

Your move.

Quick win (under 5 minutes): Ask an AI to produce 6 content ideas for one persona + one monthly theme — pick the best 2 and schedule them into your calendar now.

Good call on mapping themes to personas first — that single move aligns effort with measurable outcomes and saves busy teams from chasing noise.

The real problem: teams create content by channel or whim, not by who buys. That scatters results, wastes resources, and gives you weak signals when you review performance.

Why it matters: persona-organized content produces clearer A/B tests, faster learning, and predictable pipeline contributions. You’ll know which message moves leads and which just burns budget.

Lesson from practice: build 1–3 pillar pieces per persona each quarter, then repurpose. The pillars create the measurable lift; the snippets fill channels without re-inventing the wheel.

1. What you’ll need
   • 1–3 clean persona summaries (goals, pain points, channels, sample language).
   • Quarter goals (awareness, leads, MQLs, retention) and 2–3 KPIs.
   • Content inventory and a calendar (spreadsheet is fine).
   • An AI assistant for ideation and rapid drafting.
2. Step-by-step to build the quarter (what to do)
   1. Pick monthly themes tied to quarter goals (3 months = 3 themes).
   2. Assign a primary persona to each theme and choose 1 primary channel.
   3. For each persona+theme, use AI to generate 6–10 ideas across formats; flag 1–3 pillar pieces.
   4. Schedule pillar production first; assign owner, publish date, one KPI, and repurpose plan.
   5. Batch-create pillar content, then ask AI to create social posts, email subject lines, and CTAs from the pillar.
   6. Run biweekly reviews: compare KPI vs. target, iterate prompts, adjust priorities.

What to expect: first pass needs editing. In 8–12 weeks you’ll see consistent signals on 2–3 KPIs and be able to redeploy successful messages quickly.

Metrics to track (per persona & pillar):

• Traffic or impressions
• CTR on owned assets
• Lead volume and conversion rate to MQL
• Engagement rate (comments/shares)
• Repurpose ratio (1 pillar → number of snippets)

Common mistakes & fixes

• Too many messages: limit to 2–3 core messages per persona. Fix: prune down and prioritize by expected impact.
• Poor persona detail: vague personas produce weak copy. Fix: add one real customer quote or support ticket excerpt per persona.
• Over-reliance on AI: AI suggests; humans validate. Fix: always add a customer voice pass before publishing.

1-week action plan

1. Day 1: Finalize persona 1 and quarterly goals (30–60 min).
2. Day 2: Set 3 monthly themes and map persona to themes (30 min).
3. Day 3: Use AI to generate 6–10 ideas per persona+theme; pick pillars (60 min).
4. Day 4: Schedule pillars in calendar, assign owners, define KPIs (45 min).
5. Day 5: Batch brief for pillar 1 and start drafting or ask AI to draft the outline (60–90 min).

AI prompt (copy-paste)

“You are a senior content strategist. Persona: [insert persona summary: role, top 2 goals, top 2 pain points, preferred channel, sample language]. Theme: [insert monthly theme]. Generate 8 content ideas across formats (long-form article, webinar, checklist, 3 social posts, 1 email). For each idea give: format, one-sentence angle, 3 headline options, a primary KPI to track, and estimated effort (low/med/high). Keep tone: practical, confident, plain English.”

Your move.

Good call: the original post nails the capture and AI-cleanup steps — without a clean raster there’s nothing reliable to trace. Here’s a tighter, results-focused playbook to turn that into predictable, printable vectors.

The problem: hand-lettering is organic and messy; automatic tracing creates noise, too many nodes and loss of intended texture.

Why it matters: clean vectors scale and print consistently; sloppy vectors cost time, printing errors and client revisions.

What I’ve learned: aim for repeatable outcomes with three KPIs: scan quality, node count, and finish time. If you hit targets consistently you’ll save hours downstream.

Do / Do not (quick checklist)

• Do: scan flat at 300–600 DPI; use even light; create a pure white background before tracing.
• Do: use AI cleanup to remove paper texture but keep stroke edges; run a manual pass to remove specks.
• Do not: accept auto-trace defaults without checking Threshold, Paths and Noise settings.
• Do not: over-simplify curves until you check the result at 300% zoom and a 24″ print mockup.

Step-by-step (what you’ll need, how to do it, what to expect)

1. Capture — Scan at 300–600 DPI or shoot straight-on with a phone; expect a 3–6 MB file for a single piece at 3000 px width.
2. AI cleanup — Use the prompt below to remove texture and make strokes solid black; expect a clean PNG with transparency.
3. Vectorize — Illustrator: Image Trace Black & White; Threshold 160–200, Paths 60–75, Corners 50–70, Noise 1–4 px; Expand. Inkscape: Trace Bitmap brightness/edge detect, Smoothing 1–2.
4. Refine — Simplify until node count is reasonable, join endpoints, convert strokes to outlines if necessary; expect 5–20 minutes per short piece.
5. Export — Save SVG and PDF for printers; include a 300 DPI PNG proof sized to the largest expected print dimension.

Worked example (Illustrator, target metrics)

1. Open 600 DPI scan (≈4000 px wide).
2. Image Trace: Threshold 180, Paths 70, Corners 60, Noise 2 → Trace → Expand.
3. Simplify until node count <300, remove stray shapes, save PDF and SVG. Total time: 12–18 minutes. File sizes: SVG <2 MB, PDF proof <5 MB.

Metrics to track

• Capture resolution (px width / DPI)
• Trace node count (target <300 for short words)
• Time per piece (target <30 minutes)
• Print proof check at final size (pass/fail)

Common mistakes & fixes

• Too many nodes → use Simplify, then manually fix key anchor points.
• Jagged curves → increase Paths/Corners in trace and reduce Noise, or redraw a short segment with Pen tool.
• Loss of texture you wanted → composite a high-res raster texture layer behind the vector outlines.

Copy-paste AI prompt (use with your assistant or image tool)

“I have a high-resolution photo of hand-drawn lettering. Clean the image: remove background to pure white, increase contrast so strokes are solid black, remove specks and paper texture while preserving stroke edges and any intentional brush tails. Output a 3000–6000 px wide PNG at 300–600 DPI with transparency and a separate flattened PNG on white for tracing.”

One-week action plan

1. Day 1: Scan 5 pieces at 600 DPI; run AI cleanup on each.
2. Day 2–3: Vectorize 2 pieces per day, log node counts and time.
3. Day 4: Review any pieces failing print-proof at scale; fix topology.
4. Day 5–7: Create a mini-style guide (preferred trace settings and final file naming) and batch-export proofs.

Your move.

Short answer: Yes — your plan is solid. Tidy up two small expectations, lock in the audit trail, and you can reliably grade low- to mid-stakes work at scale.

The gap I’d close: your timing estimate is optimistic for the first 2–3 live batches. Expect 10–15 minutes per 20 responses until anchors stabilise, then 5–10 minutes is realistic. Also store the model name and prompt text in PromptVersion so your audit trail is defensible.

Why this matters: instructors need speed, consistency, and a defensible record. Calibrated anchors + TSV output + a PromptVersion stamp give you all three.

Practical, step-by-step setup (what you’ll need and how to do it)

1. What you’ll need: Google Forms + Sheets, an AI chat tool (any that accepts batch text), a Config sheet in Sheets.
2. Build the Form: 8–12 questions, 70–80% MC/checkbox. Limit open items to 1–2. Enable quiz mode.
3. Prepare the Sheet: add columns ID, OpenAnswer, Accuracy(0–2), Clarity(0–2), Examples(0–1), AI_TOTAL, Confidence, Flag, FinalScore, Timestamp, PromptVersion (include model name + prompt hash).
4. Create anchors & exemplar: write three anchors (A5/A3/A1) in Config. Manually score them once and record date/model.
5. Batch-grade: anonymize 10–20 answers, run the AI prompt below, paste TSV back into the sheet so formulas populate AI_TOTAL and FinalScore.
6. Audit fast: filter FLAG or Confidence <0.70, spot-check ~10% until agreement ≥0.8, then 10% ongoing checks.

Copy-paste AI prompt (use as-is)

Score each anonymized student answer for the topic below. Rubric: Accuracy (0–2), Clarity (0–2), Examples (0–1). Anchors: A5: “{EXEMPLAR_5}”; A3: “{EXEMPLAR_3}”; A1: “{EXEMPLAR_1}”. Return one TAB-separated line per student exactly: ID[TAB]TOTAL(0–5)[TAB]Accuracy[TAB]Clarity[TAB]Examples[TAB]Confidence(0.00–1.00)[TAB]Reason(≤12 words)[TAB]Tip(≤12 words)[TAB]Flag(OK|BORDERLINE|OFFTOPIC). Use BORDERLINE if TOTAL is 2–3 or Confidence <0.70. If OFFTOPIC, set Examples=0 and TOTAL ≤1. Student answers: 101: “{ANS_101}”; 102: “{ANS_102}”; 103: “{ANS_103}”. Return ONLY TSV lines.

Metrics to track

• Time-to-feedback: average minutes from submission to returned score (target <48 hrs, ideal <24 hrs for async classes).
• Auto-grade coverage: % of total points handled by MC/checkbox (target 70%+).
• AI-human agreement: correlation or % within ±1 point on 10–20% spot-checks (target ≥0.8).
• Flag rate: % BORDERLINE/OFFTOPIC (expect 5–15% early; trend down).

Common mistakes & fixes

• Too many open items — move to MC/short where you can.
• Vague anchors — rewrite anchors to include explicit required phrases or elements.
• No model stamp — include model name + prompt text/hash in PromptVersion so you can reproduce results.
• Messy pastebacks — force TSV and tell the AI to return ONLY lines.

One-week action plan (fast rollout)

1. Day 1: Define objective, build rubric & exemplar; add Config sheet (30–60 mins).
2. Day 2: Create Form, link to Sheets (15–30 mins).
3. Day 3: Collect 10 pilot responses, run the prompt, paste TSV, inspect (30–60 mins).
4. Day 4: Spot-check 20%, adjust anchors, record PromptVersion (30–45 mins).
5. Day 5: Run a 20–30 learner batch, measure metrics, tweak question mix (30–60 mins).
6. Day 6–7: Add delivery (mail-merge), schedule weekly calibration checks.

Result: defensible, fast grading with an audit trail and measurable KPIs. Expect initial calibration to take the most time; thereafter you’ll be grading 20 responses in ~10 minutes with >0.8 agreement.

Your move.

Aaron Agius

Agreed: your quality gate + KPIs are the right backbone. Here’s how to turn that into a publish/no‑publish system with clear thresholds, lower review time, and predictable scale.

Hook: If it doesn’t meet the threshold, it doesn’t ship. You’ll cut rework and protect tone without slowing teachers down.

The risk to manage: Tone drift, reading-level misses, and fuzzy assessments. These don’t just read awkwardly — they cause confusion and burn classroom minutes.

Field lesson: Add a calibration pack and an AI judge rubric on top of your gate. That closes the last 10% gap and makes approvals objective, not opinion-based.

• Do: Lock a glossary + do‑not‑translate list; set target reading level; enforce short sentences; require A/B (literal/localized) + risk log; run back‑translation on localized; use a 10–15 sentence calibration pack; track KPIs weekly.
• Do not: Publish without hitting thresholds; mix formality in one lesson; let idioms or culture‑bound examples slip; accept low‑confidence items; skip a classroom pilot.

1. Assemble a calibration pack (60 minutes). Collect 12–15 source sentences covering greetings, instructions, examples, assessments, sensitive phrasing, and inclusive language. Add 2 “style beacons” that sound exactly like your teacher voice. This becomes few‑shot context for both translation and QA.
2. Lock terms. Build a 30–50 term glossary and a do‑not‑translate list (product names, math terms, placeholders like {name}). Add an inclusive language rule (e.g., gender‑neutral where possible).
3. Set acceptance thresholds (before you run). Lesson passes only if: edit density <= 15/1,000 words; reviewer time <= 12 min/1,000 words; glossary adherence >= 98%; reading level within one band; risk flags <= 5 per 500 words; zero assessment ambiguities; student quick‑check ≥ 80%.
4. Translate with your existing prompts (literal + localized + risk log). Keep bullets, numbering, and placeholders intact.
5. Judge and triage (AI first, human second). Run the QA judge prompt below on the localized version. Auto‑accept sentences scoring “pass” across all rubric items; send “needs fix” to the AI for a single revision; only route unresolved items to a reviewer.
6. Back‑translate smartly. Back‑translate the revised localized version only for (a) all assessment items, (b) anything the judge flagged, and (c) a 10% random sample.
7. Build translation memory (TM). Save accepted segments as your baseline. On the next unit, ask the AI to reuse TM matches and only localize the remainder. This steadily reduces edits.
8. Pilot and log. Run a 3–5 item quick check + 3 reaction questions (understandable, natural, friendly). Log confusion points and fold them into the glossary/voice guide.
9. Review the dashboard weekly. Track acceptance rate at the gate, edit density, reviewer time, and student comprehension. Expand scope only when you clear thresholds twice.

Copy‑paste prompt: AI QA Judge + Fix

You are a quality reviewer for classroom translations. Evaluate the LOCALIZED [TARGET_LANGUAGE] text against the English source using this rubric: 1) Tone/voice match to a warm, encouraging teacher (1–5), 2) Reading level equals [TARGET_LEVEL] (1–5), 3) Instruction/assessment precision (1–5), 4) Glossary adherence for [GLOSSARY] (1–5), 5) Cultural fit and inclusive language (1–5), 6) Structure: bullets/numbering/placeholders intact (1–5). For each sentence: provide scores, a one‑line rationale, and status: PASS if all >=4, else NEEDS FIX. Then propose a corrected [TARGET_LANGUAGE] sentence that meets the rubric. Finally, summarize: counts of PASS/NEEDS FIX, risk types, and any glossary violations. Apply the calibration examples: [PASTE 10–15 SHORT EXAMPLES THAT SHOW DESIRED TONE/PHRASING].

Metrics to track weekly

• Gate pass rate: % of sentences that pass AI judge on first try (target ≥ 70%).
• Edit density: fixes per 1,000 words (target ≤ 15).
• Reviewer time: minutes per 1,000 words (target ≤ 12).
• Risk flags: medium/low confidence per 500 words (target ≤ 5; zero critical).
• Comprehension: student quick‑check correct rate (target ≥ 80%).
• Cycle time: request to publish (target ≤ 24 hours per lesson once stabilized).
• Defect escape: post‑pilot issues per lesson (target ≤ 1 minor, 0 major).

Common mistakes and fast fixes

• One model does everything. Fix: use a second model or a paraphrase‑invariance check for QA to avoid blind spots.
• Unscoped back‑translation. Fix: limit to assessments, judge‑flagged items, and 10% sampling.
• Reviewer edits untagged. Fix: require edit tags (tone, clarity, culture, assessment) to feed the glossary/voice guide.
• Mixed formality. Fix: set formality once; include two style beacons in the prompt.
• Run‑on sentences. Fix: controlled authoring to max 20 words, one instruction per sentence.

Worked example

1. Source: “Quick check: In two sentences, explain why plants need sunlight. Use your own words.”
2. Localized (ES): “Comprobación rápida: En dos oraciones, explica por qué las plantas necesitan luz solar. Usa tus propias palabras.”
3. AI judge scores: Tone 5; Reading level 4; Precision 4; Glossary 5; Culture 5; Structure 4 → PASS. Note: consider “frases” vs “oraciones” depending on region.
4. Minor human tweak: “Comprobación rápida: En dos frases, explica por qué las plantas necesitan luz solar. Usa tus propias palabras.”
5. Decision: Publish. Edit density impact: 1 change in 17 words = 59/1,000 words if scaled, but isolated to regional preference; log as a voice‑guide rule.

1‑week action plan (with targets)

• Day 1: Build calibration pack (15 sentences) + glossary (30 terms) + voice guide (10 rules). Define thresholds.
• Day 2: Run controlled authoring on Lesson 1. Lock placeholders and reading level.
• Day 3: Translate A/B + risk log. Run AI judge + fixes. Back‑translate assessments and a 10% sample.
• Day 4: Human review (tag edits). Target ≤ 12 min/1,000 words. Update glossary with recurring fixes.
• Day 5: Pilot with students. Aim ≥ 80% on quick‑check; collect 3 reactions. Log confusion points.
• Day 6: Repeat full flow for Lesson 2. Compare gate pass rate and reviewer time to Day 3–4.
• Day 7: Approve SOP: prompts, thresholds, reviewer checklist, folder structure, TM process. Greenlight scale if thresholds met twice.

Bottom line: You have the right controls. Add a calibration pack + AI judge rubric, enforce accept/reject thresholds, and your translation line becomes predictable: faster cycles, fewer edits, consistent tone.

Your move.

Good call on anonymizing and forcing single-line output. That’s the difference between a neat demo and a repeatable workflow. Let’s lock in consistency, scale to batches, and add an audit trail you can defend.

The gap: AI graders drift without calibration; copy-paste loops get messy; no clear KPIs makes it hard to trust results.

Why it matters: Tight prompts + anchors + simple metrics give you reliable auto-grading for low- to mid-stakes work, faster feedback, and a clean record when someone asks, “How did you score this?”

What you’ll set up

• A Google Form (quiz mode) with mostly auto-gradable items.
• One Sheet with rubric columns and a place for AI output.
• A calibrated AI prompt that returns TSV (tab-separated) lines you can paste straight into Sheets.

High-confidence grading prompt (batch, TSV, calibrated)

Copy-paste, replace items in braces, and run 10–20 answers at a time.

Strict mode (best for beginners):

Score short answers for {TOPIC}. Rubric weights: Accuracy (0–2), Clarity (0–2), Examples (0–1). Use anchors to align your scoring. Output one TAB-separated line per student in exactly this format: ID[TAB]TOTAL(0–5)[TAB]Accuracy[TB]Clarity[TB]Examples[TB]Confidence(0.0–1.0)[TB]Reason(≤12 words)[TB]One improvement tip(≤12 words)[TB]Flag(OK|BORDERLINE|OFFTOPIC). Rules: compare to rubric and anchors; never exceed rubric; BORDERLINE if TOTAL is 2 or 3 OR Confidence < 0.70; OFFTOPIC if unrelated or under 10 words. If OFFTOPIC, set Examples=0 and TOTAL ≤1. Exemplar: {1–2 SENTENCE EXEMPLAR}. Anchors: A5 (score 5): “{ANCHOR_5}”; A3 (score 3): “{ANCHOR_3}”; A1 (score 1): “{ANCHOR_1}”. Student answers: {ID_101}: “{ANS_101}”; {ID_102}: “{ANS_102}”; {ID_103}: “{ANS_103}”. Return ONLY student lines.

Light mode (faster, fewer flags):

Same as above, but omit Confidence and Flag and return: ID | TOTAL | Accuracy | Clarity | Examples | Reason | Tip.

Optional prompt to generate your worksheet questions (clean, paste-ready)

Create 10 beginner questions on {TOPIC}. Return pipe-delimited rows only with columns: Type(MC/Checkbox/Short/Open) | Question | Choices(semicolon-separated; blank if Short/Open) | CorrectChoices(semicolon-separated; for Open, write “Rubric”) | Feedback(≤15 words). Include 7 MC/Checkbox, 2 Short (exact), 1 Open with a one-sentence rubric.

How to implement — step-by-step

1. Build the Form: Enable quiz mode. Use 70–80% multiple-choice/checkbox for instant scoring. Add 1–2 open questions max.
2. Prepare the Sheet: Link responses to Sheets. Add columns next to the open-answer column: Accuracy, Clarity, Examples, TOTAL, Confidence, Reason, Tip, Flag.
3. Create anchors: Draft three anchor answers (excellent/good/weak). Manually score them once. These go into the prompt.
4. Batch-grade: Copy 10–20 anonymized answers plus IDs. Run the strict prompt. Paste TSV back into the corresponding columns. Use a simple SUM for TOTAL if needed.
5. Audit fast: Filter Flag for BORDERLINE or Confidence < 0.70. Spot-check 10–20%. Adjust exemplar/anchors if you see drift.
6. Combine scores: Add the Form’s auto-graded points + AI TOTAL. Keep a “Final” column.
7. Return feedback: Use a mail-merge add-on or paste feedback manually for a small cohort.

What to expect

• Setup in under 60 minutes. Subsequent batches: 5–10 minutes per 20 responses.
• Reliable scoring for clear, short answers with exemplars. Nuance still needs human review.
• Confidence + flags reduce re-check time and improve trust.

Metrics to track (put these in a summary tab)

• Time-to-feedback: Average minutes from submission to returned score.
• Auto-grade coverage: % of points from MC/Checkbox items (target 70%+).
• AI-human agreement: Correlation on a 10–20% spot-check (target ≥0.8) or % within ±1 point.
• Flag rate: % BORDERLINE/OFFTOPIC (watch trends after rubric tweaks).
• Learner satisfaction: 1–5 rating on feedback usefulness (aim ≥4.2).

Common mistakes and tight fixes

• Too many open questions. Keep to 1–2; shift the rest to MC with strong distractors.
• Vague exemplar. Write a crisp model answer that includes the key elements you expect.
• No anchors. Add 3 anchors (5/3/1). It stabilizes scoring across batches.
• Messy paste-backs. Force TSV output; tell the AI “return ONLY student lines.”
• No audit trail. Store prompt version, exemplar, anchors, and date in a separate “Config” sheet.

One-week rollout plan

1. Day 1: Define learning objective, build rubric (0–2, 0–2, 0–1), write exemplar.
2. Day 2: Create Form (8–12 questions; 1–2 open). Link to Sheets.
3. Day 3: Collect 10 pilot responses. Draft anchors (5/3/1). Run the strict prompt.
4. Day 4: Spot-check 20%. Tune exemplar/anchors until agreement ≥0.8.
5. Day 5: Run a 20–30 learner batch. Track metrics in a summary tab.
6. Day 6: Add mail-merge for feedback delivery. Include a 1–5 usefulness rating.
7. Day 7: Review KPIs, adjust question mix, lock v1.0 of your grading prompt.

Insider tip: Add a second mini-pass for BORDERLINE answers only with a narrower prompt: “Re-score IDs {…} using anchors; explain any change in ≤8 words.” This raises agreement without ballooning time.

Your move.

Turn RMA into a profit lever: make the AI inventory- and loyalty-aware so it chooses the cheapest acceptable path, sets accurate promise dates, and reduces follow-ups without hurting trust.

The gap: most teams stop at warranty and cost. They ignore stock, backorders, refurb availability, and customer value — the exact levers that decide margin and satisfaction.

Why this matters: inventory- and CLV-aware rules cut uneconomic repairs, avoid out-of-stock promises, and reward your best customers strategically. Expect faster first responses, fewer touches, and lower cost per case.

Lesson learned: the biggest gains come from three policies: keep-it refunds for low-value items, cross-ship for high-value customers when stock is available, and self-fix paths for trivial faults. Pair that with confidence thresholds and you scale safely.

• Do add stock levels, backorder days, refurb count, and customer value tier to your policy data.
• Do set a keep-it threshold (e.g., “if replacement_value ≤ $40 and shipping ≥ $12, offer keep-it refund”).
• Do enable cross-ship for VIPs when stock_on_hand > 0 and fraud risk is low.
• Do return a promise date that reflects stock and SLA, not guesses.
• Do not approve repairs when backorder days push you past SLA and replacement is cheaper.
• Do not let AI free-style messages; constrain outputs and require a 3-sentence update.

What you’ll need

• Extended policy JSON: warranty, repair_cap_percent, costs, plus replacement_value, stock_on_hand, backorder_days, refurb_on_hand, keep_it_threshold, clv_tier, cross_ship_rules, abuse rules, SLA days.
• Ticket fields for: category, reason, confidence, cost_estimate_total, promise_date, keep_it, cross_ship, self_fix, root_cause_code, policy_version.
• Automation to fetch stock/refurb counts and populate the policy JSON per ticket.

Step-by-step (implement in this order)

1. Extend the policy pack: add inventory and CLV keys; version it (e.g., policy_version v2.0).
2. Add decision rules: keep-it for low-value SKUs; cross-ship for Gold/Platinum when stock_on_hand > 0; deny if abuse flags true; choose replace if repair_cost ≥ cap or backorder_days > SLA.
3. Generate two outputs: structured JSON for your system, and a warm, three-sentence customer update with a firm date.
4. Use confidence thresholds: ≥0.90 auto-handle; 0.70–0.90 fast human check; <0.70 full review.
5. Root-cause coding: require a code from a short controlled list (e.g., BTN_STUCK, BAT_FAIL, COSM_DAMAGE) to feed product quality and parts planning.
6. Self-fix path: when trivial, attach a 5-step micro-guide and offer to try before shipping.
7. Audit & tune: log inputs → AI decision → human override → final outcome; tune monthly.

Copy‑paste prompt: inventory + CLV-aware, costed decision with customer update

“You are an RMA decision assistant. Choose the cheapest acceptable action that meets policy, using inventory and customer value. If required inputs are missing or photos are poor, set category=’Need More Info’.

Policy (JSON): {POLICY_JSON}

Intake: order#: {ORDER}, purchase_date: {DATE}, serial#: {SERIAL}, sku: {SKU}, clv_tier: {CLV_TIER}, photos: {PHOTO_LINKS}, issue: {DESCRIPTION}

Tasks: 1) Validate warranty. 2) Estimate repair_cost = labour_hours*labour_rate + parts_cost + shipping_in + shipping_out + bench_fee. 3) Compare repair_cost to replacement_value and repair_cap_percent. 4) Consider inventory: stock_on_hand, backorder_days, refurb_on_hand. 5) Apply keep_it_threshold and cross_ship_rules by clv_tier. 6) Set category to one of: In Warranty – Repair, In Warranty – Replace, Out of Warranty – Quote Repair, Refund Requested, Possible Abuse, Keep-It Refund, Need More Info. 7) Assign root_cause_code from allowed list. 8) Produce a customer-friendly, three-sentence message with a promise_date that reflects SLA and stock/backorder. 9) Return structured JSON only.

Output JSON keys: category, confidence (0–1), reason, root_cause_code, parts_tools, labour_hours_estimate, cost_estimate_total, keep_it (true|false), cross_ship (true|false), actions_for_customer, actions_for_ops, promise_date, flags (missing_serial, low_quality_photos, visible_damage, oow), policy_version.”

Policy JSON v2.0 template

{“policy_version”:”v2.0″,”warranty_months”:12,”repair_cap_percent”:0.6,”sla_days”:{“repair”:7,”replace”:3,”refund”:5},”costs”:{“labour_rate”:40,”bench_fee”:15,”shipping_in”:12,”shipping_out”:12},”sku_overrides”:{“SKU-100”:{“replacement_value”:120,”stock_on_hand”:14,”backorder_days”:0,”refurb_on_hand”:2},”SKU-200″:{“replacement_value”:250,”stock_on_hand”:0,”backorder_days”:9,”refurb_on_hand”:1}},”keep_it_threshold”:40,”cross_ship_rules”:{“Gold”:true,”Platinum”:true,”Silver”:false,”Bronze”:false},”abuse_rules”:{“visible_cracks”:true,”liquid_damage”:true},”allowed_root_causes”:[“BTN_STUCK”,”BAT_FAIL”,”PORT_LOOSE”,”SW_GLITCH”,”COSM_DAMAGE”]}

What to measure (target after 4–6 weeks)

• Auto-handled rate: 25–40% of tickets (while keeping overrides < 5%).
• Time-to-first-response: < 5 minutes median.
• Promise-date accuracy: ≥ 95% on-time.
• Cost per case: 15–30% reduction vs baseline.
• Repeat-contact rate: < 10% within 7 days.
• Keep-it refund share on eligible SKUs: 60–80% adoption without fraud spikes.

Common mistakes & fixes

• Ignoring backorders → Replace a repair you can’t staff: pass backorder_days and compute promise_date honestly.
• Letting root-cause labels drift → Enforce allowed_root_causes; reject free text.
• Over-issuing keep-it → Cap by keep_it_threshold and clv_tier; audit random samples weekly.
• No refurb utilization → Add refurb_on_hand and prefer it for replacements to protect margin.

Worked example

• Intake: order# 9807, sku SKU-200, serial Z9Y8X7, purchase 11 months ago, photos clear, symptom: intermittent charging. clv_tier: Gold.
• Policy: replacement_value $250; stock_on_hand 0; refurb_on_hand 1; backorder_days 9; repair_cap 60%.
• AI estimates repair_cost $95 (labour 1.5h $60 + part $20 + shipping $24 – bench $9 credit via supplier).
• Decision: replacement with refurb (under SLA 3 days) beats repair + 9-day backorder risk. Category: In Warranty – Replace (confidence 0.91). Cross-ship = true (Gold, refurb available). Promise_date: today + 3 business days.
• Ops actions: reserve refurb, generate cross-ship label, add root_cause_code PORT_LOOSE, start SLA timer.

7‑day action plan

1. Day 1: Add inventory, refurb, keep_it_threshold, and clv_tier to your policy JSON; version to v2.0.
2. Day 2: Update the triage prompt above; add ticket fields for keep_it, cross_ship, root_cause_code.
3. Day 3: Run 50 historical cases; compare decisions vs. final outcomes; set initial thresholds.
4. Day 4: Turn on auto-handle for confidence ≥ 0.90; others to fast review with AI reason visible.
5. Day 5: Enable self-fix micro-guides on BTN_STUCK and SW_GLITCH categories; measure deflection.
6. Day 6: Pilot keep-it on SKUs with replacement_value ≤ $40; audit 10% for abuse.
7. Day 7: Review metrics (cost per case, on-time promise, overrides); tune repair_cap and cross-ship rules.

Expectation: your first wins will be accurate promise dates, fewer touches from self-fix, and margin saved via keep-it/refurb. Keep thresholds high, then widen as overrides fall below 5%.

Your move.

Hook — Turn AI into your tireless sourcing analyst; you keep the buying decision.

Problem: You spend hours browsing and still miss winners because fees, repairs and weak comps kill margin after the fact. Manual checks don’t scale; guesses drain profit.

Why it matters: Consistent flips come from a repeatable filter, not luck. When every listing is judged against the same numbers, your hit rate rises, capital turns faster, and you negotiate from strength.

Lesson from the field: The biggest step-change wasn’t fancier AI — it was a simple “defect-to-deduction” sheet plus deal tiers. AI finds candidates and estimates resale; the deduction rules protect margin. False positives dropped, offers got sharper, profits got steadier.

What you’ll need

• Accounts on 2–3 marketplaces you trust.
• Google Sheets (or similar) to log every evaluated listing.
• An AI chat tool to run prompts.
• Clear buy rules: minimum net margin (start at 25%) and maximum repair spend per category.
• A defect-to-deduction cheat sheet (see below) and a 3-point photo checklist.

Insider trick — Deal tiers you can apply in seconds

• Tier A (buy now): Margin ≥ 30%, clean photos, full accessories. Action: pay or offer -5% to -10% for speed.
• Tier B (negotiate): Margin 20–29% or 1–2 minor defects. Action: ask 3 confirmation questions; offer to reach 28–32% margin.
• Tier C (skip or watch): Margin < 20%, major uncertainty. Action: set alert; recheck in 48 hours or if price drops.

Defect-to-deduction cheat sheet (tune by category)

• Missing charger/cable: subtract $10–$15 (small electronics)
• Battery health < 85%: subtract $20–$40 (phones/laptops)
• Light scratches: subtract $10; deep scratches/dents: subtract $30–$60
• Unknown iCloud/Google/MDM lock: treat as Tier C (skip unless verified)
• Box open, accessories sealed: no deduction; box missing: subtract $5–$15

Step-by-step (from listing to decision in under 5 minutes)

1. Surface candidates: Use saved searches with undervalued keywords: “as-is but working”, “read description”, “no charger”, “untested”, “open box”, misspellings of model names. Set a max price and distance radius.
2. Log the basics: Paste URL, listing price, shipping-in, condition, and two recent sold prices into your sheet. If unsure on fees, assume 15% total (platform + payment) as a conservative default.
3. AI valuation pass: Run the valuation prompt below. Use the lower sold price for safety. Note the AI’s confidence and red flags.
4. Apply deductions: From photos/description, subtract standard deductions for any defects. This gives you a realistic resale and a true acquisition cost.
5. Compute margin: Expected net resale (after fees) minus total cost (price + shipping-in + repair). If ≥ 25% and no major red flags, it’s Tier A/B.
6. Fast verify: Ask for serial/IMEI photo, battery health screenshot, and a powered-on photo. If seller replies fast with clean evidence, move.
7. Negotiate with intent: Use the negotiation prompt to frame a firm, friendly offer that protects your margin target.

Copy-paste AI prompt — Valuation

You are my resale analyst. Using the details below, estimate a conservative resale price achievable in 7–14 days on the same marketplace, list typical fees (platform % + payment %), and calculate the net profit and margin if bought at the listed price. Provide confidence (low/med/high), three red flags to verify in photos, and a go/no-go summary tied to a 25–30% target margin. Listing: [title]; price: [$]; shipping-in: [$]; condition: [new/like new/used/for parts]; comps (2 recent sold prices with dates): [sold1, sold2]; details: [model, serial if shown, included accessories, defects stated].

Copy-paste AI prompt — Negotiation message

Write a concise, polite buyer message that confirms condition and makes a fair, fast-cash offer that targets a 28–32% margin for me. Include 3 specific verification requests (serial/IMEI photo, battery health, powered-on photo), and justify the offer based on missing accessories or cosmetic wear if present. Keep it under 600 characters. Listing summary: [title, ask $, noted defects/accessories, location].

What to expect: With discipline, plan on evaluating 30–50 listings/hour once your sheet and prompts are set. Early weeks: 10–15 shortlists per day → 2–4 offers → 1–2 buys. Cash turns in 7–21 days if you list within 24 hours of receipt and price to the lower sold comp.

Metrics to track (weekly targets)

• Hit rate (shortlist → purchase): 10–20%
• Net margin after all costs: ≥ 25% average; ≥ 30% on Tier A
• Time-to-list after arrival: < 24 hours
• Sell-through in 14 days: ≥ 60% of listed items
• Negotiation success rate (offers accepted): ≥ 25%
• Capital turnover: average days from buy to sale

Common mistakes and quick fixes

• Underestimating shipping/fees → Fix: default to 15–18% total fees and add a $5–$15 packing/labels buffer.
• Ignoring activation/region locks → Fix: require serial/IMEI and activation screen photo before paying.
• Counting accessories as “nice-to-have” → Fix: price the resale assuming you must include them; deduct now if missing.
• Letting AI overrule your eyes → Fix: AI is a filter; your 60-second photo check decides.
• Buying one-offs across too many categories → Fix: specialize in 1–2 product families for repeatable deductions and faster comps.

1-week action plan

1. Day 1: Pick 2 categories. Write your defect-to-deduction list (5–7 items each). Set saved searches with undervalued keywords and price ceilings.
2. Day 2: Build your tracking sheet with columns: URL, Ask, Ship-in, Repair, Lower Sold, Fee %, Net Resale, Net Profit, Margin, Confidence, Red Flags, Tier.
3. Day 3: Run the valuation prompt on 40 listings. Shortlist 8–12. Message sellers using the negotiation prompt.
4. Day 4: Buy 2–3 that meet Tier A/B rules. Schedule pickup/shipping immediately.
5. Day 5: On arrival, test with a standard checklist and photograph. List within 24 hours priced at the lower sold comp minus 1–3% for speed.
6. Day 6: Review offers. Accept anything that maintains your 25%+ margin. Record final costs accurately.
7. Day 7: Update metrics. Adjust deductions, fee % and saved-search keywords based on outcomes.

Bottom line: AI surfaces candidates and standardizes your math; your rules protect downside and accelerate decisions. Track the numbers, refine weekly, and your hit rate and margins will climb together.

Your move.