aaron

Nice focus — aiming for a consistent illustrator voice is exactly the right place to start. Below I’ll give a practical, non-technical plan to lock that voice down using AI so you can produce repeatable, on‑brand illustrations for children’s books.

The problem: illustrators drift — color shifts, character proportions change, and compositions lose the original charm across pages or books.

Why this matters: consistency builds recognizability. Young readers, parents and publishers remember characters and style. Consistency shortens revision cycles and protects licensing value.

Quick lesson I use: treat AI as a precision tool for a style guide. Don’t chase one-off pretty images — build repeatable rules and templates the AI can follow.

1. What you’ll need
   1. 10–20 reference images you like (your sketches or other art you own).
   2. 3–6 descriptive adjectives for the voice (e.g., warm, whimsical, textured, rounded).
   3. A simple palette (5 colors) and 2 character silhouette rules (head size, limb length).
   4. An AI image tool (any tool that accepts text prompts) and a text editor for prompts.
2. How to do it — step by step
   1. Write a short style brief (1 paragraph + palette + 3 rules).
   2. Use the prompt below to generate 20 variations of the main character.
   3. Pick the best 6 and create a one‑page style guide: palette, line weight, proportions, typical backgrounds, and 3 anchor poses.
   4. Use the guide to generate scene images and validate with 5 test readers/kids for recognizability.
3. Copy‑paste AI prompt (use as-is)

   “You are an award-winning children’s book illustrator. Create a clear style guide for a warm, whimsical 4–7 year old audience. Include: 1) a 5-color palette with hex codes, 2) line weight and texture description, 3) character proportions (head-to-body ratio, limb thickness), 4) three signature facial expressions, 5) two standard background treatments, and 6) five visual anchors that must not change across images. Then generate 12 variations of the main character in neutral pose, maintaining exact proportions and palette. Output as bullet points and simple labels.”

What to expect: first-pass images will be close but need refinement. After 2–3 prompt iterations you’ll have a repeatable result.

Metrics to track

• % of images where testers say “same character” (target: 80%+).
• Number of revisions per illustration (goal: ≤2).
• Time per approved illustration (goal: reduce by 30% over 4 projects).

Common mistakes and fixes

• Too vague prompts → images drift. Fix: lock palette, proportions, and 3 anchor poses in prompt.
• Overfitting a single image → loss of flexibility. Fix: create 6 approved variants, not one image.
• Ignoring composition → characters feel out of place. Fix: add camera angle and foreground/background rules to guide.

One‑week action plan

1. Day 1: Collect 10 references and pick 4–6 adjectives.
2. Day 2: Draft the 1‑page style brief and palette.
3. Day 3: Run the copy‑paste prompt to generate 12 variants.
4. Day 4: Select 6 winners and create the style guide page.
5. Day 5: Generate 6 scene images using the guide.
6. Day 6: Test with 5 readers/kids and collect feedback on recognizability.
7. Day 7: Iterate prompts and finalize the guide for future work.

Make the style guide a living file you use for every brief. That’s how consistency becomes scalable.

Your move.— Aaron

Here’s the leverage: use AI as your researcher, fraud filter and rate calculator so you only touch microjobs and surveys that convert to real cash at or above your target hourly rate.

The problem

Most microjobs underpay and most surveys screen you out. The waste comes from three blind spots: unclear pay floors, no vet on payout reliability, and no math on true hourly earnings.

Why it matters

When you quantify payoff before you apply, you stop chasing pennies. AI can surface legitimate platforms, flag risk, and estimate effective hourly pay in seconds — so your time goes where money flows.

What I’ve seen work

With clients over 40, three levers moved earnings quickly: a hard minimum rate, a pre-apply vet, and ruthless pruning after 10–14 days. The win wasn’t more effort — it was better filtering and faster measurement.

What you’ll need

• Device + reliable internet + verified payout (PayPal or bank).
• One 2–3 line bio and a 1-minute summary of skills (data entry, transcription, short writing, surveys).
• A simple spreadsheet with columns: Source, Task, Payout, Minutes, Qualified? (Y/N), Paid On Time? (Y/N), Notes.

