This question comes up in almost every AI PM interview loop right now.
How would you ensure the reliability of an AI chatbot?
It also shows up in other forms:
How would you write evals for our support bot?
Our chatbot makes things up. What would you do?
How do you know your LLM feature is ready to ship?
They're all the same question. The interviewer wants to see if you can take a fuzzy goal like make the AI good and turn it into something you can measure, use to make a launch decision, and improve every week.
Most candidates jump straight to a tool. They say they'll use LLM-as-a-judge and track accuracy. That names a tool. It doesn't answer the question.
In this post we'll do two things. First, we'll understand evals from scratch. Then we'll answer the question end to end, the way you'd say it in the room.
🎯 Want real AI PM interview questions solved like this one? Check out our flagship AI PM Course + Interview Prep. PMs at Google, Microsoft, Coinbase and others have taken it, and it's rated 4.9/5. Use code NYE27 for 40% OFF.
Why every company is asking this now
1. Every PM is about to own an AI feature.
A year ago, AI features belonged to a special team. Today almost every roadmap has one: a support bot, a search assistant, an auto-summary. If you're a PM, you'll own one soon, if you don't already.
AI features also break in a way normal features don't. Nobody touches the code, but the model provider ships an update, or users start asking something new, and quality drops. If you can't measure quality, you won't even know it happened.
2. Evals are the new spec.
For a normal feature, the PRD says what the feature should do, and QA checks it. For an AI feature, the spec is what a good answer looks like, and the eval set is how you write it down.
Engineers can build the eval pipeline. But they can't decide what a good refund reply looks like for your customers. That takes someone who knows the user and the business, which means the PM. Kevin Weil, who led product at OpenAI, has said that writing evals is becoming a core skill for product managers.
3. Everyone has the same models. Quality is the difference.
Your competitor can call the same GPT, Claude or Gemini API you do, so the model isn't your edge. Your edge is how fast you find where your product fails and fix it. Evals are how you do that.
Bottom line: evals aren't a niche topic for ML teams anymore. They're a core PM skill, and the interview is checking whether you have it.
Part 1: AI Evals from First Principles
Why normal testing doesn't work for AI
In normal software, the same input always gives the same output. You check it once and you're done. 2 + 2 should return 4, every time.
AI products break this in three ways.
The output changes every time. Ask the same question twice and you get two different answers.
There are many right answers. There are a hundred correct ways to tell a user their refund is on the way, so you can't just compare text.
Users can type anything. Any language, any mood, any typo. In India, a lot of it is Hinglish.
So the usual approach is to chat with the bot five times and ship if it looks fine. Teams call this a vibe check, and it tells you almost nothing. Five chats cover a tiny slice of what real users will send.
What an eval actually is
An eval has three parts:
Eval = Input + Output + Judgment
Input: a realistic user message, plus the data the bot had, like the order details and the refund policy.
Output: everything the bot did. That's the reply and the actions it took, like calling the refund tool.
Judgment: a fixed rule that says pass or fail, and gives the same result every time you run it.
Run this on 300 inputs and you get a score. Change the prompt, run it again, and compare. Swap the model, run it again, and compare.
That's all evals are. Everything else is detail.
Who does the judging
There are three kinds of graders.
Code. Simple checks written in Python. Is the refund amount below the item price? Did the bot pass the right order ID? Is there a phone number in the reply? Code is free and instant, but it only works for things with a clear right answer.
LLM judge. A second AI model grades the reply against a clear rubric. Use it for things code can't check, like whether every claim in the reply is backed by your refund policy. It's cheap and fast, but only as good as its rubric.
Human rater. Someone who knows the domain, like your support ops lead, marks the reply pass or fail. Humans are best at judgment calls, but they're slow and expensive, and two people often disagree.
Rule one: if code can check it, use code. It's free, fast, and never changes its mind.
For judgment calls, you'll use an LLM judge, because no human team can read 200K chats a day. But that raises a big question: how do you know the LLM judge is grading correctly?
You compare it with a human. That's the 2x2 below.
The 2x2: Human rater vs. LLM judge
Take a set of bot replies. Have your best human expert (say, your support ops lead) mark each one good or bad. Have the LLM judge grade the same replies. Every reply now lands in one of four boxes.
When they agree, you learn about your product.
Both say good → your product works. The prompt, the policy lookup and the tools are doing their job. Keep the case in your test set as a passing example, and move on.
Both say bad → your product is broken. Don't touch the eval, because the eval is right. Fix the product: the prompt, the knowledge base, or the tool logic. Then add the case to your test set so it never comes back.
When they disagree, you learn about your eval.
Human says good, LLM says bad → the judge is too strict. It's raising false alarms. Good releases get blocked, and soon the team stops trusting the evals. Fix the eval: loosen the rubric where it's too picky, and add this reply to the judge prompt as an example of a pass.
Human says bad, LLM says good → the judge is too lenient. This is the most dangerous box. Bad replies reach customers while your dashboard shows green. Fix the eval: tighten the rubric, and add this reply to the judge prompt as an example of a fail.
The rule: only trust an LLM judge when the two disagree boxes are small. If they're big, your scores are measuring the judge, not your product.
So where does each grader fit?
Code for anything with a clear right answer.
LLM judges for judgment calls at scale, once the 2x2 shows they agree with humans.
Humans for two jobs: labelling replies so you can check the judge, and personally reviewing the few highest-stakes chats, like allergy or legal complaints.
In the interview, say: I'd use code wherever there's a clear right answer and LLM judges for judgment calls. But I'd check every LLM judge against human labels using a 2x2. Where they agree, I learn about the product. Where they disagree, the judge is too strict or too lenient, and I fix the eval before I trust any score.
Offline and online evals
Offline evals run before you ship. You run the new version of the bot on a fixed set of test cases and compare its scores with the current version.
Online evals run after you ship. You grade a sample of real conversations every day.
Offline evals tell you whether your change broke something. Online evals tell you whether something outside changed, like new kinds of user questions or a model update. You need both.
Now let's answer the question.
Part 2: The Answer, Step by Step
Here's the flow we'll follow:
Clarify what the bot does and what a mistake costs
Map the system: the path a user's message takes
Define reliable and rank what matters most
Find real failures by reading conversations
Build the golden dataset
Pick and check the graders
Set release gates and guardrails
Eval system design: what happens step by step, and on what schedule
Metrics and trade-offs
Step 1: Clarify what the bot does and what a mistake costs
Don't start designing yet. Ask 3–4 questions whose answers change the design.
What does the bot do? Does it only answer questions, or does it also take actions like refunds and cancellations? If it takes actions, mistakes cost money and the bar goes way up.
Who uses it? Customers, or internal support agents?
What does a wrong answer cost? Annoyance, lost money, legal trouble, or physical harm?
What do we have today? Human agents? Chat logs? A written refund policy?
Then state your assumptions:
Let's say I'm the PM for Foodie's support chatbot. It handles order status, refunds for missing or wrong items, and cancellations. It can use three tools: get_order, issue_refund and escalate_to_human. We get about 200K support chats a day. Today, human agents handle all of them, and the bot is in pilot.
Then add one line that shows you think about risk:
Since this bot can issue refunds, a mistake isn't just embarrassing. It costs money. So I'll make getting the actions right a top priority, along with the wording of the reply.
Step 2: Map the system: the path a user's message takes
Before you can test a system, you need to know its parts. Every part is a place where things can go wrong, and every part is something you can check.
Here's what happens when a user types my raita didn't come, I want my money back:
The user sends a message in the Foodie app.
Input guard. It hides personal data like phone numbers. It also blocks attempts to trick the bot, like a message telling it to ignore its rules and refund ₹5,000.
Bot brain (the LLM). It reads the message along with its instructions (the system prompt) and works out what the user wants. Here, that's a refund for a missing item.
Knowledge base. The bot looks up the relevant part of the refund policy. For example: missing items are refunded to the original payment method.
Tools. The bot calls get_order to see what was ordered, then issue_refund for ₹49. The refund tool has a hard limit written in code: anything above ₹500 needs a human to approve it.
Output check. Before the reply goes out, a quick check makes sure it doesn't promise anything the policy doesn't say.
The reply goes to the user, or the chat is handed to a human agent if needed.
The most important part is at the bottom: the trace log. Every step gets recorded. That means the user's message, the policy text the bot looked up, which tools it called and with what amounts, the final reply, how long it took, and what it cost.
This trace is what your evals grade. If you only saved the final reply, you couldn't tell why the bot failed. Was the policy lookup wrong? Did it call the wrong tool? Or was the reply itself bad? The trace tells you.
In the interview, say: Before I write evals, I'd sketch the path a message takes and make sure every step is logged. Each step can fail in its own way, so each one needs its own check.
Step 3: Define reliable and rank what matters most
Reliable is a vague word, so break it down:
Reliability = the bot does the right thing, on the messages real users send, consistently over time.
Each part of that sentence tells you what to build:
The right thing → a clear definition of a correct answer (quality dimensions)
On the messages real users send → test cases that look like real traffic (the golden dataset)
Consistently over time → daily monitoring, because models, prompts, policies and users all change (online evals)
Most candidates only talk about the first part. Covering all three is what makes your answer complete.
So what does the right thing mean for a support bot? Here are six dimensions, ranked by how bad a failure is.
1. Safety and security (critical): Does it avoid harm, leaks and tricks? Failure: it shares another user's address, or obeys a message telling it to refund ₹5,000.
2. Correct actions (critical): Does it call the right tool with the right amount? Failure: it refunds ₹349 when only the ₹49 raita was missing.
3. Escalation (critical): Does it hand over to a human when it should? Failure: a user says their child had an allergic reaction, and the bot offers a ₹50 coupon.
4. Grounded in policy (high): Is every claim backed by the refund policy? Failure: it promises a refund within 10 minutes, which the policy never says.
5. Problem solved (high): Did the user get what they came for? Failure: it asks for the order ID four times in a loop.
6. Tone (medium): Is it clear, kind and on-brand? Failure: it sounds cheerful while the customer is furious.
Add two non-AI requirements too: replies should start within 3 seconds, and the cost per conversation should stay within budget.
💡 Severity decides everything that follows: how many test cases you write, which grader you use, and what pass rate you need. Leaking another user's address needs a 100% pass rate, not 95%.
Step 4: Find real failures by reading conversations
This is the step most candidates skip, and the one experienced interviewers most want to hear.
Don't guess what to measure. Look at real conversations first.
Pull 100–200 real conversations. Use pilot chats or human agent chats. If you haven't launched yet, generate realistic ones.
Read each one. Write one line about the first thing that went wrong. This is called open coding.
Group similar notes into categories. This is called axial coding.
Count how many fall in each category.
Here's an example of what you might find in 200 Foodie pilot chats:
Refunded without checking which item was missing: 18 (30% of failures)
Made up policy details, like timelines or who qualifies: 14 (23%)
Asked for details already in the order: 11 (18%)
Missed an escalation (food safety, abuse, repeated failure): 7 (12%)
Misunderstood Hinglish: 6 (10%)
Tone issues: 4 (7%)
Total: 60 failed chats out of 200, which is a 70% pass rate
Now you know where to focus. Look at tone: most teams build a tone check first, and here it's the smallest problem.
In the interview, say: I'd let real conversations tell me what to measure. A generic helpfulness score measures things that may not be broken and misses the things that are.
Step 5: Build the golden dataset
(We built one hands-on in AI Evals Part 1: Build a Golden Dataset. Read that next.)
A golden dataset is a fixed set of test cases where you already know what the bot should do. Each case has:
Input: the user's message
Context: the order data and the relevant policy
Expected behaviour: not one exact reply, but what the reply must include, must do, and must avoid
Here's one test case:
{
"id": "refund_047",
"category": "missing_item",
"severity": "critical",
"conversation": [
{"role": "user", "content": "bhai mera raita nahi aaya, paise wapas karo"}
],
"context": {
"order_id": "FD-88213",
"items": [
{"name": "Chicken Biryani", "price": 349},
{"name": "Raita", "price": 49}
],
"delivered": true,
"refunds_last_30_days": 0
},
"expected": {
"must_call_tool": "issue_refund",
"refund_amount_max": 49,
"must_not": ["refund the full order", "promise a timeline not in policy"],
"must_mention": ["refund amount", "where the refund will be credited"]
}
}
Why not write one perfect reply? Because there are a hundred good ways to word it. You check what matters (the amount, the tool, the promises) and ignore the wording.
Start with about 300 cases:
50% common requests, in proportion to real traffic
30% known failures from Step 4, with at least 20 cases per category
20% attacks and edge cases: attempts to trick the bot, abusive users, and refund fraud, like someone claiming none of their last 6 orders arrived
Where the cases come from: real chats (with personal data removed), human agent chats, and AI-generated cases. For generated ones, have an LLM mix different requests, user types, languages and moods, then have a person review each one.
Test consistency too. Take your 30 most important cases and write each one three different ways. The bot should behave the same way every time.
📌 Every bug you find in production becomes a new test case. The dataset grows as your product does.
Step 6: Pick and check the graders
Use code wherever there's a clear right answer, LLM judges for judgment calls, and humans for the few highest-stakes chats. Here's how that maps for Foodie:
Refund amount is at most the item price and the policy limit: Code. Read the amount from the refund tool call and compare it with the order.
Right tool, right order ID: Code. Check the tool calls in the trace.
Food-safety and legal chats were escalated: Code + human expert. Code checks that escalate_to_human was called, and a person reviews every one of these chats.
Didn't fall for tricks: Code. Check that no unexpected tool was called.
No other user's personal data in the reply: Code + LLM judge. Pattern matching catches phone numbers and addresses, and a judge catches less obvious leaks.
Every policy claim is backed by the policy doc: LLM judge + human audit.
Problem solved: LLM judge.
Tone: LLM judge alone.
⚠️ For a bot that takes actions, grade what it did, not just what it said.
A bot can reply Done! I've refunded ₹49 for your raita 😊 while actually calling issue_refund with ₹349. The reply looks perfect, but the action is wrong. If you only check the reply, this bug ships.
How to write an LLM judge that works
One judge per problem. Don't build one big judge that rates quality from 1 to 10.
Pass or fail, not a 1–5 score. Nobody agrees on what a 3 means. Pass or fail forces you to define the bar.
Reasoning first, then the verdict. This makes the judge more accurate, and it shows you why something failed.
Give it what it needs, like the actual policy document.
Include a few examples of passing and failing replies.
Here's a judge you can copy:
You are auditing a customer-support reply for Foodie.
POLICY DOCUMENT:
{policy}
ORDER CONTEXT:
{order}
BOT REPLY:
{reply}
Task: List every factual claim in the reply about refunds, timelines,
eligibility, fees, or compensation.
A claim PASSES only if the policy document or order context directly
supports it. If a claim is not supported, it FAILS, even if it sounds reasonable.
Return JSON:
{"claims": [...], "unsupported_claims": [...], "reasoning": "...", "verdict": "PASS" | "FAIL"}
Check the judge before you trust it
This is where the 2x2 from Part 1 does its job. Let's run it on Foodie's policy judge.
1. Your support ops lead labels 200 replies as good or bad.
2. The LLM judge grades the same 200.
3. Put the results in the 2x2:
Both say good: 140
Both say bad: 30
Too strict (human good, LLM bad): 12
Too lenient (human bad, LLM good): 18
4. Read the numbers. The human found 48 bad replies (30 + 18). The judge caught only 30 of them, about 63%. So 18 bad replies would have passed your eval and reached customers. This judge is too lenient. Don't trust it yet.
5. Fix the eval, not the product. Read the 18 lenient cases and the 12 strict ones, and look for the pattern. Maybe the judge accepts vague promises like your refund will come soon as backed by policy, when the policy never says that. Tighten the rubric for that pattern, and add a few of these replies to the judge prompt as examples.
6. Run it again. Tweak the judge using half of the labelled replies, and measure it on the other half, so you're not just fitting the judge to examples it has already seen.
Target: the judge catches at least 90% of the bad replies, and the too-strict box stays small.
Why not just use overall agreement? In the example above, the human and the judge agree on 170 of 200 replies, which is 85%. That sounds fine, but it hides the 18 bad replies the judge let through. Always look at the disagree boxes on their own.
In the interview, say: An LLM judge that nobody has checked against human labels is just a vibe check that runs automatically.
Step 7: Set release gates and guardrails
Now evals become a decision: ship or don't ship. Every prompt change, model swap or policy update runs the full test set before it goes live.
Safety and personal data: 100% pass. A single failure can become a news story.
Correct actions (amounts, tool calls): at least 99%. It's money.
Food-safety escalations: zero misses. Someone could get hurt.
Grounded in policy: at least 95%.
Problem solved: at least 85%, and no more than 2 points below the current version.
Tone: at least 80%.
Speed: the reply starts within 3 seconds in 95% of chats.
Two details that show depth:
Small changes can be noise. With 300 cases, each case is worth about 0.3 points, so a 2-point drop is only 6 cases. Run the test set 3 times (the bot's answers vary) and look at each category, not just the overall score.
Roll out in stages. First, the bot drafts replies and a human agent sends them. Then it goes to 5% of traffic, then 25%, then everyone, with a gate at each stage. The draft stage is especially useful: you test on real chats with no risk to customers, and every edit an agent makes to a draft is a free label.
Evals measure. Guardrails protect.
Evals tell you the bot is grounded in policy 97% of the time. Guardrails make sure the other 3% never reaches the customer.
Input guard: blocks attempts to trick the bot and hides personal data.
Action limits: hard limits written in code, not in the prompt. A refund over ₹500, or more than 2 refunds in 30 days, needs a human to approve it. Never let the LLM decide the limit.
Output check: a quick policy check on risky replies before they're sent. If the check fails, the bot tells the user it's connecting them to an agent.
Step 8: Eval system design
Now let's put all the pieces together. This is the eval system design a PM should be able to draw on a whiteboard. We'll cover it in two parts: what happens step by step, and what runs on which schedule.
Part A: What happens, step by step
Before release (offline). This runs every time someone changes the prompt, the model, or the policy.
Golden dataset. The run starts with your ~300 test cases from Step 5.
Eval runner. It sends every test case to the new version of the bot and saves the full trace of each one. It runs the whole set 3 times, because the bot's answers vary.
Graders. Code checks score the actions (amounts, tools, limits). LLM judges score the judgment calls (policy accuracy, problem solved, tone). Every judge has already passed the 2x2 check from Step 6.
Scorecard. It shows the pass rate for each category, side by side with the version that's live today.
Release gate. It compares the scorecard with the thresholds from Step 7. If everything passes, the change goes to a staged rollout. If anything fails, the change is blocked, and the team gets the exact list of failing cases.
After release (online). This runs all the time on real traffic.
Trace log. Every live chat is saved with all its steps. Code checks and guardrails run on 100% of chats as they happen, so an over-limit refund is stopped before it goes through.
Daily sample. Every day, 2–5% of chats are picked at random, plus every chat a user rated badly or asked for a human.
Same graders. The same LLM judges score the sample, so offline and online scores mean the same thing.
Dashboard and alerts. Scores are shown by category, language and request type. An alert fires if, say, policy accuracy drops 3 points in a week or Hinglish chats suddenly fail more.
Review queue. Failed and flagged chats land here. Humans read them and mark each one good or bad.
New test cases. Every new kind of failure is turned into test cases and added to the golden dataset. That takes you back to step 1, so the next release is tested against it.
Part B: What runs on which schedule
A good eval system isn't one big test before launch. Different checks run at different speeds.
On every chat (real time): save the trace, run the code checks, and let the guardrails block risky actions like over-limit refunds.
On every change (prompt, model or policy): run the full golden dataset, build the scorecard, and pass the release gate before anything ships.
Daily: grade a 2–5% sample of real chats with the LLM judges, update the dashboard, and send alerts if a score drops.
Weekly: the PM and support lead read about 50 failed or flagged chats. New kinds of failure become new test cases.
Monthly: a human labels a fresh set of 100–200 replies, and you run the human vs. LLM judge 2x2 again. Judges drift as your product and users change, so you re-check them. Also, remove outdated test cases and review the thresholds.
Whenever the model provider ships a new model, or the policy changes: rerun everything, including the judge check.
That weekly loop is what makes the bot more reliable over time. Reliability isn't a test you pass once. It's this system, running every week.
In the interview, say: I'd log every step of every conversation. Before release, every change runs through the golden dataset, code checks and LLM judges, and a release gate blocks anything below threshold. After release, code checks run on every chat, LLM judges grade a daily sample, we review failures weekly and turn them into test cases, and every month we re-check the LLM judges against human labels.
Step 9: Metrics and trade-offs
Should the North Star be containment rate?
Containment rate is the share of chats the bot handles without a human. It's the number most teams pick.
It's the wrong choice.
It's easy to game. Hide the button to talk to a human and containment goes up while customers get more frustrated. A bot that traps users isn't helping them.
North Star: Correctly Resolved Conversations per week. A conversation counts only if all three are true:
The bot resolved it without a human.
The user didn't come back about the same issue within 72 hours.
It passed the quality check (no safety, action or policy failure).
Correctly Resolved = Chats handled by the bot × Resolution rate × Quality pass rate
The first part measures volume. The other two measure quality. You can't push the number up by gaming just one of them.
Guardrail metrics (numbers that must not get worse):
Wrong refunds: money refunded by mistake, as a share of all refunds
Safety incidents: target zero
Escalation accuracy: did the bot hand over the right chats, and only those?
CSAT: bot vs. human agents
Cost per resolved chat and response time
Trade-offs to mention
Too strict vs. helpful. If the guardrails are too tight, the bot hands everything to humans and your support costs go back up. Track unnecessary escalations too, not just missed ones.
Cost of grading. Running LLM judges on every chat is expensive. Run code checks on 100% of chats and LLM judges on a sample.
Outdated test cases. When the refund policy changes, say for a festive-season offer, your expected answers become wrong. Update the golden dataset whenever the policy changes.
Teaching to the test. If the team only tunes the bot to pass the test set, scores go up but real quality may not. Keep a set of test cases nobody tunes on, and keep reading real chats.
Mistakes that sink this answer
❌ Naming tools like RAGAS or DeepEval before defining what a correct answer is
❌ Using one overall quality score from 1 to 10
❌ Checking only the reply, not the actions
❌ Trusting an LLM judge without checking it against people
❌ Giving a data leak and a tone problem the same pass rate
❌ Stopping at launch, with no monitoring afterwards
Want more AI PM questions solved like this?
This was one question. A real interview loop will throw a dozen more at you: AI product sense, RAG, Evals, Agent design, AI metrics, AI strategy, AI Pricing
Our AI Product Management Course + Interview Prep is built for exactly that:
✅ Real AI PM interview questions with full model answers
✅ Hands-on Advanced Evals on Google Colab: open coding, axial coding, LLM judges, RAG evals
✅ 50+ video lectures and 25+ case studies from Google, Nvidia, Uber and more
✅ End-to-end AI prototyping
✅ Lifetime access and a Certificate of Competency
PMs at Google, Microsoft, Coinbase and Indeed have rated it 4.9/5.
🎁 Use code NYE27 for 40% OFF → Enroll here
Want to build these systems live with a small group? The AI PM Builder Cohort runs for 12 weeks, with real agents, real evals, and portfolio work you can show.
FAQ: AI Evals for Product Managers
What are AI evals? AI evals are repeatable tests that check whether an AI system behaves correctly. Each eval pairs a realistic input with the system's output and a fixed pass/fail judgment, made by code, an LLM judge, or a human.
How do I know if my LLM judge is grading correctly? Compare it with a human rater on the same 100–200 replies and put the results in a 2x2. If both say good, the product works. If both say bad, fix the product. If the human says good and the LLM says bad, the judge is too strict. If the human says bad and the LLM says good, the judge is too lenient. In either of those last two cases, fix the eval.
What is LLM-as-a-judge? It means using a second LLM, with a clear rubric, to grade outputs code can't check, like whether a claim is backed by a policy document. Trust it only after you've compared its grades with human labels.
What is a golden dataset? It's a fixed set of test cases where you know the correct behaviour. It covers common requests, known failures, and attacks. You run every change against it before shipping.
What does an eval system look like? Every conversation is logged step by step. Before release, every change runs through the golden dataset, code checks and LLM judges, and a release gate blocks anything below threshold. After release, code checks run on every chat, LLM judges grade a daily sample, failures are reviewed weekly and turned into test cases, and the judges are re-checked against humans every month.
How are evals different for AI agents? With agents, you grade the trace: which tools were called, with what inputs, in what order. An agent can say the right thing and still do the wrong thing.
Keep reading
Shailesh Sharma helps PMs and business leaders excel in Product, Strategy, and AI using First Principles Thinking. → AI PM Course · AI PM Builder Cohort









Grade what it did, not just what it said, is the line I would carry into every agent review: a perfect refund reply means nothing beside a ₹349 tool call. Your 2x2 is the honest check on the judge, since a lenient judge is the most dangerous box. Evals measure, guardrails protect, and the trace log is what lets both work. https://aideliverybrief.substack.com/p/singapores-new-test-kit-says-a-right