aaron

Turn Sunday into a 20‑minute executive ops review powered by AI. Output by 9am Monday: a one‑page Week Playbook, three booked focus blocks, and two tiny wins queued to start fast.

The issue: Monday drag comes from unclear outcomes, hidden conflicts, and fuzzy prep. Why it matters: when AI crystallizes your top three outcomes and preps the first actions, you reduce decision fatigue and protect time for the work that moves revenue, delivery, or stakeholder trust.

Insider moves that compound: (1) two-pass AI (summary → challenge/risks) gives you clarity and coverage; (2) 1.5x focus rule (block 1.5× your estimate) protects execution; (3) pre-draft key emails on Sunday to remove Monday friction.

What you’ll need

• a calendar (next 7–10 days)
• a notes app with a doc titled “Week Playbook”
• 15–20 minutes on Sunday
• optional: AI assistant (any) to read your pasted calendar and message summaries

Copy-paste AI prompt (robust)

“You are my Sunday planning analyst. Here are my next-week calendar items and key message summaries: [paste events with times, locations, travel, deadlines, and 5–10 important emails]. My preferences: [best hours], [meeting-heavy vs maker time], [no calls before X], [travel buffer: 30/45/60 min], [tools I use]. Do the following and return a concise one-page plan:

1) Identify the Top 3 outcomes for the week with success criteria in one sentence each.2) Map the critical path for each (2–3 concrete next steps, owner, due date).3) Flag conflicts, dependencies, and missing prep (docs, people, data).4) Draft meeting prep checklists (bullets, 5 items max per meeting).5) Suggest 30–60 minute focus blocks for the critical steps using my energy windows and the 1.5x rule. Include travel/transition buffers.6) Write 2 pre-drafted emails/notes I can send Monday to unblock work.7) List two 20-minute Monday wins to build momentum.8) Risks + if/then contingencies (short).”

Variants (use when time is tight)

• 90-second quick pass: “From this calendar, give me only Top 3 outcomes, one next step each, and two Monday wins.”
• Deep prep (5 minutes): “Add a 6-slide outline for my biggest meeting and three questions to pressure-test the plan.”
• Midweek tune-up (Wednesday): “Update my Week Playbook based on these changes. Reprioritize Top 3 and adjust blocks.”
• Travel heavy week: “Optimize with 15-minute email bursts and dictate-on-the-go prep. Add buffer math.”

Step-by-step — 20-minute Sunday run

1. 3 min — Dump. List upcoming outcomes you care about (not tasks). Example: “Sign vendor SOW,” “Deliver Q4 hiring plan,” “Board pre-brief alignment.”
2. 7 min — AI pass. Paste your calendar/messages into the prompt. Skim the output and highlight: Top 3 outcomes, first next steps, and suggested focus blocks.
3. 5 min — Lock the calendar. Block three focus windows (30–60 minutes each) in your best-energy slots. Apply the 1.5x rule and add buffers around meetings with travel.
4. 3 min — Ship friction removers. Send one pre-drafted email to unblock work and schedule one quick alignment call. Add two tiny Monday wins at the top of your to-do list.
5. 2 min — Save the Playbook. Paste the AI output into your “Week Playbook” note. Pin it. Done.

What to expect

• Less Monday context switching; first 90 minutes run on rails.
• Clear success tests for the week so it’s obvious what to say no to.
• Fewer last-minute scrambles because dependencies are flagged early.

Metrics (track weekly)

• On-time outcomes %: Top 3 delivered by Friday. Target: 80%+.
• Focus time booked: Minutes blocked for Top 3. Target: 180–300 min/week.
• Plan-to-do ratio: Blocks kept vs scheduled. Target: 70%+.
• Monday friction: 1–5 self-score at 11am. Target: ≤2 by week 3.
• Prep lead time: Hours between prep checklist completion and meeting. Target: ≥24h.

Mistakes to avoid (and fixes)

• Letting AI decide your goals. Fix: you pick outcomes; AI supports sequencing and prep.
• Vague tasks. Fix: one action, one owner, one deadline. Rewrite until it fits in 30–60 minutes.
• No buffers. Fix: add 10–15 minutes between meetings; 30–60 for travel.
• Overbooking mornings. Fix: protect only three blocks total; move the rest to midweek.
• Skipping review. Fix: 3-minute nightly glance at the Playbook to adjust.