Step-by-step (do this)

1. Lock your guardrails. Minimum effective hourly (e.g., $12–$15/hr). Max time per task (30–45 minutes). Max screen-out tolerance (e.g., under 35%).
2. Shortlist platforms with payout proof. Use the prompt below to get 6–10 legitimate sites, including details on payment timing, cash-out minimums, fees, and typical screen-out rates.
3. Vet each listing before applying. Run the “Scam/Time-Waster Filter” prompt on any gig or survey panel page you’re considering. You’ll get red flags, missing info, and must-ask questions.
4. Estimate your real hourly in advance. Use the Rate Calculator prompt. It adjusts for screen-outs (your “screen-out tax”) and shows a go/no-go decision.
5. Pitch tight and consistent. Use the pitch generator to produce 30–40 word messages for microtasks, surveys, transcription. Offer a tiny paid sample and a clear turnaround.
6. Batch and track. Apply in two 30–45 minute sprints per day. Record Minutes and Payout for every task, including screen-outs. After 10–14 days, drop sources under your floor.

Copy-paste AI prompts (refined and robust)

• Shortlist (platforms that actually pay): “List 10 legitimate platforms for microjobs and paid surveys for someone with basic digital skills (data entry, short writing, transcription, surveys). For each, provide: one-line description, typical task types, average task length, typical effective pay range, payout methods, payout timing, minimum cash-out and fees, common screen-out rate, three red flags to watch for, and one acceptance tip. Prioritize platforms with public payout evidence and no upfront fees. Exclude sites that require purchases.”
• Scam/Time-Waster Filter (per listing or panel): “Analyze this microjob/survey listing: [paste text or URL text]. Identify: 1) missing or vague details, 2) payout risks (delays, thresholds, fees), 3) data/privacy concerns, 4) three verification steps to confirm legitimacy, 5) three questions to ask before starting, 6) a go/no-go verdict with reasoning.”
• Rate Calculator (adjusts for screen-outs): “Evaluate expected effective hourly pay. Inputs: payout = [$], estimated minutes = [min], estimated qualification rate = [%], cash-out minimum = [$], average tasks to cash-out per week = [#]. Compute: a) expected hourly = (payout × qualification rate) ÷ (minutes/60); b) risk-adjusted hourly if payout is delayed by cash-out threshold; c) go/no-go vs my floor of [$]/hour. Return the numbers clearly.”
• Pitch Generator (3 variants): “Write three 35–40 word pitches I can paste when applying to microjobs and surveys. Variants: data entry, transcription, survey participation. Include: availability, a 15-minute paid sample offer, expected turnaround, and request for written deliverables + payout method.”
• Follow-up/Dispute Template: “Draft a polite 80–100 word message to request status or escalate non-payment for a completed microtask/survey, referencing task ID, submission date, payout terms, and a 48-hour resolution ask.”

What to expect

• Day 1: a shortlist of 6–10 platforms with payout details and red flags.
• Days 2–3: 10–15 applications sent; 2–4 trials accepted.
• Days 4–7: 1–3 paying tasks completed; clear view of sources above/below your floor.

KPIs (decide with data)

• Applications per week (target: 12–20)
• Acceptance rate (target: 15–30%)
• Qualification rate (surveys) (target: 50%+ on your top panels)
• Average task minutes (target: under 45)
• Effective hourly = total paid ÷ (total minutes/60) (target: at/above your floor)
• Payout reliability = % paid on time (target: 95%+)
• Cash-out velocity = days from task to money in account (target: under 7 days)

Insider tricks

• Screen-out tax: If a panel screens out 40% of the time, multiply payouts by 0.6 before comparing to your hourly floor.
• Cash-out friction: High thresholds lower real earnings. Prefer platforms with low minimums and weekly payouts.
• Time-boxing: Cap platform testing at 90 minutes each before deciding to keep or drop.

Common mistakes and fast fixes

• Pay-to-join traps. Fix: decline immediately — legitimate sites do not charge entry fees.
• Ignoring thresholds/fees. Fix: factor minimum cash-out and fees into the Rate Calculator.
• Vague deliverables. Fix: request written deliverable, deadline, and payout terms before starting.
• No tracking. Fix: log Minutes and Payout for each task; review weekly.
• Mixing accounts. Fix: separate a dedicated gig email to keep confirmations and payouts clean.

7-day action plan

1. Day 1: Set floor and max task time. Run Shortlist prompt. Pick top 3 platforms with low cash-out thresholds.
2. Day 2: Create two 35–40 word pitches via the Pitch Generator. Set up your spreadsheet. Verify payout method on each platform.
3. Day 3: Apply to 8–10 gigs across the top 3 platforms. Use the Filter prompt on each listing first.
4. Day 4: Complete 2–3 small tasks. Log Minutes and Payout. Note any screen-outs.
5. Day 5: Re-run the Rate Calculator on new opportunities. Decline anything below your floor after adjustments.
6. Day 6: Send follow-ups on pending reviews or payouts. Apply to 4–6 more gigs on the highest-performing platform.
7. Day 7: Review KPIs. Keep 1–2 platforms ≥ your floor. Drop the rest. Plan next week’s volume on winners only.

Result to aim for in 2 weeks: one reliable platform delivering steady tasks at or above your hourly floor, with predictable payouts and minimal screen-outs — proven by your own numbers.

Good point: keeping the system simple (tags + highlights) makes adoption and ROI far easier — especially for non-technical teams.

Here’s a compact, actionable plan to build a reliable research repository using AI so you can find insights fast and measure outcomes.

Why this matters: Without structure, research is unusable. A lightweight repo gives you repeatable discovery, faster decisions, and fewer duplicate efforts.

Short lesson from practice: start with a single storage source, a small controlled tag list, and an AI step that auto-summarizes and suggests tags. That combination delivers immediate retrieval improvements without heavy engineering.

1. What you’ll need
   1. A notes/repo app that supports tags and highlights (example options: Notion, Obsidian, or Google Drive + a simple index).
   2. A way to capture highlights (browser or PDF highlighter that exports notes).
   3. An AI service to summarize and propose tags (cloud model or app with built-in AI).
   4. Optional: an automation tool (Zapier/Make) to connect capture → repo → AI.
2. How to build it (step-by-step)
   1. Choose your repo and create a folder/space called Research.
   2. Define 8–12 controlled tags (topics, client, market, status). Keep names short and consistent.
   3. Capture: when you read, highlight and save the excerpt + source link into one file per item (title, date, source).
   4. Ingest: run an AI step that generates a 2–3 sentence summary, 3 suggested tags, and a 1-line “why this matters” note; attach to the item.
   5. Search: use the repo’s search — or a simple vector search if available—for question-based retrieval (query + context returns best matches).
   6. Review monthly: prune tags, merge duplicates, archive stale items.

Copy-paste AI prompt (use as-is in your AI tool):

“Summarize the following excerpt in 2–3 sentences, list 3 concise tags from this controlled vocabulary: [list your tags], and provide one sentence on why this is relevant to a product/market decision. Excerpt: [paste excerpt]. Source: [URL or title].”

Key metrics to track

• Items added per week
• Tag coverage (% items with ≥1 controlled tag)
• Average retrieval time (how long to find an answer)
• Search success rate (percentage of queries that return useful results)
• Duplicate rate (items merged per month)

Common mistakes & fixes

• Over-tagging: fix by limiting to 8–12 tags and enforcing one primary tag per item.
• Inconsistent naming: fix with a short naming convention doc and occasional cleanup.
• Ignoring metadata: always capture source and date — makes verification and trust possible.
• Relying only on AI: use AI for enrichment, not for final decisions — human review matters.

1-week action plan (practical)

1. Day 1: Pick your repo and create Research space + tag list.
2. Day 2: Install highlight tool and capture 5 recent items into the repo.
3. Day 3: Run the AI prompt above on those 5 items; attach outputs.
4. Day 4: Test retrieval with 5 real queries; note success rate.
5. Day 5: Adjust tags and naming for clarity; merge obvious duplicates.
6. Day 6: Automate one repeatable step (e.g., highlight → repo entry) if possible.
7. Day 7: Review metrics and set monthly maintenance reminder.

Ready to implement this week? Tell me which repo you plan to use and I’ll give you a tailored setup sequence and the exact tag list to start with.

Your move.

— Aaron

Yes — that pattern (one idea per slide; title + 3 bullets + one-line note) is the leverage point. Here’s a faster, tighter version with a couple of pro moves to eliminate formatting friction and keep your slides within a clear “slide budget.”

5‑minute quick win: Paste the prompt below into your AI tool with your notes. You’ll get a clean, ready-to-paste slide skeleton that respects word counts and timing.

Copy-paste AI prompt (use as-is)

Turn the following lesson notes into a presentation outline for an audience aged 40+. Output exactly 6 slides separated by lines of three dashes (—). For each slide, provide: Title (Title Case), Three bullets (6–8 words each, sentence case), One sentence speaker note (max 18 words), Two image keywords, Suggested slide duration in seconds. Keep language plain, friendly, and specific. Total talk time target: 7 minutes. Notes: [PASTE YOUR NOTES]

Problem: Most people lose time formatting, over-write bullets, and exceed their talk time. The result: crowded slides and rushed delivery.

Why it matters: A consistent slide budget + structured AI output cuts build time by half, improves attention, and makes delivery calmer and clearer.

What works (lesson learned): Two-pass prompting with constraints wins. Pass 1 creates a tight skeleton. Pass 2 adjusts tone, examples, and accuracy. Then import to slides in one go.

Steps (from notes to deck)

1. Set your slide budget (1 min): Choose total talk time. Rule of thumb: 60–75 seconds per slide. Example: 7 minutes → 6 slides.
2. Generate the skeleton (3–5 min): Use the prompt above. Expect: 6 tidy slide blocks, each with 3 short bullets, one speaker note, image keywords, and timing.
3. Voice & accuracy pass (5–10 min): Run this follow-up prompt on the AI output: “Rewrite bullets in plain language for adults 40+, swap any jargon, add one local example in each speaker note, keep word counts the same.” Quick fact-check one claim.
4. Import fast (5–10 min): Copy Titles and bullets into your slide editor. Pick one clean theme, large fonts (Title 36–44pt, Bullets 24–28pt), high contrast. Add one image per slide using the provided keywords.
5. Rehearse and trim (10 min): Read notes aloud. If you exceed time, remove the weakest bullet, not the whole slide.

Insider trick: frictionless import

• Paste each slide’s Title + bullets into a blank slide (Title and Content layout). This is faster than designing first.
• Use one visual style across all slides (e.g., “simple flat icon, high contrast”). Your image keywords already cue this.
• Keep bullets visually scannable: one line each; avoid wrapping.

Premium prompt (polish pass)

Audit and tighten this slide outline. Enforce: 3 bullets per slide, 6–8 words each; remove filler words; convert vague verbs to specific ones; ensure every speaker note includes one practical example or question. Flag any bullet exceeding 8 words and rewrite it shorter. Return the revised slides using the same format.

What to expect: 10–15 minutes to a clean outline; 15–25 minutes to build slides and visuals; 10 minutes to rehearse. Total: ~40–50 minutes for a 6-slide lesson.

Metrics to track (results & KPIs)

• Time to first draft (target: <15 minutes)
• Total build time to delivery-ready (target: <50 minutes)
• Slides per 10 minutes of talk (target: 7–10)
• Average words per slide (target: <20 total)
• % slides with one visual (target: 100%)
• Rehearsal time variance vs plan (target: ±10%)
• Learner engagement proxy: number of questions or a one-question post-session rating

Common mistakes & fixes

• Bullets too long — Fix: “Compress each bullet to 6–8 words; keep verb first.”
• Generic images — Fix: Add context words to keywords (e.g., “bedtime routine, no screens, warm light”).
• Over-stuffed slides — Fix: Move extra detail to the speaker note; never exceed 3 bullets.
• Inconsistent tone — Fix: “Rewrite for adults 40+: clear, respectful, zero slang.”
• Time overrun — Fix: Cut one bullet per slide first; don’t read notes verbatim.

1‑week action plan

1. Day 1: Pick one lesson. Run the skeleton prompt. Set slide budget.
2. Day 2: Voice & accuracy pass; add one local example per slide.
3. Day 3: Build slides with one clean theme; add images via keywords.
4. Day 4: Rehearse with a timer; trim to hit time.
5. Day 5: Deliver to a small group; collect one-line feedback.
6. Day 6: Apply feedback; save this deck as your reusable template.
7. Day 7: Repeat process on a second lesson; aim to beat your build time by 20%.

Bonus: copy-paste prompt for images

For each slide title and bullets below, suggest one image concept that is simple, high-contrast, and context-specific. Return: Slide number, Image concept (7–10 words), Alt text (under 12 words), and a short keyword string for search.

Pick one lesson and run the skeleton prompt now. The structure does the heavy lifting; you supply the clarity and examples that make it stick.

Sharp point: the checklist ritual is the guardrail that keeps teams honest. Now let’s bolt on an operational wrapper that turns it into measurable results and fewer escalations.

Problem: Plain-English-to-SQL works until ambiguity, stale schemas, or over-broad queries sneak through. That’s where run-time surprises, slow dashboards, and audit anxiety come from.

Why it matters: A predictable, enforced path from request to safe execution cuts cycle time and risk simultaneously. That’s the difference between a neat demo and a dependable internal service.

Lesson from the field: Treat SQL generation like a product. Use a contract, a policy file, and a test harness. Your checklist executes the routine; the wrapper catches drift and keeps quality high.

1. Stand up a “safe layer” the model can’t hurt
   • Create approved views that hide sensitive columns and enforce row filters. Name them plainly (e.g., sales_orders_public, employees_public).
   • Publish a synonyms map (“customers” → accounts, “revenue” → net_sales) so the model resolves business terms to columns consistently.
   • Set DB defaults: statement_timeout, read-only role, max_rows caps via LIMIT injection policy.
2. Use a generation contract (not free-form text)
   • Require structured output: query, parameters, risks, and a tiny test case. That’s machine-checkable and reviewable.
   • Enforce explicit columns, parameter placeholders, and explicit JOINs. Reject anything else automatically.
3. Automate checks before sandbox
   • Static policy: allowlist views/tables, banned keywords (DROP/TRUNCATE/ALTER/DELETE), mandatory LIMIT, and no SELECT *.
   • Parser/linter: validate dialect, parameters present ($1/$2 or ?), and join conditions exist for multi-table queries.
4. Sandbox, then promote with evidence
   • Run in read-only sandbox with EXPLAIN (analyze off). Capture plan shape, estimated rows, and indexes used.
   • Auto-annotate the query with a short performance note (e.g., “uses idx_orders_created_at; est rows 8,432”).
   • Only then convert to a prepared statement with least-privilege creds; log SQL text, params, duration, row count.
5. Maintain a golden test suite
   • Keep 15–25 common requests with expected SQL/shape. Run them nightly against the latest prompt + schema to catch regressions.
   • Flag drift: schema mismatches, slower P95 runtime, or changed result cardinality >10% without schema change notes.
6. Close the loop
   • When a query is edited by humans (joins, filters, indexes suggested), feed that correction into the synonyms map and prompt hints.
   • Review weekly: top failures, slow-query offenders, and vocabulary that confused the model.

Copy-paste prompt (contract style)

“You are an expert SQL generator. Output must be JSON with keys: dialect, sql, parameters, clarifications, risks, test_params, expected_result_shape. Rules: 1) Dialect = PostgreSQL. 2) Use $1, $2 parameters only; do not inline values. 3) Only use approved objects: [list views/tables]. 4) No destructive statements (DROP, TRUNCATE, DELETE, UPDATE, ALTER). 5) No SELECT *; list columns explicitly. 6) Include LIMIT $N for top-level SELECT unless request specifies an exact LIMIT. 7) Use explicit JOINs with ON conditions. 8) If the request is ambiguous, populate clarifications with specific yes/no questions and return no SQL. Inputs: Schema: [paste]. Synonyms: [paste]. User request: [paste]. Return only the JSON object, no prose.”

