aaron

Sharp framework—the 3‑part stack plus two‑variant testing is the right backbone. I’ll layer on a scoring rubric, a feed simulation, and a simple traffic plan so you pick a winner before you burn 2–3 weeks testing a weak line.

The gap: many headlines read well but underperform because they miss one of three elements: instant clarity, role‑to‑audience relevance, or credible proof. If any one is weak, invites and replies lag.

Why it matters: a cleaner pre‑screen saves time and lifts the odds that Variant A beats your current baseline. You’re aiming for modest, compounding lifts (+10–20% per iteration), not fireworks.

Field lesson: score first, simulate the feed second, then ship. Headlines that pass a simple CRC test (Clarity, Relevance, Credibility) and win a persona simulation usually win live.

What you’ll need (add to your current inputs):

• Top 3 opportunity types you want (e.g., “retention projects,” “product launches”).
• One disqualifier (what you don’t want) to avoid muddying the message.
• One proof token you can stand behind (tool, niche, soft credential).

Step‑by‑step (stacked on your process)

1. Generate candidates: Use your pattern bank to create 8–12 headlines. Keep one role keyword and one niche keyword.
2. Score with CRC (0–5 scale each; 12+ total to pass):
   • Clarity: can a stranger repeat the promise in one breath?
   • Relevance: is the audience unmistakable, and is the outcome what they buy?
   • Credibility: is there one believable proof token or result type?
3. Simulate the feed: Rank your top 6 headlines as if you were a time‑poor hiring manager with a specific job‑to‑be‑done. Keep the top 2.
4. Compression check: 6–10 words or under ~120 characters; remove fillers; start with a verb or a clear role+audience; exactly one micro‑proof.
5. Traffic plan (to get signal fast): If your baseline views are under 50 per week, add 10 targeted LinkedIn requests per day (or 5 Upwork proposals across the right category) for the first 4 days of each test.
6. Run A/B: 14 days each. Change nothing else during a variant’s window.

Copy‑paste AI prompt: CRC scoring + rewrite

“Evaluate these LinkedIn/Upwork headlines for CRC. For each, score Clarity, Relevance, Credibility on a 0–5 scale, total the score, and give a one‑line fix. Keep each under 120 characters, include exactly one role keyword and one niche/proof token. Then produce a ‘best revised’ version for any headline scoring under 12. Headlines: [paste up to 10].”

Copy‑paste AI prompt: persona feed simulation

“Act as a time‑pressed hiring manager. Persona: [e.g., SaaS founder], Job‑to‑be‑done: [e.g., improve onboarding], Constraints: [e.g., limited budget, needs fast ramp]. You will see 6 candidate headlines. Rank them 1–6 by likelihood to earn a click in a scrolling feed. For each, list: 1) 5‑word recall, 2) reason to click, 3) what’s missing. Headlines: [paste 6].”

Copy‑paste AI prompt: safety/compliance pass

“Review this headline for risky claims, vagueness, or buzzwords. Suggest a compliant, plain‑English rewrite that keeps one measurable verb and one micro‑proof token. Headline: [paste].”

Metrics to track (and targets)

• LinkedIn: profile views (+10–20%), search appearances (+10%), connection requests received (+15%), reply rate on outbound (+5–10%).
• Upwork: profile views (+10–20%), job invites (+10–20%), proposal‑to‑interview rate (+5–10%), hire rate (hold or improve).
• Thresholds to call a win: at least 100 profile views or 20 outreach touches per variant, with a ≥10% lift on one primary KPI.
• Quick math: Lift % = (Variant − Baseline) ÷ Baseline × 100.

Common mistakes and fast fixes

• Too clever, not clear — Fix: start with role or verb (“Email for DTC — grow repeat sales | Klaviyo”).
• Multiple proof tokens — Fix: one token in the headline; move the rest to About/Skills.
• No audience — Fix: name them explicitly (SaaS, DTC, Fintech, Local Service).
• Hard promises — Fix: soften with “help/aim to” unless you can verify.
• Keyword stuffing — Fix: one role + one niche; sprinkle synonyms in About.
• Mismatched top‑of‑fold — Fix: echo the headline’s audience+outcome in the first 80 characters of About/Overview.

One‑week action plan