1-week action plan

1. Today (5 min): Create a “Week Playbook” note with headers: Top 3 outcomes, Critical path, Prep checklists, Focus blocks, Risks, Monday wins.
2. Sunday (20 min): Run the robust prompt, book three focus blocks, queue two pre-drafted emails.
3. Monday 8:30am (10 min): Execute the two tiny wins, send one unblocker email, start first block.
4. Wednesday (7 min): Midweek tune-up prompt; re-block time if needed.
5. Friday (5 min): Score metrics; note one improvement for next Sunday.

Keep it tight, keep it repeatable, let AI handle the heavy lift on prep and sequencing. You own the outcomes.

Your move.

Quick win (5 minutes): Export last 7 days of leads, add a column time_to_submit_sec (submit_time – first_touch_time), filter for values <= 5 seconds — mark those as suspect. That single filter usually cuts noise by 20–40% instantly.

Problem: Spam leads and low-quality traffic inflate costs, waste sales time, and skew campaign data. Small teams lose deals because reps chase noise.

Why this matters: Cleaning leads raises lead-to-opportunity conversion, reduces wasted outreach, and sharpens campaign ROI. Even a 10% improvement in lead quality can lift revenue materially.

What I’ve learned: Rules catch the obvious stuff; AI finds the subtle patterns. Use both, keep humans in the loop during tuning, and measure aggressively.

What you’ll need

• Lead CSV: timestamp, first_touch_time, masked_email, email_domain, ip_hash, referrer, user_agent, time_to_submit_sec, pages_viewed, utm_source.
• Google Sheets or Excel.
• An AI chat assistant (or an API you can call later).

Step-by-step (do this this week)

1. Export 2 weeks of leads (200–500 rows). Mask emails/phones (jan***@domain.com).
2. Add helper columns: email_domain, time_to_submit_sec, pages_viewed, submissions_per_ip (rolling 1-hour window), repeat_email_count, user_agent_flag (empty/known-bot).
3. Apply deterministic rules to tag obvious spam: disposable domains, time_to_submit_sec <=5s, submissions_per_ip >=5 in 1hr, blank/referrer mismatch, ua flagged.
4. Sample 50–100 anonymized rows (preferably balanced across labels) and run the AI prompt below to surface patterns and score each row.
5. Review flagged rows: accept/reject labels; update rule thresholds and whitelist domains as you confirm real users.
6. Automate: set CRM to tag leads with score >80 as likely-spam, 40–80 as review, <40 as go. Route review queue to a rep for 24–48 hour checks.

Copy-paste AI prompt (anonymize first):

I have a 75-row anonymized CSV with columns: timestamp, email_domain, masked_email, ip_hash, referrer, user_agent, time_to_submit_sec, pages_viewed, utm_source. Return a CSV-style list with: label (clean/likely-spam/low-quality), reason (one short sentence), score (0-100). Then list the top 3 patterns you see and recommend 3 simple spreadsheet rule thresholds I can implement to immediately cut false positives.

Metrics to track (weekly)

• Spam rate (% leads labeled likely-spam)
• False positive rate (% flagged as spam but confirmed real)
• Manual review load (leads/day in review queue)
• Lead-to-opportunity conversion (before vs after filtering)
• Time saved per rep (hours/week)

Common mistakes & fixes

• Too aggressive thresholds — fix: target 5–10% false positives, tune weekly.
• Pasting raw PII into public chat — fix: mask before you paste.
• Relying solely on AI scores — fix: combine rules + score + human review for mid-range cases.
• Ignoring campaign context — fix: keep UTM and landing page data in your sample to avoid blocking valid paid traffic.

1-week action plan

1. Day 1: Export 2 weeks, add helper columns, run the <=5s quick filter (mark results).
2. Day 2: Apply the deterministic rules and tag obvious spam.
3. Day 3: Prepare 50–100 anonymized rows and run the AI prompt above.
4. Day 4–5: Manually review flagged mid-scores, adjust thresholds, whitelist domains.
5. Day 6–7: Automate CRM tagging (score rules), measure metrics and report results.