What you’ll need: approved views, synonyms map, linter/parser, policy file with allowlist + banned terms, read-only sandbox or replica, logging destination, and least-privilege credentials.

KPIs and targets

• First-pass acceptance rate (passes linter + sandbox): target ≥ 90% within 2 weeks; ≥ 95% by week 4.
• Unsafe-command rejection rate: target ≤ 1% of generations.
• Schema mismatch rate (unknown columns/tables): target ≤ 0.5% after synonyms rollout.
• P95 sandbox runtime for accepted queries: target ≤ 2s for filtered queries; ≤ 5s for aggregates.
• Time-to-query (request to safe execution): target median ≤ 5 minutes.
• Cost per accepted query (model + compute): baseline now; optimize 20–30% via few-shot examples and shorter context.

Common mistakes and fast fixes

• Ambiguous business terms (“sales” vs “net_sales”): fix with the synonyms map and examples in the prompt.
• Unbounded scans: enforce mandatory LIMIT and date filters in the policy; reject if missing.
• Timezone/date surprises: require explicit timezone and date boundaries in requests; include in contract as risks if unclear.
• Stale schema: re-export schema nightly; version-stamp the prompt inputs and log version with each query.
• SELECT *: linter auto-reject; ask the model to regenerate with explicit columns.

One-week plan (clear deliverables)