1. Day 1: Gather inputs (audience, outcome, proof, tone, opportunities, disqualifier). Generate 8–12 headlines using your pattern bank.
2. Day 2: Run CRC scoring; discard anything under 12/15. Run the persona feed simulation; keep the top 2.
3. Day 3: Compression pass and compliance pass. Finalize Variant A and B.
4. Day 4: Ship Variant A. Capture 14‑day baseline metrics from your last period.
5. Days 5–7: Create signal: 10 targeted LinkedIn requests/day or 5 Upwork proposals/day aligned to the headline’s niche. Log views, invites, replies.

What to expect: A tighter shortlist in under 45 minutes, early signals within 7–10 days, and a cleaner read on which headline earns more views and invites. If both variants underperform, swap one element (audience, outcome, or tone) and rerun the loop.

Turn your stack into a system: score, simulate, compress, ship, measure, iterate. Your move.

Locking the import format before scaling is the right move. You’ve nailed the foundation. Now let’s make it production-grade so you can generate, QA, and export to Moodle (GIFT) and Canvas (CSV/QTI) with minimal rework.

Reality check: Format errors aren’t the only drag. Inconsistent answer keys, weak distractors, and missing tags kill reuse and analytics.

Why it matters: A repeatable pipeline (schema → AI generation → QA → exports) cuts your time per question to minutes, keeps imports clean, and gives you durable banks you can version and reuse across courses.

My lesson: Generate once in a “canonical schema,” then render to GIFT and CSV from that source. Add lightweight QA checks before importing and you’ll 3–5x throughput without quality slip.

• Do: Use a canonical item schema (ID, stem, 4 options, correct, rationale, difficulty, Bloom level, tags).
• Do: Keep IDs stable (e.g., ACC201-Q017-v1). Increment versions when editing to avoid duplicates.
• Do: Bake QA into the prompt: one correct answer, plausible distractors, similar option length, remove negatives unless intentional.
• Do: Tag with topic|difficulty|bloom|item_id for filtering and randomization.
• Don’t: Mix curly quotes, stray commas, or hidden characters — use straight quotes and UTF-8.
• Don’t: Rely on LaTeX or images in CSV. For formulas, use LMS-native editors post-import.
• Don’t: Use “All of the above” or overlapping distractors; it reduces diagnostic value.

What you’ll need

• AI chat tool.
• Google Sheets or Excel.
• LMS test course with import permissions (Moodle and/or Canvas).
• One small sample export from your LMS to confirm header naming.

Steps to execute

1. Create your canonical sheet with headers: item_id, type, stem, optionA, optionB, optionC, optionD, correct, points, rationale, difficulty(1–3), bloom, tags.
2. Use the dual-output prompt below to generate 10–20 items into: (A) canonical CSV, (B) Moodle GIFT, (C) Canvas-friendly CSV.
3. Run a quick QA pass: check one correct per item, option length balance (no telltale 3-word vs 10-word gaps), remove ambiguous wording, confirm feedback/rationale.
4. Import 5 items to Moodle via GIFT. Fix any line causing an error, re-export, re-import.
5. Import the same 5 items to Canvas via CSV. If your Canvas instance prefers QTI, keep CSV for Classic, and plan a QTI step later if needed.
6. Once clean, scale to batches of 50. Keep IDs and tags consistent for future randomization and analytics.

Worked example (one item, three outputs)

• Canonical (CSV row): MCQ,”Which organelle is known as the cell’s powerhouse?”,”Mitochondria”,”Nucleus”,”Ribosome”,”Golgi apparatus”,”Mitochondria”,1,”Mitochondria generate ATP.”,1,Remember,”cell_bio|energy|BIO101-Q001-v1″
• Moodle GIFT: Which organelle is known as the cell’s powerhouse? {=Mitochondria ~Nucleus ~Ribosome ~Golgi apparatus}
• Canvas CSV row: type,question,option1,option2,option3,option4,correct,points,feedback,tagsMCQ,”Which organelle is known as the cell’s powerhouse?”,”Mitochondria”,”Nucleus”,”Ribosome”,”Golgi apparatus”,”Mitochondria”,1,”Mitochondria generate ATP.”,”cell_bio|remember|d1|BIO101-Q001-v1″

Copy-paste prompt (dual-output, use as-is)