Your move.

5-minute win: Paste your top 10 research questions into the prompt below. You’ll get a ranked list with impact, cost-to-learn, time-to-signal, and a simple “do next” for each. Share the top three with your decision-maker before lunch.

The problem: A long backlog hides the 2–3 questions that actually drive revenue, retention, or risk reduction. Opinions take over. Momentum dies.

Why this matters: Prioritizing by likely impact and time-to-signal turns research into decisions that move KPIs this quarter — not just insights that sound smart.

Lesson from the field: Adding two things — cost-to-learn and time-to-signal — doubled throughput in one team I advised. Same people, same tools, clearer choices. Exec buy-in went up because the top items were fast, cheap, and tied to a KPI.

1. What you’ll need
   • Your backlog (10–50 questions, one per line).
   • A spreadsheet with columns: question, impact, feasibility, confidence, weighted_score, time_to_signal_days, cost_to_learn, uncertainty_flag, recommendation.
   • Access to an AI assistant and 15 minutes with a decision owner.
2. How to do it (step-by-step)
   1. Set anchors (2 minutes): Pick one KPI to optimize (e.g., paid conversion, week-1 retention, cost-to-serve) and a time horizon (30–90 days). Note any hard constraints (no new data infra, budget cap).
   2. Run the AI pass (5 minutes): Use the prompt below to score Impact, Feasibility, Confidence; add time_to_signal (days to first learn) and cost_to_learn (rough dollars or team-days). AI returns a CSV you can paste straight into your sheet.
   3. Calculate a priority number (2 minutes): weighted_score = impact*0.5 + feasibility*0.3 + confidence*0.2. Then create speed_factor = if time_to_signal_days ≤ 14, add +1 to the priority; if ≤ 7, add +2. Final_priority = weighted_score + speed_factor.
   4. Segment the list (3 minutes):
      • Now: Final_priority ≥ 8 or time_to_signal ≤ 7 days.
      • Next: Final_priority 6–7.9.
      • Later: Everything else, unless uncertainty_flag is TRUE and cost_to_learn is low (these can be small probes).
   5. 15-minute review agenda: Present the top 5 with one-line rationale and a decision ask. Agree owners and start dates. Capture any swaps and why — that becomes your learning loop.
3. What to expect
   • A clean top 3–5 tied to a KPI, with clear next steps (A/B test, 5–8 user tests, log analysis, or “no further action”).
   • Faster starts: items with time_to_signal ≤ 7 days become immediate candidates.
   • Better trade-offs: high-impact but uncertain items get a cheap probe first, not a month-long study.

Copy-paste AI prompt (premium template)

“I will paste a numbered list of research questions and one target KPI. For each question, do the following and return a CSV: 1) Score Impact on the KPI (1–10), 2) Score Feasibility with typical resources (1–10), 3) Score Confidence based on existing evidence (1–10), 4) Estimate time_to_signal_days to get a directional answer, 5) Estimate cost_to_learn (team-days or $ rough order), 6) Set uncertainty_flag TRUE if evidence is thin and name what’s missing, 7) Recommend the next step (user interview / prototype / analytics / A/B test / no action). Use weights: Impact 50%, Feasibility 30%, Confidence 20% to compute weighted_score. Also compute final_priority = weighted_score + 2 if time_to_signal_days ≤ 7, +1 if ≤ 14, else +0. Include a two-sentence rationale and any strong assumptions. Columns: question, impact, feasibility, confidence, weighted_score, time_to_signal_days, cost_to_learn, uncertainty_flag, rationale, recommended_next_step, final_priority.”

Insider trick: calibrate the AI before scoring

Run two “anchor” questions you already know the outcome for (one high, one low). If the AI’s scores don’t match reality, tell it how to adjust (e.g., “increase weight on Feasibility for infra-heavy items”), then run your full list. This keeps scores grounded in your context.

Optional micro-prompt (calibration)

“Here are two anchor questions with known outcomes and why. Adjust your scoring guidelines so similar items receive comparable scores. Confirm the adjusted rules in 5 bullet points, then ask me to paste the full list.”

Metrics that prove this works