1. Day 1: Build approved views for 3–5 core tables and export fresh schema. Create synonyms map for top 30 business terms.
2. Day 2: Implement the contract-style prompt and policy checks (allowlist, banned terms, mandatory LIMIT, parameterization).
3. Day 3: Wire parser/linter and sandbox execution with EXPLAIN capture. Set statement_timeout and read-only role.
4. Day 4: Assemble 15 golden requests with expected outputs. Run baseline and record KPIs.
5. Day 5: Triage failures; update synonyms and add 3 few-shot examples to the prompt. Re-run tests; aim ≥ 90% pass.
6. Day 6: Add logging (SQL, params, runtime, row count, schema version). Create a simple dashboard for KPIs.
7. Day 7: Policy hardening: LIMIT enforcement, index hints allowed, regression run overnight; set weekly review cadence.

What to expect: With the contract + allowlist + golden tests, you’ll move from ad hoc wins to predictable >90% first-pass safe queries, sub-5-minute cycle time, and auditable execution trails.

Your move.

Stop chasing. Start collecting. The fastest way to lift cash flow is a disciplined dunning system: segmented reminders, one-click payment, and AI that writes the right tone for the right client — every time.

Why this matters: If you invoice $50,000/month, cutting DSO from 45 to 30 days unlocks roughly $25,000 in working capital without new sales. That’s payroll, inventory, or ad spend back in your hands.