Generate [N] assessment items on [TOPIC] for [LEVEL] learners. Use only multiple-choice (4 options). Apply this policy: one unambiguously correct answer, three plausible distractors, avoid negatives unless flagged, keep option lengths within ±20% of correct. Include a 1-sentence rationale (feedback) and tags. Return exactly three sections in this order, with no extra commentary.

SECTION A: Canonical CSV with columns: type,question,option1,option2,option3,option4,correct,points,feedback,tags. Use type=MCQ, points=1. Use straight quotes only. Do not include commas inside fields unless the field is wrapped in quotes.

SECTION B: Moodle GIFT for the same items. Each item as: Question text {=Correct ~Distractor ~Distractor ~Distractor}

SECTION C: Canvas CSV with the same columns as Section A.

Topic=[insert]; Level=[insert]; N=[insert].

Quality KPIs to watch

• Time to first clean import: target under 30 minutes.
• Import error rate (first pass): under 5% rows.
• QA rejection rate after review: under 10%.
• Throughput after template lock: 100–150 questions/hour (including review).
• Distractor plausibility score (subjective 1–5): average ≥4.

Common mistakes & fixes

• Mismatch in correct column: Ensure the correct field exactly matches one option text (case and punctuation).
• Curly quotes/smart punctuation: Convert to straight quotes; set spreadsheet to plain text before paste.
• Duplicate stems: Add an item_id and search for duplicates before import.
• Canvas variant differences: Some instances prefer QTI. Validate CSV import in your environment with 5 items first; if blocked, export QTI later.
• Images or math fail: Upload assets to LMS first and reference stable URLs, or add equations post-import with the LMS editor.

7-day sprint

1. Day 1: Build the canonical sheet and confirm LMS headers. Create 5-item sample export for reference.
2. Day 2: Generate 10 items with the dual-output prompt. Import 5 to Moodle (GIFT) and 5 to Canvas (CSV). Fix formatting.
3. Day 3: Codify your QA checklist (answer key, option length, clarity, tags). Apply to 20 new items.
4. Day 4: Scale to 50 items. Tag by topic and Bloom level. Import in batches of 25.
5. Day 5: Add rationales and difficulty labels. Spot-check 10 items in the LMS as a student preview.
6. Day 6: Produce another 50–100 items. Version IDs (v1 → v2) for any edits.
7. Day 7: Final QA, archive master canonical CSV, plus export packs: Moodle GIFT and Canvas CSV.

Next step: Tell me Moodle or Canvas (or both) and I’ll tune the headers and a ready-to-import starter file for your setup.

Your move.

— Aaron

Good point: focusing on safety and effectiveness from the start is exactly right — protect your data while getting usable insights.

Quick reality: you can use AI to research market salaries and draft negotiation scripts fast — but only if you follow a repeatable, private workflow and validate AI outputs against multiple sources.

Why this matters: a sloppy approach wastes leverage and risks exposing sensitive details. A structured approach increases your odds of closing +10–20% on target offers.

What I’ve learned: use AI for synthesis and phrasing, not as a primary data source. Treat it like an assistant that aggregates public data and formats your script — then verify.

Checklist — Do / Do not

• Do: anonymize role details, cross-check 3+ sources, set clear target numbers.
• Do: prepare a BATNA and non-salary asks (bonus, equity, title, start date).
• Do not: paste personal identifiers (SSN, exact current comp breakdown) into AI prompts.
• Do not: accept the first salary figure AI returns without verification.

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

1. Collect role basics: title, level, location, years of experience, industry, company size.
2. Use AI to synthesize public salary ranges from job boards and reports — keep prompts anonymized.
3. Validate: compare AI output to 2–3 reputable sources (company filings, industry reports, recruiter notes).
4. Define targets: market midpoint, low acceptable, ideal ask (usually midpoint +10–15%).
5. Draft negotiation script with AI: anchor, justify with data, state BATNA, ask for time to decide.
6. Practice live: role-play script, refine tone and timing, prepare responses to common pushbacks.

Key metrics to track

• Salary range confidence (% agreement across sources).
• Target delta = Desired ask / Market midpoint (%).
• Offer conversion rate (offers / interviews) after implementing scripts.
• Average increase achieved vs. prior offers (%).

Mistakes & fixes

• Mistake: trusting a single data point. Fix: require 3-source agreement before using a number.
• Mistake: revealing exact current comp. Fix: state ranges or percentage increases instead.

Worked example