• Decision lead time: days from backlog to top-5 sign-off.
• Time-to-signal: days to first directional answer on top 2.
• Execution rate: % of top-5 started within 7 days.
• Decision impact: % of prioritized items that triggered a product/marketing change.
• Forecast accuracy: ratio of expected impact vs realized (aim to get within 20% after two cycles).

Mistakes and easy fixes

• Scores bunch at 7–8: Ask AI to normalize so the lowest item gets ~3 and the highest ~9; or force at least one 9 and one 3.
• Pet projects creep in: Require a one-line KPI link for any swap. No KPI, no swap.
• Feasibility optimism: Add a quick tech check by the implementer before finalizing the top 3.
• No learning loop: After each study, record the actual time_to_signal and impact to recalibrate the next scoring pass.

1-week action plan

1. Day 1: Pick your KPI and paste your questions into the prompt. Get the CSV and create your sheet.
2. Day 2: Calibrate with two anchors. Re-run the list if needed. Add speed bonuses and segment Now/Next/Later.
3. Day 3: 15-minute decision review. Lock the top 3, owners, and start dates.
4. Days 4–5: Launch 1–2 quick studies (≤7 days to signal). Log assumptions and expected outcomes.
5. Days 6–7: Capture first signals, update the sheet with actuals, and adjust any items in Next.

Make the backlog serve the KPI, not the other way around. Your move.

— Aaron Agius

Quick win (5 minutes): Write a one-line niche sentence now — who, age, main pain, and style. Example: “Women 35–55 who love houseplants and want sustainable, stylish kitchen linens.” Keep it; you’ll use it to generate ideas.

Nice point — tight constraints and short test cycles are exactly the two levers that turn AI output into revenue, not noise. I’ll add a results-first layer: concrete KPIs, a fast filtering checklist, and a one-week play to move from idea to signal.

The problem: AI spits useful concepts, but without rapid validation you waste time and money on ideas that look good on paper and don’t convert.

Why this matters: You need a repeatable, low-cost loop that turns AI suggestions into real customer signals — clicks, add-to-carts and purchases — so you invest only in winners.

Short lesson from practice: Constrain, test, measure. In dozens of small e-commerce launches the fastest discriminator was a 7–10 day paid boost: it separates interesting from sale-ready ideas faster than opinions.

1. What you’ll need
   1. Your one-line niche sentence.
   2. A constraints list (materials, retail price, production method, ship size).
   3. A spreadsheet for tracking: idea, CTR, add-to-cart rate, conversion, cost/unit.
   4. $50–$150 per idea for a 7–10 day test.
2. How to run it (step-by-step)
   1. Generate 20 ideas using the prompt below (30 minutes).
   2. Filter quickly: remove anything >3 production steps, trademarked, or >estimated cost limit (15 minutes).
   3. Create one hero mockup and one listing per top 3 ideas (photos + 3 title variants).
   4. Run a $50–$100 targeted boost per listing for 7–10 days.
   5. Evaluate using the metrics below and decide: scale, iterate, or drop.

Metrics to track (clear pass/fail)

• CTR on ad/listing: target >2%
• Add-to-cart rate: target >3%
• Conversion rate (view-to-sale): target >1% for new listings
• Cost per acquisition (CPA): must be below your margin-based threshold

Common mistakes & fixes

• Mistake: Running ads without a hero listing. Fix: One high-quality image and 3 tested titles.
• Mistake: Too many SKUs. Fix: Start with one hero SKU.
• Mistake: Ignoring early micro-metrics. Fix: Look at CTR and add-to-cart before obsessing about sales.
• Mistake: No production cost check. Fix: Estimate cost/unit before running promotion.

1-week action plan (exact)

1. Day 1: Write niche sentence and constraints (10 minutes). Run the AI prompt below to create 20 ideas (30 minutes).
2. Day 2: Filter to top 3 (15 minutes). Order or create mockups for each.
3. Day 3–4: Build 3 listings with one hero image and 3 title variants (2 hours).
4. Day 5–11: Run $50 boost per listing and record CTR, add-to-cart, conversion daily.
5. Day 12: 30-minute review session. Keep or scale winners; drop or iterate losers.

Copy-paste AI prompt (use as-is)