Lesson from the field: The gains come from three levers: 1) zero-friction payment links, 2) a progressive reminder “waterfall,” 3) segmentation (VIP vs. chronic late). AI amplifies #2 and #3 so every message is short, precise, and appropriate.

What you’ll need

• Accounting tool with online payments enabled (QuickBooks, Xero, Wave)
• Payment rails: card + bank transfer (Stripe/PayPal/bank link)
• Automation: built-in workflows, Zapier, or Make
• A shared inbox or CRM to log all reminders
• A simple metrics sheet (columns listed below)

Build the system (practical, low-risk)

1. Segment customers
   • On-time: paid the last 3 invoices <= 3 days late.
   • Watchlist: 2+ invoices >7 days late in last 6 months.
   • VIP: high value or strategic; softer tone, longer grace.
2. Set payment friction to zero
   • Add a big “Pay Now” button and a plain link on every invoice and email.
   • Enable both card and bank transfer; allow partial payments when helpful.
   • Create a late fee item (apply after policy grace period). Clarify terms in the footer.
3. Define the reminder waterfall
   • Day 0: Friendly reminder + link.
   • Day 8: Firm nudge, offer help or plan.
   • Day 22: Final notice, state late fee/next steps.
   • Day 30+ (if needed): Task for a call; pause future services until paid.