Role: Senior Product Manager, Seattle, 8 years. AI synthesis finds market range $140k–$180k; midpoint $160k. Target ask: $175k (mid +9%). BATNA: one pending recruiter interview with $165k confirmed.

Script snippet: “Based on market data for Senior PM roles in Seattle and my 8 years leading cross-functional product launches, I’m targeting $175,000. I believe that reflects market value and the impact I’ll deliver. If that’s outside the range, I’m open to discussing a compensation package that includes additional equity or a sign-on.”

Copy-paste AI prompt (use after anonymizing specifics)

“You are an expert compensation researcher. Given this anonymized role: Senior Product Manager, 8 years experience, Seattle, mid-sized tech company — summarize a realistic salary range with justification, list three likely data sources to confirm, and draft a concise 3-line negotiation opening (anchor + justification + fallback). Do not ask for or use personal identifiers.”

1-week action plan

1. Day 1: Collect role basics and run the AI prompt above (anonymized).
2. Day 2: Verify AI ranges against 2–3 sources and finalize target numbers.
3. Day 3: Generate negotiation script and rebuttals with AI.
4. Day 4–5: Role-play scripts; iterate tone and timing.
5. Day 6: Prepare BATNA and non-salary asks.
6. Day 7: Final review and commit to your opening lines.

Your move.

Good call — changing one element at a time is the single most reliable way to learn what actually moves the needle.

Problem: most Upwork/LinkedIn headlines are either vague lists of titles or keyword-stuffed phrases that don’t convert. That wastes opportunities — profile impressions that don’t turn into invites, messages, or calls.

Why it matters: your headline is the primary conversion trigger. A 10–30% lift in profile views or reply rate from a simple headline change means more projects, higher-quality leads, and faster client wins.

Short lesson from the field: focus on audience + outcome + distinct proof/tool. Keep it 6–10 words, action-oriented, and test a benefit-led version vs a personality/tone version.

1. What you’ll need:
   • One-line outcome (what you deliver)
   • Primary audience (who benefits most)
   • Top 1–2 skills/proof points or a tool
   • Preferred tone (direct, friendly, bold)
2. Step-by-step: how to create and test:
   1. Write a single sentence: outcome + audience + skill. Example: “Cut onboarding churn for SaaS founders via UX audits.”
   2. Use this AI prompt to generate options (copy‑paste below).
   3. Select two candidates: A = benefit-led (clear outcome), B = personality/tone (distinct voice).
   4. Implement variant A for 14–21 days, then swap to B for the same period. Don’t change anything else.
   5. Compare metrics and iterate (keep the winner, then test one new element).

Copy‑paste AI prompt (use verbatim):

“Write 6 headline options (each under 120 characters) for a [role] who helps [audience] achieve [benefit]. Provide: 2 benefit-led headlines, 2 personality/tone headlines, 1 that uses a measurable verb, and 1 that includes a quick proof or tool. Keep each scannable (6–10 words) and focused on outcomes.”

Metrics to track:

• LinkedIn: profile views, connection requests received, InMail reply rate, number of meeting requests.
• Upwork: profile views, job invites, messages, proposal-to-interview rate, hire rate.
• Compare percentage change vs the previous period (target +10–30% as an initial KPI).

Common mistakes & fixes:

• Too many titles — fix: pick one role + one benefit.
• Vague buzzwords — fix: replace with specific outcome or proof.
• Over-promising — fix: soften claims with “help” or show a tool/proof.

1. 1-week action plan:
   1. Day 1: Draft the one-line outcome + audience + skill.
   2. Day 2: Run the AI prompt and pick 6 options.
   3. Day 3: Shortlist 2 headlines and refine language for scannability.
   4. Day 4: Update profile headline (variant A) and note baseline metrics.
   5. Days 5–7: Promote profile (apply to 5 jobs/send 10 messages) and log responses.

Keep tests small, measure rigorously, and scale what wins. Your move.

— Aaron Agius

Cut the guesswork: cluster search intent, map content, and stop wasting time on pages that never rank or convert.

The problem. Small sites publish scattered pages that chase keywords instead of satisfying user intent. Result: low traffic, poor rankings, and weak conversions.

Why it matters. One focused content map turns dozens of irrelevant pages into a revenue-driving structure: pillar pages, supporting articles, and conversion pages aligned to intent. That makes SEO predictable and scalable.