Act as an Etsy/Shopify product researcher. Target customer: [paste your one-line niche sentence]. Constraints: materials = [e.g., linen/organic cotton]; retail price $[min]–$[max]; production = [POD/small-batch]; shipping size = [small/medium]; no trademarked phrases. Generate 20 product ideas. For each idea provide: 1-sentence description, 3 short keyword-rich title options, estimated cost to produce per unit, suggested retail price, difficulty score 1–5, and one risk flag (manufacturing, shipping, IP).

Your move.

Good call on the 1‑page codebook and timeboxed reviews — that low‑friction routine is the difference between a live process and chaos.

The real problem most small teams face: speed without trust. AI can tag at scale, but without clear KPIs and a tight human‑in‑the‑loop routine you trade speed for noisy outputs. That wastes stakeholder time and kills adoption.

Why this matters: reliable qualitative outputs = faster decisions, fewer follow‑up interviews, and lower cost per insight. You should be measuring that improvement, not just saying the AI saved time.

Quick lesson from the field: teams who pilot 5–10% of data, set a 0.65–0.75 confidence gate, and run 20–30 minute daily review blocks stabilize review to ~15% of segments within two iterations. That’s repeatable, auditable, and fast.

Step-by-step implementation (what you’ll need & how to do it)

1. What you’ll need
   1. Transcripts (plain text or CSV) in one folder.
   2. One‑page codebook (4–8 core codes + 1 example each).
   3. AI tagging tool that returns assigned_code(s) + confidence (cloud or local).
   4. Spreadsheet DB: id, segment, ai_codes, confidence, triage, reviewer, note.
   5. One reviewer + one recon owner (can be same person).
2. How to run it
   1. Pilot 5–10%: run AI, review every label, log errors and update codebook.
   2. Set triage: confidence >=0.70 = green (auto‑accept); 0.50–0.69 = yellow (review); <0.50 = red (escalate).
   3. Run full pass; reviewers work 20–30 minute blocks on yellow/red items only.
   4. Weekly 20–30 minute reconciliation: record changes in one‑line audit log and version the codebook.
3. What to expect
   1. Week 1 review rate ~15–30%.
   2. After 1–2 reconciliation rounds review rate drops toward 10–15% and consistency improves.

Metrics to track

• % segments auto‑accepted (target 70% after two iterations).
• Human review rate (start 15–30%, target 10–15%).
• Inter‑rater agreement (human vs human / AI vs human) — aim 80%+.
• Hands‑on coding time per interview — aim to cut 40–70% vs manual baseline.

Common mistakes & fixes

• Repeating errors: add a single‑line rule to the codebook and bulk reclassify matching segments.
• Overlapping codes: define primary vs secondary or allow multi‑code but set analysis priority.
• Confidence drift: lower threshold for pilot, raise once agreement hits target.

1‑week action plan

1. Day 1: Finalise one‑page codebook; pick 5–10% pilot.
2. Day 2: Run AI on pilot; export to spreadsheet.
3. Day 3: Full review of pilot; update codebook and log 3 common errors.
4. Day 4: Re‑run/adjust prompts; set confidence thresholds and triage colors.
5. Day 5: Run AI on full set; reviewers begin 20–30 minute review blocks.
6. Day 6: Finish flagged reviews; log disagreements.
7. Day 7: 20–30 minute reconciliation; version codebook and measure metrics.

Copy‑paste AI prompt (use as base)

You are a qualitative research assistant. Read the transcript segment below and assign one or more codes from this codebook: [list codes and one-line definitions]. Return a JSON array with fields: segment_id, assigned_codes, confidence_score (0-1), short_justification (one sentence). If unsure, set confidence_score < 0.70. Segment: “[paste transcript segment]”

Your move.

—Aaron

Quick win (under 5 minutes): Take one vague user story from your backlog and run the copy-paste prompt below — you’ll get a clean “As a… I want… so that…” plus 4–6 testable acceptance criteria you can paste into your ticket.

Good call in your post: using AI to draft stories is exactly where you get fast clarity — but only if you pair the draft with a simple validation loop.

The problem: user stories are often vague, bundling requirements and implementation details. That creates rework, longer cycle time, and failed tests.