4. Automation wiring (Zapier/Make or built-in)
   • Trigger: Invoice created → send Day 0 email; log to invoice timeline.
   • Wait/check: If unpaid at +8 days → send Day 8 variant based on segment (On-time, Watchlist, VIP).
   • Wait/check: If unpaid at +22 days → send final notice; create follow-up task in your calendar/CRM.
   • Payment received: Immediately stop reminders; send receipt/thank you; log outcome.
   • Partial payment: Calculate balance; schedule adjusted reminder for remaining amount.
   • Bounced email: Fail over to SMS (short version) and flag for manual review.
5. Smart retries for failed payments
   • Enable card “smart retries” in your payment processor and time reminder emails to land shortly after a retry.
   • For bank transfers, wait 3–5 business days before escalating (settlement window).
6. Exception rules (keep goodwill)
   • Invoices > $5,000 or VIP: manual review before final notice; offer a 2–3 part payment plan.
   • First-time late payer: waive late fee once; note it in the CRM.

Insider templates that convert (tight and clear):

• Subject ideas: “Quick nudge on Invoice #{InvoiceNumber}”, “2-minute payment link for #{InvoiceNumber}”, “Avoid late fee on #{InvoiceNumber}”.
• Line to add at the top: “It takes under 2 minutes to pay here: {PaymentLink}.”
• Attach the PDF and include the link — some clients forward PDFs internally, others click links.