Short lesson from the field. I’ve seen small sites double organic conversions by shifting 8 scattered posts into 3 intent-aligned pages with clear internal linking and CTAs. The work is mostly organization and prioritization.

What you’ll need (quick):

• Access to Google Search Console + Google Analytics (or similar).
• A seed list of 50–200 keywords (serps, customer language, competitors).
• A spreadsheet and an AI assistant (optional but speeds clustering).

Step-by-step: how to cluster intent and build the map.

1. Extract keyword data: export queries from GSC (90 days) and any existing keyword list. Add estimated volume and difficulty if you have a tool.
2. Normalize and clean: dedupe, remove brand-only queries, fold plurals and misspellings.
3. Label intent manually or with AI: tag each keyword as Informational, Commercial Investigation, Transactional, or Navigational.
4. Cluster by topic+intent: group keywords that satisfy the same user need into clusters (one cluster = one target page or content series).
5. Map content types: assign each cluster to pillar, supporting blog post, product page or FAQ. Note primary CTA for each (lead, sale, signup).
6. Prioritize: score clusters by intent value (transactional highest), search volume, and ranking difficulty. Pick 3–5 quick wins.
7. Create briefs: for each prioritized cluster, write a one-page brief with title, headings, target keywords, internal links, and CTA.
8. Publish + link: implement pillar pages first, link supporting content back to pillar, track impact.

Copy-paste AI prompt (use with your keyword list):

“You are an SEO strategist. Given the following comma-separated list of keywords and their approximate monthly search volumes, do three things: 1) Group keywords into clusters by search intent (Informational, Commercial Investigation, Transactional, Navigational). 2) For each cluster, provide a short cluster name, a 10-word buyer-stage description, a suggested page title, a 140-character meta description, recommended URL slug, and the primary CTA. 3) Rank clusters 1–5 by priority for a small site (low budget). Here are the keywords: [paste keywords and volumes].”

Metrics to track (KPIs).

• Organic clicks & impressions (GSC)
• CTR for target pages
• Rankings for cluster head terms
• Organic sessions to prioritized pages
• Conversion rate / goal completions per page

Common mistakes & fixes.

• Publishing multiple pages for same intent → consolidate into one authoritative page.
• Ignoring page format (blog vs product) → match format to intent.
• Weak internal linking → create clear hub-and-spoke linking to your pillar page.

1-week action plan (practical).

1. Day 1: Export GSC queries + analytics; assemble seed keywords into sheet.
2. Day 2: Clean list; add volumes; remove brand terms.
3. Day 3: Run clustering prompt across keywords (use the AI prompt above).
4. Day 4: Review clusters, assign content types and CTAs; pick 3 priorities.
5. Day 5: Draft two content briefs (pillar + supporting post).
6. Day 6: Publish one supporting post with internal link to an existing/created pillar.
7. Day 7: Set up a simple KPI dashboard; monitor GSC for early signals.

Your move.

Agree — the named reviewer plus a minimal verification checklist and an escalation ladder are the backbone. Now let’s bolt on measurement and pre-approved language so you can move fast, stay accurate, and prove it with numbers.

The problem When incidents hit, teams either publish late or say too much. Both erode trust. The fix is a tight system: facts → AI draft → human scorecard → publish on a cadence. No guessing, no rework.

Why it matters Speed is visible, accuracy is remembered. Consistent, plain-English updates cut tickets, stabilize sentiment, and protect renewal risk. You can track all three.

Field lesson The winning combo is pre-approved phrasing plus a reviewer scorecard. It reduces legal drag, prevents speculation, and keeps tone steady across channels.

What you’ll need (10 minutes to set up, then reuse)

• Severity definitions (S1: full outage; S2: major feature; S3: partial/minor).
• Facts checklist (start time, affected features, scope %, regions, suspected cause, workaround, next-update time, owner).
• Pre-approved phrase bank (acknowledgement, impact, actions, workarounds, next-update statements, apology).
• Three templates (social one-liner, 50–80 word status page, 3-bullet internal brief).
• One reviewer + one escalation lead by role, and access to status page/social/internal channel.
• A simple AI chat tool and a timer (30-minute default cadence).

Fast execution playbook (repeatable)