Why it matters: clear stories cut dev and QA time, reduce UAT defects, and make stakeholder reviews fast. You should see measurable improvements in sprint predictability within two sprints.

My experience/lesson: I’ve used AI to draft hundreds of stories. The best outcomes came when the AI output was constrained (role, benefit, constraints) and reviewed via a 5-minute checklist before moving to dev.

1. What you’ll need: one-line feature brief, primary user role, constraints (security/performance), AI chat tool, one reviewer.
2. How to do it — step-by-step:
   1. Write a 1–2 sentence brief (example: “Save payment methods for returning customers”).
   2. Paste the prompt below into your AI chat and run it.
   3. Copy the user story and 4–6 ACs into the ticket. Run a 5-minute review: confirm “so that” outcome, split complex ACs, mark must-haves vs nice-to-haves.
   4. Create 1 ticket for the story and 2–3 subtasks for critical ACs (security/tokenization, delete flow, cross-device sync).

AI prompt (copy-paste)

Act as a product coach. Given this feature brief, write one clear user story in the format: “As a [role], I want [action], so that [benefit].” Then provide 5 acceptance criteria as short, testable Given/When/Then statements, list 4 edge cases, and give 4 manual test steps. Also tag each acceptance criterion as Must/Should/Could. Feature brief: “Allow customers to save payment methods for future purchases.” Constraints: PCI-compliant, allow delete, mobile+desktop, tokenization required.

Metrics to track

• Sprint acceptance rate (%) — target +15% in two sprints.
• Average ticket cycle time — target reduce by 20%.
• UAT/production defects tied to stories — target reduce by 30%.
• Time to review story (human validation) — target ≤5 minutes.

Mistakes & fixes

• Vague ACs — Fix: enforce Given/When/Then and Must/Should/Could tags.
• Bundled conditions — Fix: split into separate, testable ACs.
• Skipping edge cases — Fix: require at least 3 edge cases before mark Ready.
• Implementation language in ACs — Fix: make acceptance criteria implementation-agnostic.

1-week action plan

1. Day 1: Pick 3 highest-value vague stories and run the prompt for each.
2. Day 2: 5-minute review with a teammate; agree Must/Should/Could and split tasks.
3. Days 3–5: Track metrics; ship one story by end of week; record defects and review results in retro.

Your move.

Want consistent, fast qualitative coding without hiring a team? Small teams can get there by treating AI like a trained assistant — not a substitute.

The gap: Manual coding is slow and inconsistent. AI can accelerate tagging but will introduce errors if you hand off quality control.

Why it matters: Faster, repeatable insights mean quicker product decisions, cleaner reports for stakeholders, and lower cost per insight. If you don’t control quality, you’ll waste time fixing bad outputs.

Short lesson from the field: Start with a 1-page codebook, pilot 5–10% of your corpus, and set a clear human-review rule. Teams that do this drop hands-on coding time 40–70% and stabilize review to ~15% of items.

1. What you’ll need
   1. Transcripts (plain text or CSV) in one folder.
   2. One-page codebook: 2–10 codes with 1 example quote each.
   3. Low-cost AI (cloud or local) that can tag text and return a confidence score.
   4. A spreadsheet or simple database to store: transcript ID, segment, AI code(s), confidence, reviewer note.
   5. 1–2 reviewers for spot checks.
2. How to run it (step-by-step)
   1. Label pilot: run AI on 5–10% of interviews. Review every AI label in that pilot.
   2. Refine: update codebook with edge-case rules and example quotes based on pilot errors.
   3. Scale: run AI on full set, flag anything below confidence threshold (start 0.70) or multi-code outputs for human review.
   4. Reconcile weekly: 15–30 minute session to resolve disagreements and update codebook. Version the codebook.
   5. Iterate: after each reconciliation, re-run AI on failed patterns or add explicit rules to pre-filter segments.

Copy-paste AI prompt (use as the base for your model):

“You are a qualitative research assistant. Read the transcript segment below and assign one or more codes from this codebook: [list codes and one-line definitions]. Return a JSON array with fields: segment_id, assigned_codes, confidence_score (0-1), short_justification (1 sentence). If unsure, mark confidence_score below 0.70. Segment: “[paste transcript segment]””

Metrics to track