Robust AI prompts (copy-paste)

Prompt 1 — segmented reminder with right tone:

“Act as an accounts receivable specialist. Draft a short reminder for {Segment} client about invoice #{InvoiceNumber} for {AmountDue}, due {DueDate}. Include: 1) a clear one-click payment link {PaymentLink}, 2) a friendly line for Day 0 OR a firm line for Day 8 OR a final notice line for Day 22+, 3) an offer of a payment plan if appropriate, 4) under 110 words, 5) subject line options. Output email body and a one-line SMS variant.”

Prompt 2 — partial payment and disputes:

“Summarize this invoice status: total {AmountDue}, paid {AmountPaid}, balance {Balance}, notes: {Notes}. Write a polite, precise email that confirms the balance, lists acceptable payment options, and proposes two payment plan choices with dates. Keep under 120 words, include {PaymentLink}, and add a short call script for our team if the client requests a hold.”

Metrics to track (weekly)

• DSO and median days late (goal: -20–40% in 60 days)
• % invoices paid on time (goal: +15–30%)
• Reminder efficiency: % paid within 48 hours of each send
• Open and link-click rates by segment (On-time/Watchlist/VIP)
• % escalated to final notice and % requiring manual calls
• Time spent on collections (target: -70% vs. baseline)

Common mistakes and quick fixes

• Generic tone for everyone — Fix: use segment-based variants and AI to tailor tone.
• Payment link buried — Fix: place the link/button top and bottom; add a plain URL.
• No path for partial payments — Fix: enable partials and auto-calculate remaining balance in reminders.
• Bounced emails unnoticed — Fix: automation step to flag bounces and send SMS fallback.
• Timezone mismatch — Fix: schedule sends in the client’s business hours.

Your one-week rollout

1. Day 1: Enable online payments; add a large payment button and plain link to the invoice template. Create the late-fee item (do not apply yet).
2. Day 2: Tag customers into segments (On-time, Watchlist, VIP). Prepare a test invoice per segment.
3. Day 3: Build automation: Day 0/8/22 sends, stop-on-payment, partial-payment branch, bounce-to-SMS, log all actions.
4. Day 4: Generate templates via Prompt 1; create shorter VIP variants. Send tests to yourself and two real clients (with small balances).
5. Day 5: Turn on smart retries in your payment processor. Validate that paid invoices immediately halt reminders.
6. Day 6: Create a 1-page SOP: exceptions, when to waive fees, how to offer a plan. Assign call tasks for Day 30+ cases.
7. Day 7: Go live for all new invoices. Start the metrics sheet with columns: Client, Invoice#, Amount, Issue Date, Due Date, Segment, Days Late, Messages Sent, Opens, Clicks, Paid Date, Payment Method, Late Fee (Y/N), Notes.