1. Classify severity (30 seconds): S1 if >50% users blocked or core function down; else S2/S3. This sets cadence: S1 every 30 minutes, S2 every 60, S3 every 120.
2. Fill facts checklist (2–3 minutes): Confirm what’s known vs. unknown. If unknown, explicitly state “cause under investigation.” Never guess an ETA for a fix; only promise next update time.
3. Draft with AI (1 minute): Use the prompt below and paste your facts. Generate social + status page + internal in one go.
4. Reviewer scorecard (90 seconds): Approve only if it hits 8/10 on this quick rubric: 1) acknowledges issue, 2) states impact plainly, 3) gives start time, 4) explains current actions, 5) offers workaround or says none, 6) sets next-update time, 7) avoids speculation/ETAs, 8) reading level ~Grade 8, 9) consistent across channels, 10) courteous tone.
5. Publish + log (1 minute): Post to channels, and log timestamp, approver, severity, and next-update time. Set timer.
6. Cadence loop: Feed new facts back into the same prompt. If nothing new, still post a check-in with status and next update.
7. Closure (post-mortem comms): Within 24–48 hours, publish a brief resolution note: root cause, fix, prevention steps, and an apology.

Insider tricks

• Two clocks: Never promise a fix by time; promise the next update by time. It protects credibility.
• Phrase bank: Pre-approve 10–12 sentences for impact, actions, and apologies. Legal signs off once; you reuse endlessly.
• Channel tuning: Social = one sentence; status page = 50–80 words; internal = 3 bullets with owner and actions.

Copy-paste AI prompt (use as-is)

Act as a crisis communications assistant. Using the facts below, produce three outputs: 1) a one-sentence public alert (max 280 chars), 2) a 50–80 word status page update with impact, what’s being done, workaround (or “none available”), and the exact next-update time, and 3) an internal engineering brief with scope, immediate actions (3 bullets), and named lead. Tone: calm, transparent, professional; Grade 8 reading level for customer messages; no speculation or fix ETAs. Facts: [paste start time, affected features, scope %, regions, suspected cause if confirmed, workaround, owner, next-update time].

Metrics that prove impact

• Time to Acknowledge (TTA): target ≤7 minutes (S1), ≤10 (S2), ≤15 (S3).
• Update Cadence Adherence: % updates on time — target ≥95%.
• Clarity score: Grade level ≤8; zero jargon flags.
• Correction rate: % posts amended for inaccuracies — target <1%.
• Ticket deflection: inbound support volume vs. baseline during outage — target −20% after first update.
• Sentiment shift: neutral/positive mentions within 2 hours — target ≥70%.

Common mistakes and quick fixes

• Silence while investigating: Post a 1-line acknowledgement within 5–10 minutes; promise the next update.
• Speculating on cause/ETA: Replace with “cause under investigation; next update at [time].”
• Inconsistent facts across channels: Always generate all channels from the same AI prompt run.
• Legal bottlenecks: Use the pre-approved phrase bank; only the variable facts change.
• Too technical: Add “Explain for customers, avoid jargon, Grade 8 reading level” to every prompt.

7-day rollout (simple and measurable)

1. Day 1: Define S1–S3 and set cadences; nominate reviewer and escalation lead by role.
2. Day 2: Build the single-sheet facts checklist and a 12-line phrase bank; get pre-approval.
3. Day 3: Save the prompt above as a template; create three message shells per channel.
4. Day 4: Dry run a mock S1 incident; measure TTA and cadence adherence.
5. Day 5: Tune the reviewer scorecard; enforce 8/10 minimum before publish.
6. Day 6: Connect metrics: start logging timestamps, sentiment snapshot, and support volume.
7. Day 7: Run a second drill; compare metrics; lock the playbook and store it where everyone can access it.

Bottom line AI drafts it; your reviewer ensures truth and tone; the scorecard and metrics make it repeatable and provable.

Your move.

Good correction on excluding only multi‑attendee and all‑hands events. That keeps your automation flexible and prevents wasting perfectly usable time.

Reality check: if your calendar doesn’t defend deep work, meetings and pings will. The outcome to chase is simple—one protected block daily that actually survives. Automate it, measure it, scale it.