• % of segments auto-accepted (confidence >= threshold) — target: 70% within 2 iterations.
• Human review rate — starting target: 15–25%.
• Inter-rater agreement (human vs. AI or human vs. human) — target: 80%+.
• Hands-on coding time per interview — aim to cut 40–70% vs. manual.

Common mistakes & fixes

• Overlapping codes: add “primary/secondary” rules or allow multiple codes but prioritize one for analysis.
• Model drifts on jargon: add glossary entries to the codebook and retrain or add prompt examples.
• Low confidence clusters: create simple pre-filters (keyword rules) to route tricky segments to humans automatically.

1-week action plan

1. Day 1: Create 1-page codebook and gather 5–10% pilot transcripts.
2. Day 2: Run AI on pilot; export outputs into spreadsheet.
3. Day 3: Review pilot outputs, note errors, update codebook.
4. Day 4: Re-run AI on pilot patterns (or adjust prompts); set confidence threshold.
5. Day 5: Run AI on full set and flag low-confidence items.
6. Day 6: Review flagged items (one reviewer), log disagreements.
7. Day 7: 20–30 minute reconciliation; finalize codebook version 1 and measure metrics.

Your move.

Good point — keyboard-only checks catch what scanners miss. That’s the quick win that proves impact fast.

Problem: automated scanners give a list of issues but not prioritized, implementable fixes with selectors, code snippets, and acceptance tests. That gap leaves product teams with vague tickets and uncertain ROI.

Why it matters: fixing prioritized accessibility issues reduces legal risk, increases conversions for marginal users, and produces measurable score gains (Lighthouse/axe) you can report to stakeholders.

Experience takeaway: run scanner + AI + manual checks as a single workflow. The scanner finds the surface issues, AI converts them into developer-ready tickets, and manual QA verifies user-facing behavior.

1. What you’ll need
   • Automated scan export (Lighthouse or axe JSON).
   • 3 representative page screenshots and the HTML snippet or URL for each page.
   • Access to an AI assistant (internal or sanitized public model).
   • Basic QA tools: keyboard-only checklist and a screen-reader (NVDA/VoiceOver).
2. Step-by-step (one pass)
   1. Run scanner on top 5 pages; export JSON.
   2. Collect screenshots + the HTML of the highest-traffic page areas.
   3. Feed scan + HTML + screenshots to the AI prompt below to get a prioritized list (selectors, code fixes, estimates, acceptance tests).
   4. Create tickets for top 3 quick wins with acceptance tests from AI and assign dev time.
   5. Deploy quick wins, perform keyboard-only and screen-reader checks, then re-scan and record metrics.

Copy-paste AI prompt (use as-is)

Here is an accessibility scan JSON (paste after this line). Also attached: three screenshots and the HTML snippet for the key interaction area. Provide up to 12 prioritized fixes. For each fix include: issue title, severity (High/Med/Low), exact location (CSS selector or HTML snippet), plain-English explanation, step-by-step implementation instructions, one copyable code fix (HTML/CSS/JS) if applicable, estimated developer time (hours: low/med/high), and one acceptance test that a QA person can run. Mark the top 3 quick wins. Sanitize any sensitive data before pasting.

Metrics to track

• Issues found (total / High / Medium / Low).
• Pages remediated (% of top 10 pages).
• Lighthouse/axe score delta (before → after).
• Developer hours spent vs AI estimates.
• Accessibility-related support tickets.

Common mistakes & fixes

• Relying only on automated reports — fix: mandatory keyboard + screen-reader pass for each ticket.
• Vague tickets — fix: include selector, acceptance test, and code snippet from AI before dev starts.
• Pasting production secrets into public AI — fix: sanitize or use internal AI instance.

1. 1-week action plan
   1. Day 1: Run scans for top 10 pages; capture screenshots and HTML snippets.
   2. Day 2: Run the AI prompt per page; export prioritized fixes and code snippets.
   3. Day 3–4: Implement 5 quick wins (labels, alt text, focus order, contrast, form errors).
   4. Day 5: Manual QA on fixed flows; update tickets for remaining items with estimates.
   5. Day 6–7: Re-scan, report metrics, and schedule next sprint for high-severity items.

Your move.

Aaron