What to expect: Within 30–60 days, fewer final notices, faster pays after Day 0 and Day 8 messages, and reclaimed hours weekly. Keep tuning cadence and tone by segment; the compounding effect is real.

Your move.

Good call — including a sensitivity reader is the single most practical step you can add to catch lived‑experience issues AI and editors miss. I’ll build on that with a concise, results‑focused workflow you can apply this week.

The problem

AI produces fast, broadly correct gender‑neutral drafts, but it routinely flattens voice or erases plot‑relevant identity. Left unchecked, that creates rework, loss of nuance, and potential harm.

Why it matters

Speed without control wastes time. Get drafts to 80% ready with AI, then use a short human loop to protect character, tone, and cultural context — and measure the outcome.

Do / Do not checklist

• Do work in 300–500 word chunks per pass.
• Do maintain a one‑page style sheet (pronouns, job swaps, must‑keep identity notes).
• Do include an editor + at least one sensitivity reader for scenes with identity or cultural signals.
• Do version every pass (v1, v2, v3).
• Do not accept AI output as final on identity or tone.
• Do not over‑neutralize to remove character texture.

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

1. What you’ll need: one scene (300–500 words), one‑page style sheet, AI chat/editor, editor, sensitivity reader, versioned file folder.
2. How to do it:
   1. Run the scene through the AI with the prompt below; ask for a changelog of swaps.
   2. Read output twice: once for voice/subtext, once for reference consistency (pronouns/names).
   3. Make two targeted human edits: restore voice or preserve any plot‑critical identity lines.
   4. Send scene + changelog to editor and sensitivity reader; apply one round of feedback.
   5. Final consistency pass; save as next version.
3. What to expect: AI delivers a 60–80% usable draft in minutes; plan 15–45 minutes human review per scene.

Metrics to track (KPIs)

• AI usability rate: % of lines kept unchanged after human review.
• Review time per scene (minutes).
• Number of sensitivity flags per scene.
• Revision rollback rate: % of AI changes reverted.
• Sensitivity reader satisfaction (1–5) after final pass.

Common mistakes & fixes

• Over‑neutralizing: characters lose texture. Fix: keep any trait that informs plot or motivation.
• Pronoun drift: mixed references. Fix: run a single pronoun consistency pass and ask AI to list all pronouns used.
• Erasing culture: removed meaningful context. Fix: flag for sensitivity reader before changing.

Worked example

Original: “The manager called him over and patted his shoulder, proud of his progress.”

Neutral rewrite A: “The manager called them over and patted their shoulder, proud of the progress.”

Neutral rewrite B (preserving tone): “The manager signaled them over and offered a firm, proud clap on the shoulder.”

Why B works: swaps pronouns and keeps the tactile warmth without assuming gender; note the line if familial culture or gender is plot‑relevant.

Copy‑paste AI prompt (use as‑is)

Rewrite the following scene to be inclusive and gender‑neutral while preserving tone, character intent, and all plot‑critical details. Replace gendered job titles and pronouns with neutral alternatives where appropriate. For any line that depends on gender or cultural context, provide two alternate phrasings and mark it for human review. Output the rewritten scene, then a short changelog listing each pronoun/title swap and one sentence explaining why it changed, and finally list lines that should be reviewed by a sensitivity reader.

One‑week action plan

1. Day 1: Pick 2 scenes (300–500 words). Create or update the one‑page style sheet.
2. Day 2: Run AI prompt on scene A; do quick human pass; save v1.
3. Day 3: Send v1 to editor + sensitivity reader; collect feedback.
4. Day 4: Apply feedback; run consistency pass; save v2.
5. Day 5: Run same process for scene B; compare metrics (review time, AI usability rate).
6. Day 6–7: Consolidate lessons, update style sheet, plan next 10 scenes with KPI targets.

Keep it lean: AI gives speed, humans give judgment. Measure the gap and shrink it each week. Your move.