• Do: use one primary calendar, run the automation early morning, target a 90‑minute block with a 60‑minute fallback, set to Busy (or Focus), add a 10‑minute buffer, and auto‑decline invites during that block.
• Do: prioritize morning energy peaks, color‑code “Deep Work,” and add a one‑line description so colleagues respect it.
• Do: cap total focus holds at 20–30% of working hours to avoid overblocking and resentment.
• Do: log created holds and interruptions daily—treat this like a KPI, not a vibe.

• Don’t: exclude every event with attendees—only exclude multi‑attendee or all‑hands; allow your own single‑attendee blocks and reminders.
• Don’t: split deep work into 3–4 micro‑blocks; one continuous block beats three fragments.
• Don’t: run automations on secondary calendars or across time zones without checks—duplicates and misses follow.
• Don’t: hide it as Private with no context; clarity reduces friction.

Insider trick: on Google Calendar, use the Focus Time event type and enable auto‑decline. It behaves like Busy, visually signals intent, and enforces the boundary without manual policing.

What you’ll need

• Primary calendar (Google or Outlook).
• Automation path: built‑in Focus Time/recurring event, or Zapier/Make, or a light script (Google Apps Script/Microsoft Power Automate).
• Rules: days, time window, target length (90 → 60 fallback), exclusions (multi‑attendee, recurring, all‑hands), buffer, and a friendly auto‑decline note.

Step‑by‑step (two practical paths)

1. Fast, non‑technical (Google Focus Time)
   1. Define your window: weekdays 9:00–12:00; target 90 minutes; fallback 60.
   2. Create a Focus Time event tomorrow; enable auto‑decline invites; add description: “Scheduled focus time—please avoid unless critical.”
   3. Duplicate across the week where you see obvious free space. This is your baseline while the automation pilots.
2. Adaptive automation (Zapier/Make or script)
   1. Schedule a daily run at 6:00–7:00 AM local.
   2. Scan free/busy within your window. Pick the largest slot ≥ 90 minutes; if none, pick ≥ 60 minutes; if none, skip the day.
   3. Exclude events with more than one attendee, all‑hands, travel blocks, and recurring series. Allow your own single‑attendee holds.
   4. Create an event titled “Deep Work — Please do not schedule”, Show as Busy or Focus, add a 10‑minute buffer, no pop‑up reminders, and an auto‑decline message.
   5. First week: mark as Tentative for manual review; Week 2 onward: Busy/Focus.

Robust prompt (copy‑paste)

“You have access to my primary work calendar. Each weekday at 6:15 AM local time: 1) scan 9:00 AM–12:00 PM for the largest continuous free slot; 2) choose ≥ 90 minutes, else ≥ 60 minutes; 3) exclude slots overlapping with events that have more than one attendee, any recurring series, or company all‑hands; allow my single‑attendee reminders; 4) create ‘Deep Work — Please do not schedule’ set to Busy (or Focus), add ‘Scheduled focus time — avoid scheduling unless critical’, add a 10‑minute buffer before/after, and suppress notifications; 5) auto‑decline new invites that conflict with the created block using a polite note; 6) log the date, start/stop, length, and any conflicts to a daily summary. For the first 7 days, set status Tentative; after 7 days, set Busy/Focus if acceptance ≥ 70%.”

What to expect

• Week 1: some conflicts, but you should secure 3–4 real blocks.
• Week 2: holds stabilize and colleagues adapt if you communicate once, clearly.
• By Week 4: a reliable daily deep‑work rhythm with fewer context switches.

Metrics to track

• Total uninterrupted focus minutes per week (target: 300–450 in Week 1; 450–600 by Week 3).
• Acceptance rate: deep‑work blocks created vs. kept (target ≥ 80% by Week 2).
• Interruptions per block (target ≤ 1).
• Self‑rated focus score 1–5 after each block (target ≥ 4 by Week 2).
• Meetings displaced or declined due to holds (track trend—should drop as norms form).

Common mistakes and fast fixes

• Overblocking kills goodwill → cap at 20–30% of working hours and prioritize mornings.
• Blocks ignored by the team → enable auto‑decline and add a one‑line description; send one policy note once.
• Automation fights recurring events → explicitly exclude recurring and all‑hands; never override Busy.
• Too strict exclusions → allow your own single‑attendee reminders so the algorithm finds usable time.
• Timezone travel → read local timezone and skip creation on travel days or when working hours shift.

Worked example

• Rules: one 90‑minute hold M–F, 9–12 window; fallback 60; exclude multi‑attendee, recurring, and all‑hands; add 10‑minute buffers; auto‑decline.
• Week 1 result: 5 holds created, 4 kept (80%), 360 uninterrupted minutes, average focus 3.8/5.
• Adjustments: move window to 8:30–11:30, reduce Friday to 60 minutes. Week 2 hits 450 minutes, focus 4.2/5.

One‑week action plan

1. Day 1: Do the 60‑minute manual Focus Time block tomorrow. Draft your one‑line team note in the event description.
2. Day 2: Turn on the automation (Zapier/Make/script) with Tentative status and logging.
3. Days 3–5: Review conflicts each morning; adjust exclusions and window if acceptance < 70%.
4. Day 6: Add auto‑decline and buffers if not already on; color‑code the event.
5. Day 7: Review KPIs. If acceptance ≥ 70% and focus ≥ 3.5, flip to Busy/Focus. If not, tighten window or drop to 3x/week.

Your move.

Good prompt — focusing on product usage and support data is the right place to look for churn signals. That’s where early indicators live: declining activity, repeated unresolved tickets, or surges in negative sentiment.

Problem: Most teams have the data but not the process: they spot churn after it happens instead of predicting it so they can act.

Why it matters: Predicting churn even a month earlier lets you prioritize retention work, reduce voluntary churn, and concentrate support and success resources where they move the needle.

Short lesson from experience: Start simple and operational. Models that produce an actionable score plus the top 3 reasons for the score get used. Sophisticated models that only output probabilities gather dust.

1. What you’ll need
   • Product usage logs (events, frequency, recency, feature adoption)
   • Support data (ticket volumes, resolution time, sentiment from transcripts)
   • Customer metadata (plan, tenure, ARR)
   • Historical churn labels (who left and when)
2. How to do it — step-by-step
   1. Assemble a dataset at the customer-week level with usage aggregates (DAU/WAU, feature counts), support counts, sentiment score, and plan/ARR.
   2. Define churn label (e.g., no login + downgrade or cancellation within 30 days).
   3. Build two baselines: a rules-based score (simple thresholds) and a lightweight model (logistic regression or tree-based).
   4. Validate with time-based cross validation. Track precision on top 10% highest-risk customers — that’s your operational group.
   5. Deploy a daily score feed to CS with the top 3 drivers per customer and suggested playbook.
   6. Run an A/B test: proactive outreach vs. business-as-usual and measure churn reduction.

What to expect: Within 4–8 weeks you should have a reliable risk score. Early wins are triaging high-value at-risk customers and preventing 10–30% of predicted churn in the test group.

Metrics to track

• Overall churn rate (monthly)
• Precision@top10% risk (accuracy of alerts)
• Lift in retention for treated group vs control
• Time-to-resolution for flagged tickets
• ARR saved (or churned ARR prevented)

Common mistakes & fixes

• Mistake: Using noisy churn labels. Fix: Define clear operational churn and validate with billing data.
• Mistake: Too many features; model is opaque. Fix: Limit to top 10 features and return drivers.
• Mistake: Alerts ignored by CS. Fix: Attach concise reasons + one recommended action.
• Mistake: No feedback loop. Fix: Track outcomes of outreach and retrain monthly.

Copy-paste AI prompt (use with your LLM for feature ideas or to analyze transcripts):

“You are an expert customer success analyst. Given this data: weekly_active_users, avg_session_length, feature_X_usage_count, support_ticket_count_last_30_days, avg_ticket_resolution_hours, and sentiment_score_from_transcripts, list 12 features that are strong predictors of customer churn, explain why each matters, and suggest 3 actionable interventions a CS rep can take when the model flags a customer for each feature.”

1-week actionable plan

1. Day 1: Pull a 6–12 month sample of usage, support, and churn labels into a single sheet.
2. Day 2: Create basic aggregates (recency, frequency, feature adoption) and calculate support metrics.
3. Day 3: Define churn label and build a rules-based risk score for quick testing.
4. Day 4: Run the copy-paste AI prompt on your support transcripts to extract sentiment drivers.
5. Day 5: Train a simple model and rank customers by risk; prepare top-10% list.
6. Day 6: Draft 3 one-click playbooks for CS based on top drivers.
7. Day 7: Launch pilot outreach to top 50 at-risk customers and measure outcomes for 30 days.

Your move.