DEV Community: Yvoo

How do you budget by paycheck when bills do not line up with paydays?

Yvoo — Mon, 09 Nov 2026 18:50:09 +0000

Assign every bill to the paycheck that arrives on or before its due date, then subtract those bills from that paycheck. What remains is the money you can plan with. A monthly budget hides this, because rent and your paycheck rarely share a date.

The rest of this article shows the method on paper, where it breaks, and how I built it into a one-file app.

Why does a monthly budget fail when pay is uneven?

A monthly budget assumes money arrives once and bills leave once. Real pay does not work that way. You may be paid every two weeks, twice a month, or on irregular dates.

Bills ignore all of that. Rent is due on the 1st. The phone bill lands on the 12th. Insurance is due on the 20th.

The monthly total can look healthy while one paycheck carries almost every large bill. You open the account on the 19th and the balance is gone.

Discipline is rarely the issue. The monthly view hides which paycheck is responsible for which bill.

How common is living close to the edge?

Common enough that timing matters. The Federal Reserve's 2025 household survey asked adults about a hypothetical $400 emergency expense. 63 percent said they would cover it using only cash, savings, or a credit card paid off at the next statement.

That means more than a third would need another route. The survey measures emergency cushions, not paycheck-to-paycheck living, so treat it as context and not as a count of that group. The figure was unchanged from the previous three years.

Source: Economic Well-Being of U.S. Households in 2025, Executive Summary, Federal Reserve Board.

When the cushion is thin, a bill landing one paycheck early or late decides whether the month works.

How do you assign bills to paychecks?

Use one rule: a bill belongs to the latest paycheck that arrives on or before its due date. Three steps apply it.

List your paydays for the next month, with the amount of each.
List every bill with its due date, including the ones that come every few months.
Place each bill under the latest payday that falls on or before it.

Here is an example with made-up numbers. You are paid $1,500 on the 5th and on the 19th.

Paycheck	Bills it covers	Bills total	Left over
5th, $1,500	Electricity (8th) $140, phone (12th) $45	$185	$1,315
19th, $1,500	Insurance (20th) $120, internet (25th) $60, rent (1st) $1,100	$1,280	$220

Rent is due on the 1st, which is before the 5th payday. So the paycheck from the 19th covers it, a bill that belongs to next month's calendar.

The monthly total here is $3,000 in and $1,465 out. That looks comfortable. By paycheck, the 19th leaves only $220 for two weeks of living.

What do you do with the leftover?

Read the leftover as a spending limit for that period, not as a bonus. Divide it by the days until the next payday.

On the 19th, $220 over 17 days is about $12.90 a day. On the 5th, $1,315 over 14 days is about $94 a day.

Those two numbers are very different, and the monthly view would have shown you one average. Knowing this in advance lets you act. You can move a bill's due date with the provider, shift a savings transfer to the lighter paycheck, or plan the tight stretch.

Why does this fall apart in a spreadsheet?

The method is simple. Keeping it current is the work. Each new bill needs a row, a due date and a paycheck. Each payday shift needs a fix to a formula.

Quarterly and yearly bills are the worst case. They vanish from view for months, then land in one paycheck with no warning.

A spreadsheet can do this. In my experience the upkeep stops after a few weeks, and a broken formula gives a wrong number with total confidence.

How does Paycheck Budget handle it?

I built the same rule into one HTML file that opens in your browser. It has three short screens for setup.

Your pay and next payday.
The bills that repeat.
A choice between plan mode and plan and track.

You enter a bill once. The app places it in the right paycheck every time it comes round: monthly, every two weeks, every few months, or once.

Plan mode needs only your pay and your bills. It never asks you to log a coffee. Plan and track adds a + Spend button. You type an amount, tap a category, and the Today screen shows one number: safe to spend today, counted line by line.

The Paychecks screen lists the next six paychecks, each with its bills, debt minimums and savings. A calendar shows paydays, bills and spending by day.

What about debt and savings?

Debt sits in the same plan. You enter your debts. The app shows a payoff date under two strategies.

Avalanche pays the highest interest rate first. It usually costs the least interest.
Snowball pays the smallest balance first. It gives earlier wins.

The app shows the total interest under each, so you compare the cost instead of guessing. Savings goals sit beside them, and each paycheck shows its savings.

Where is my data stored?

In your browser, on that computer, and nowhere else. It runs without an account or subscription, works offline, and never connects to your bank.

There is a trade-off. Clearing your browsing data erases your numbers. So the app has a Download a backup button and reminds you once a week. A backup file restores everything, in the same browser or another one.

Chrome or Edge is recommended. Nothing to install: you download the file and double-click it.

Which approach should you pick?

If your pay is steady and your bills are few, a monthly budget works. Keep it.

If your paydays are uneven, or one paycheck always feels tighter than the others, budget by paycheck. Start on paper with the three steps above. Use a tool when the upkeep becomes the obstacle.

This is a planning method, not financial advice. The numbers above are examples, so replace them with your own.

Written with AI assistance. Every claim about the app comes from the version shipped on 2026-10-30.

Paycheck Budget is the one-file budget app this article describes. Try the free demo first; the full version is on Gumroad.

Why do Notion life dashboards stop being used, and what keeps one alive?

Yvoo — Wed, 04 Nov 2026 16:20:43 +0000

A Notion life dashboard stops being used when opening it costs more than it gives back. Broken widgets, a crowded home page, sample data to delete and a hard start all raise that cost. A dashboard that lasts keeps the home page small and the rest one click away.

Below are the five reasons dashboards die and the rules I follow to prevent each one. They come from building a Notion life planner called Life & Work OS.

What actually kills a Notion dashboard?

The cause is rarely motivation. Five causes recur.

Widgets stop working. Third-party embeds for clocks, quotes and trackers depend on outside services. When one disappears, the page shows a blank box.
The home page is overloaded. Too many blocks compete for attention. You scan, feel behind, and close the tab.
Sample content has to be cleared. Filled-in examples help you learn, then block you. Deleting them is a chore nobody scheduled.
Navigation is inconsistent. Each sub-page has a different set of links, so you lose your way.
A new user cannot start. Without a guide, a powerful workspace looks like a blank wall.

Each cause has a rule. None needs a plugin.

Rule 1: How do you avoid widgets that break?

Build with plain Notion pages and databases. Use native views, filters, relations and rollups. Skip embeds.

A native block cannot go dead because a third party closed. It follows the same rules as every other page you own.

The cost is some visual polish. A clock widget looks nice. A filtered list keeps working.

Rule 2: What belongs on the home page?

Three things: Today, a month calendar, and your goals. Everything else is one click away.

In Life & Work OS, the Today list shows tasks due today or earlier that are still open. The month calendar shows every dated task. Goals appear as cards with a target date and a status.

Habits, journal, meals, money and work sit on their own pages. They are reachable, but they do not compete for your first glance.

The test is simple. Open the home page and ask what you need to do now. If you cannot answer in five seconds, remove a block.

Rule 3: How do you make goals useful instead of decorative?

Link tasks to a goal and let the progress figure come from them. In the template, a goal's progress is the share of its linked tasks you have ticked.

Few people update a percentage by hand for long. A number computed from work you already log stays honest without extra effort.

Each card also shows a target date and status. Together they tell you whether a goal is moving or only exists.

Rule 4: How do you avoid the sample-data cleanup?

Ship two editions. One is a sample, filled with examples so you can see how every page behaves. The other is blank, with the same pages and nothing inside.

You choose by how you learn. If you want to see it working first, take the sample. If you start from zero, take the blank one and skip the deleting.

If you build your own dashboard, apply the same idea. Keep a copy of the empty structure before you fill it.

Rule 5: How do you keep navigation consistent?

Put the same link row at the top of every page. Home, habits, journal, meals, money, work and the database list should sit in the same place everywhere.

You never wonder where a page went. Build the row once and copy it to each page.

What do the daily habits look like?

A dashboard survives when the daily loop is short. The loop in this template has two parts.

Morning: open the home page and look at Today.
Evening: tick your habits and write two lines in the journal.

The habit tracker has one row per day and five habits to tick, with a score for the day. You rename the five habits to your own. The journal holds a date, a mood, the win of the day and what you are grateful for.

Meals, money and work follow the same pattern. Meals use a board by breakfast, lunch, dinner and snack, plus a week calendar. Money groups income, expenses and savings by type, each line with a category and its month. Work lists projects with a status, a deadline and a next step.

Keep each page to the fields you will fill in. A field you never touch is clutter.

How does a new user get started?

Include a Start here page inside the workspace, with five steps to make it yours. Short, ordered and written for someone who has never used a database view.

A guide outside the workspace gets lost. A guide inside it is there at the moment of confusion.

What does it cost to try?

You need only a free Notion account. The planner is delivered as a one-page PDF with two copy links, one per edition. Open a link in a browser on a computer, sign in to Notion, press Duplicate and choose your workspace. The copy is yours to edit.

Notion is a separate service and needs an internet connection. Chrome or Edge is recommended for the copy step.

Which rule should you apply first?

Start with the home page. Remove everything that is not Today, the calendar or goals. Move the rest to its own page and link it from one shared row.

That single change fixes the overload and the navigation problem together. The other four rules protect the dashboard once you rely on it.

Written with AI assistance. Every claim about the template comes from the version shipped on 2026-10-30.

Life & Work OS is the Notion life planner built on these rules, with a sample and a blank edition: get it on Gumroad.

Notion is a trademark of Notion Labs, Inc. Life & Work OS is an independent template and is not affiliated with or endorsed by Notion.

7 Vapi Settings I Changed After Real Phone Calls (Voice Agent Gotchas, Tested)

Yvoo — Wed, 21 Oct 2026 13:49:48 +0000

I run a voice agent on a business phone line. It answers in French, English or Chinese, takes a message (who is calling, what they need, how to reach them) and hands it to a human. The stack: Vapi for the call, Soniox for speech-to-text, Claude Haiku for the conversation, an ElevenLabs voice.

Text simulations looked fine. Then real calls came in, and six things went wrong that the text tests hadn't shown, plus two configuration details I'd check before go-live. Here is each one, what caused it, and the setting the agent runs now.

Why did the agent quote prices nobody approved?

The first phone prompt reused the whole knowledge base, price sheet included: 38,700 characters. On an early test call, the agent read three price tiers to the caller.

Anything in the prompt can come out of the speaker. I replaced it with a phone-only prompt of 5,400 characters, with no prices and no delivery times. A price question now gets one sentence (the team will send details by email) and the agent moves on to the next missing item. ElevenLabs' prompting guide also flags long prompts as slower and less reliable, so the cut paid twice.

Why did French calls end with an English "Goodbye"?

On French test calls, the last words were "Goodbye. Au revoir." The end-call tool speaks its own default line before it hangs up. An empty request-start message silences it; the model says goodbye in the caller's language, then calls the tool.

"tools": [{ "type": "endCall", "messages": [{ "type": "request-start", "content": "" }] }]

Where did the office noise come from?

Callers heard a low office murmur behind the voice. Vapi's API reference states it plainly: the default background sound is "office" for phone calls and "off" for web calls, which is why a web test won't show it.

"backgroundSound": "off"

Why did one spelled name trigger twenty replies?

A caller spelled a surname and an email slowly, pausing between pieces. The transcriber cut each piece into its own turn, and the agent answered every fragment: more than twenty replies in one call. The answer is to wait longer before a pause counts as the end of a turn. This is what the agent runs now:

"startSpeakingPlan": {
  "waitSeconds": 1.0,
  "transcriptionEndpointingPlan": {
    "onPunctuationSeconds": 1.0,
    "onNoPunctuationSeconds": 2.0,
    "onNumberSeconds": 2.0
  }
}

The price is a slightly slower reply after short answers. On a message-taking line that trade is worth it. On a fast sales line, measure before you copy these numbers.

Why did line noise cut the agent off mid-sentence?

A crackle on the line was transcribed as a word, and one word was enough to stop the agent talking. The agent now needs two words from the caller before it treats them as interrupting.

"stopSpeakingPlan": { "numWords": 2 }

Why did the agent keep talking after goodbye?

In three of five test calls, after both sides had said goodbye, the model restated the hand-over message instead of ending the call. Rather than fight it in the prompt alone, I gave the model one fixed closing line per language and added end-call phrases: when the assistant says one of these, Vapi hangs up.

"endCallPhrases": ["bonne journée, au revoir", "have a good day, goodbye"]

Make the model's closing line match one of them exactly, in every language the line supports.

What else is worth checking before go-live?

Two smaller ones:

Don't ask for a number you already have. The caller's number is available in the prompt as {{customer.number}}. My agent reads it back for confirmation instead of asking the caller to dictate it, and in French it reads it the way French speakers say numbers: "zéro six", then digit pairs.
keypadInputPlan.delimiters takes an array. Passing a plain string got a 400 from the API. "delimiters": ["#"] works.

How do you know a fix didn't break something else?

One manual call proves little: each bug above showed up on some calls and not on others. I keep a small suite of scripted scenarios (a client with a vague need, a recruiter, a price question, a caller speaking Chinese). Each one places a real call and checks the result automatically: no price figures in the agent's lines, the hand-over said at most once, the message fields filled in. At roughly ten cents a scenario in my setup, it runs after every prompt change.

Most of these were not model problems. They were defaults, timing and telephony. Before your agent takes its first real call, check six things: what the prompt contains, what the end-call tool says, the background sound, the endpointing waits, the interruption threshold, and how the call ends.

Written with AI assistance. Every issue, number and setting above comes from my own agent's test and real calls; the JSON is the configuration it runs today.

I set up and tune phone agents like this one. If you'd rather have one answering your line than debug one, the contact is on my profile.

How to Make AI Summaries Stop Dropping the Important Parts: A Copy-Paste Prompt (Tested)

Yvoo — Tue, 13 Oct 2026 16:01:19 +0000

An AI summary fails quietly. It doesn't invent anything, it reads well, every bullet is true — and the one line you needed is simply not there. The exception to the rule. The deadline. The "never do X". Nothing in a clean eight-bullet summary tells you what got cut, so you walk away confident about a document you've only partly read.

That's a different problem from hallucination, and it needs a different fix. You can't fact-check an omission; there's nothing on the page to check. What you can do is make the model show its work: list everything the document contains first, summarize second, then account for every item it left out. Below is that prompt, a side-by-side test against a plain "summarize this", and where it still needs you.

Why do AI summaries drop the important parts?

Because "summarize" asks for compression, and compression keeps what's typical of a document, not what's load-bearing in it. The main rules survive. The exceptions to those rules — usually one sentence each, often buried under a heading that sounds minor — are exactly what compression treats as detail.

Three kinds of content go first, and they happen to be the ones that hurt:

Exceptions — "do X, except when Y." The summary keeps "do X".
Hard constraints — numbers, limits, deadlines, "must" and "must not".
Small sections — a heading with three lines under it loses to a heading with thirty, whatever the three lines say.

The copy-paste summary prompt with a coverage check

Summarize the document below in two passes.
Pass 1 — Map: list every section or distinct topic, in order, one line each.
Pass 2 — Summary: write the summary (max [N] bullets). Every bullet must name
the section it comes from.
Then, Coverage check: list each Pass-1 item that is NOT in the summary, and
for each say in one line whether a reader could get hurt by not knowing it
(yes/no + why).
Numbers, deadlines, exceptions and "must/must not" rules are never dropped
silently: include them or list them under Coverage check.
Document: [PASTE]

The map comes first on purpose. Once the model has written down every section, it can't pretend the small ones don't exist — and the coverage check forces a verdict on each one it skipped. The omission becomes visible, which is the whole point.

What happens on a real document?

I used PEP 8, Python's style guide: long, public domain, full of rules and exceptions to those rules, and easy to check. Two fresh runs (Claude Sonnet, same 8-bullet limit):

Run A: only the instruction "Summarize this document in at most 8 bullet points."
Run B: the prompt above, with N = 8.

Run A was a good summary. Indentation, line length, blank lines, imports, naming, docstrings, comparisons to None, annotations — all correct, all genuinely useful. If you'd never read PEP 8, you'd think you had.

Here's what it didn't mention, checked against the source:

The section on when to ignore the guide. PEP 8 opens by saying consistency within a project matters more than consistency with PEP 8, lists reasons to break its own rules, and says in so many words: do not break backwards compatibility just to comply with this PEP. Run A kept every rule and dropped the permission to deviate — which makes it read stricter than the document is.
The team exception to line length. Run A gave the 79-character limit. The source adds that a team can agree to go up to 99, as long as comments and docstrings still wrap at 72.
The one mandatory trailing comma. Trailing commas are optional except for a one-element tuple. That's a real bug in waiting: without the comma you don't get a tuple.
Where module dunders like __all__ go, including the rule that from __future__ imports come before them.

Run B caught all four. The permission-to-deviate section became its first bullet, backwards-compatibility warning included. The 99-character team limit made it into the line-length bullet. And the coverage check listed the sections it still left out, each with a verdict:

When to Use Trailing Commas — yes, a reader could get hurt: the one-element tuple case "silently produces a plain string instead of a tuple — a classic hidden bug."
Module Level Dunder Names — yes: the from __future__ ordering rule, which the model noted can cause a real error rather than a style nit.
Source File Encoding, ASCII Compatibility — no: mostly binding on standard-library contributors.
References, Copyright — no.

Run B also listed a tail of exceptions it had compressed out of the summary: the two narrow cases where a bare except: is acceptable, the warning against return inside finally, the note that name-mangled attributes are still reachable. Not all of that belongs in a summary. All of it is better listed than silently gone.

Same model, same document, same bullet budget. The difference is that Run B had to account for what it cut.

Where does this prompt stop?

Three limits showed up in the test:

It's longer. Run B's output was several times the length of Run A's. On a document you'll skim once, that's overhead. Use it when being wrong about the document costs you something.
The yes/no verdicts are judgment calls. "Could a reader get hurt?" depends on who the reader is. The model marked Source File Encoding as low-risk because it mostly binds standard-library contributors — right for most readers, wrong if you are one.
It only covers what the model actually read. Both runs read PEP 8 through a web-fetch tool, and the Run B agent reported that parts of the page came back paraphrased rather than verbatim. It also reported the map as complete — all 42 section headings present — but a map built from a paraphrase can still miss a line. For anything that matters, paste the source text in yourself.

How do you use the coverage check in practice?

Read the "yes" items first. They're the ones the summary would have hidden from you. On PEP 8 that was two lines; on a contract or a policy it's usually the reason you're reading it.
Spot-check one "no". Open the source at one skipped section and confirm the verdict. If it's wrong once, read the others yourself.
Search the source for "except", "must", "never", "unless", and any number. Ten seconds, and it's the fastest independent check that the constraints made it through.
Keep the map. Pass 1 is a table of contents you can come back to when a question comes up later — faster than rereading.

Written with AI assistance. Both summary runs were performed as described and reported faithfully; the claims about what PEP 8 says were checked against the live page at peps.python.org. PEP 8 is public domain — reproduce the test on it or on any document you know well.

This is part of the Verify AI Output series; related: how to stop ChatGPT and Claude from forgetting context in long conversations. I keep prompts like this one — summarization, fact verification, source compilation — in a Notion workspace I actually work from; if you want that library already set up, the AI-Augmented Notion Workspace is free, pay what you want.

If you run your AI work on a system, run the rest on one too. An ATS resume template in English and French, for Word and Google Docs: on Gumroad.

Can an LLM name the WCAG criterion a snippet violates? A 6-case RGAA benchmark on Kaggle

Yvoo — Fri, 09 Oct 2026 08:18:04 +0000

This is a submission for the Kaggle Benchmarking Challenge

What I Benchmarked

Accessibility audits against RGAA 4.1, the French profile of WCAG 2.1 AA, are a service I offer to French sites. The first pass of an audit is tedious and mechanical: look at a fragment, name the success criterion it breaks. If a model can do that pass reliably, the human hours go to the judgement calls instead.

So the benchmark asks exactly that question, six times. Each case is a small HTML fragment with one obvious defect, plus one compliant control:

Case	Fragment	Primary criterion
img-no-alt	`<img src="hero.jpg">`	1.1.1 Non-text Content
input-no-label	`<input type="text" id="q" placeholder="Rechercher">`	1.3.1 Info and Relationships
low-contrast	`<p style="color:#999;background:#fff">Mentions légales</p>`	1.4.3 Contrast (Minimum)
div-button	`<div onclick="go()">Valider</div>`	2.1.1 Keyboard
no-lang	`<html><head><title>Accueil</title></head><body>Bonjour</body></html>`	3.1.1 Language of Page
ok-link	`<a href="/contact">Nous contacter</a>`	NONE

The prompt is one paragraph: you are auditing a French public site, here is the fragment, answer with the WCAG 2.2 criterion number only, or NONE. (Every id above is unchanged between WCAG 2.1 and 2.2, so the RGAA mapping holds either way.)

Grading is deterministic, no judge model. A case passes when the answer contains any defensible criterion for that fragment. Two fragments genuinely break more than one rule: a clickable div fails both Keyboard (2.1.1) and Name, Role, Value (4.1.2); an unlabeled input fails 1.3.1, 3.3.2 Labels or Instructions, and 4.1.2. My first local draft accepted only the primary id, and the first model I ran lost two points for answers I would have accepted from a junior auditor. That draft was grading taste in criteria, not the ability to spot the defect, so I widened it before pushing to Kaggle. I kept the strict count as a second column because the gap between the two turned out to be the interesting part.

Score is cases passed out of 6. The whole task is one Python file: six cases, one prompt template, one loop.

Models Tested

Five models from the Kaggle model proxy, chosen to cover three labs, two price tiers, and two open-weight reasoning models:

Claude Sonnet 5 (Anthropic)
Gemini 3 Flash Preview and Gemini 3.7 Flash (Google)
gpt-oss-120b (OpenAI, open weights)
DeepSeek-R1-0528 (DeepSeek, open weights)

I wanted to see whether chain-of-thought buys anything on a task where the answer is a bare id.

Findings

Results from task version 2 on Kaggle:

Model	Lenient (any defensible criterion)	Strict (primary only)	Cost for 6 cases	Latency
Claude Sonnet 5	6/6	4/6	$0.007	10 s
Gemini 3 Flash Preview	6/6	5/6	$0.026	44 s
Gemini 3.7 Flash	6/6	5/6	$0.027	68 s
gpt-oss-120b	5/6	4/6	$0.0005	149 s
DeepSeek-R1-0528	6/6 *	6/6 *	$0.059	65 s

* DeepSeek ignored "criterion number only" and answered in prose, naming every candidate criterion for the ambiguous cases. Substring grading cannot tell an answer from an enumeration, so its strict column is not comparable. More on that below.

Per case, what each model answered:

Case	Expected	Sonnet 5	Gemini 3 Flash	Gemini 3.7 Flash	gpt-oss-120b	DeepSeek-R1
img-no-alt	1.1.1	1.1.1	1.1.1	1.1.1	1.1.1	1.1.1
input-no-label	1.3.1	3.3.2	3.3.2	3.3.2	3.3.2	1.3.1, 3.3.2, 4.1.2
low-contrast	1.4.3	1.4.3	1.4.3	1.4.3	1.4.3	1.4.3
div-button	2.1.1	4.1.2	2.1.1	2.1.1	2.1.1	2.1.1, 4.1.2
no-lang	3.1.1	3.1.1	3.1.1	3.1.1	`3`	3.1.1
ok-link	NONE	NONE	NONE	NONE	NONE	compliant

Spotting the defect was the easy part on these six cases. Naming the canonical rule was not. Every model found every defect and none flagged the compliant link. The single lenient miss in the table is not a knowledge miss: gpt-oss-120b answered 3 on the missing-lang page, a truncated 3.1.1 after 225 tokens of reasoning. The only real disagreement is which criterion to cite for the two multi-rule fragments. Every model that gave a single answer picked 3.3.2 over 1.3.1 for the unlabeled input, and Sonnet picked 4.1.2 over 2.1.1 for the div button.

The pick is not stable within one model. I ran the task twice on Kaggle, 21 minutes apart; the two versions differ only in how the score is returned, not in the prompt. Sonnet answered 1.3.1 for the input the first time and 3.3.2 the second. Gemini 3 Flash Preview answered 4.1.2 for the div the first time and 2.1.1 the second. If you grade on exact id, you are measuring sampling noise.

The control case held. Every run on the clean <a>, across both task versions and all five models, said it was compliant. For a first-pass audit tool, the false-positive rate on obviously good markup matters more than the hit rate on obviously bad markup, because false positives are what make a human stop trusting the tool.

Format compliance is its own axis, and the reasoning models lost it. DeepSeek-R1 got every case right and still broke the contract: it answered in paragraphs, listed all three candidate criteria for the input, and its visible output includes the full <think> block. gpt-oss-120b kept the format but truncated an answer. The three proprietary models returned exactly the bare id asked for, every time. For anything you plan to pipe into a script, that is the number that decides.

Reasoning tokens are where the money goes. Sonnet answered the six cases in 10 seconds for under a cent. The two Gemini Flash models took 4 to 7 times longer and cost 4 times more, almost all of it output tokens spent thinking before emitting a five-character id. DeepSeek-R1 was the most expensive run at $0.059, eight times Sonnet, for the same six verdicts. gpt-oss-120b was the cheapest at $0.0005, but one case alone sat on the proxy for two minutes, and the first run was killed by a 429 before it finished.

What surprised me: I expected the cheap models to miss the contrast case, since judging #999 on white needs an actual ratio (2.85:1, below the 4.5:1 floor). Nobody missed it.

What I would measure next: fragments with two defects where the model has to list both; the RGAA numbering (criterion 1.1, 11.1, and so on) instead of WCAG ids, since French audits are delivered in that vocabulary; and real pages with axe-core as the ground truth, which is where a six-case set stops being enough.

My Benchmark

https://www.kaggle.com/benchmarks/tasks/delphine53303/rgaa-a11y-judgement

Task source, cover and raw run files: https://github.com/yvoolab/rgaa-a11y-benchmark

Touch Grass: the best hours to be outside, forecast on your own laptop with TabPFN

Yvoo — Fri, 09 Oct 2026 00:43:41 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

A one-file forecaster that answers one question: which two hours tomorrow are worth going outside for?

It pulls 70 days of hourly weather for your city from Open-Meteo, hands that table to TabPFN, Prior Labs' open tabular foundation model, and gets back tomorrow's temperature, rain, wind and cloud hour by hour, with an uncertainty band. A transparent score turns that into three ranked windows. The output is a single offline HTML page: open it on your phone, read the top line, put the phone away.

No account, no API key, no GPU, no cloud. The model runs on a laptop CPU in about five minutes, honesty check included.

Who it is for: anyone who plans a run, a walk with a kid, or a lunch outside around the weather, and would rather own the thing that tells them when than refresh an app with ads.

Demo

Live page for Paris, built on the night of 8 October for 9 October:
https://yvoolab.github.io/touch-grass-tabpfn/

Run it yourself for any coordinates:

pip install tabpfn==9.1.0 numpy
python touch_grass.py --lat 45.76 --lon 4.84 --name Lyon --tz Europe/Paris

Code

https://github.com/yvoolab/touch-grass-tabpfn

yvoolab / touch-grass-tabpfn

Best hours to be outside today, forecast locally from your own weather CSV with TabPFN (open weights, CPU, offline HTML)

Touch Grass

Which hours tomorrow are worth being outside, forecast on your own laptop from a plain CSV of past weather. No account, no API key, no GPU, no cloud. One Python file, one offline HTML page.

Built for the DEV Hacktoberfest Open-Source AI Challenge, Week 1: Touch Grass. The open-source AI at the core is TabPFN, Prior Labs' tabular foundation model.

Live page: https://yvoolab.github.io/touch-grass-tabpfn/ (regenerated by hand, not on a schedule; the date in the header is the day it was built for).

What it does

Pulls about 70 days of hourly weather for one place from Open-Meteo (free, no key). Saved to data/<place>_hourly.csv so the next run can be fully offline.
Turns it into a flat table: hour of day, weekday, and what temperature, rain, wind and cloud were 1, 2, 3 and 7 days earlier.
Fits one TabPFN regressor per variable on the last 41…

View on GitHub

One Python file, 300 lines, MIT. touch_grass.py is the whole thing: fetch, features, four TabPFN fits, holdout, score, HTML. The saved CSV lets you rerun it fully offline.

How I Built It

The open-source AI at the core is TabPFN v2, used as a plain regressor, no agent wrapper. Four models, one per variable, each fit on 984 rows and asked for 24 predictions.

The data shape is deliberately boring. Each row is one hour of one day: hour of day, weekday, and what each variable was 2, 3, 4 and 7 days earlier. That is the whole feature set. TabPFN is pretrained on millions of synthetic tables, so it does not need me to hand-craft seasonality; it needs me to give it an honest table and stay out of the way.

The part I care most about is the honesty check. Before forecasting tomorrow, the pipeline re-predicts the last three fully observed days, each from only the days before it, and prints mean absolute error next to the dumbest baseline there is: the same hour two days earlier. Paris, this week:

Variable	TabPFN	Same hour 2 days earlier	Model better?
Temperature (°C)	2.83	1.67	no
Rain (mm/h)	0.10	0.11	yes
Wind (km/h)	2.38	3.43	yes
Cloud (%)	51.5	63.8	yes

The model wins on wind and cloud, ties on rain, and loses on temperature. In a stable October week, "same as two days ago" is a hard baseline for temperature with 41 days of lags and no numerical forecast as input. The page says so in a table, not in a footnote. If a tool is going to tell you when to leave the house, it should show you when it was wrong.

Three choices worth stating:

Why lags of 2+ days instead of 1. When you run this at night for tomorrow, "yesterday" is the last day whose 24 hours are all behind you. Using today's values would mean feeding the model Open-Meteo's own forecast for the hours that have not happened yet. The lag structure shifts with the target day so nothing leaks.
Why the score is a formula on the page, not a learned label. If I trained the model to predict a "comfort score" I computed from the same columns, it would learn my rule back and the holdout table would be meaningless. The model predicts weather; the rule is applied afterwards and is yours to edit.
Why 41 days and 4 ensemble members. TabPFN v2 caps CPU fits at 1,000 rows, so 41 × 24. Four ensemble members instead of eight halves the CPU time with the same story. Both are constants at the top of the file.

Built with Claude Code at the keyboard and me deciding what the thing is for, which baseline counts, and what goes on the page. Every number above comes from a run on my laptop, not from a notebook I cleaned up afterwards.

Why Does Open Innovation Matter?

Here is the specific thing open weights made possible: this project is a single file anyone can run in five minutes without creating an account anywhere.

That was not automatic. tabpfn 9.1.0 defaults to the newest TabPFN-3.5 checkpoint, which is gated behind a Prior Labs login and a non-commercial license. The v2 weights are ungated on Hugging Face under the Prior Labs License v1.1, Apache-2.0 plus attribution, and they run on CPU. Selecting them is one line:

TabPFNRegressor.create_default_for_version(ModelVersion.V2, device="cpu")

With a closed API, three things in this project would not exist. The offline rerun from a saved CSV. The honesty table, because you cannot audit a model you cannot run twice on your own data. And the "put the phone away" ending, because a page that needs a server to refresh is a page that pulls you back to the screen. Open weights are what let a weather tool be something you own rather than something you visit.

Attribution: TabPFN-v2 weights by Prior Labs. Hollmann et al., Accurate predictions on small data with a tabular foundation model, Nature 637 (2025). Weather data by Open-Meteo, CC BY 4.0.

Prize Categories

Best Use of TabPFN

How to Check AI Math: A Copy-Paste Prompt That Catches Wrong Numbers in AI Answers (Tested)

Yvoo — Thu, 08 Oct 2026 15:38:30 +0000

When an AI answer gets a number wrong, it is rarely the multiplication. It is the setup around it: a percentage taken of the wrong base, a yearly rate split into months as if compounding didn't exist, a figure that quietly changes between step two and step five. The arithmetic is clean, the table is formatted, and the conclusion is off.

You can't catch that by glancing at the result, and re-running the same question usually reproduces the same setup. What works is a second pass that rebuilds every calculated number from your inputs, then checks the base and the units separately from the arithmetic. Below is that prompt, a test run scored against values computed in Python, and what the test does and doesn't prove.

What do wrong numbers in an AI answer actually look like?

Five shapes cover most of them:

Wrong base. A percent change divided by the new value instead of the old one. Profit going from 35,913 to 39,075 is +8.8%, not +8.1%; both look reasonable.
Simple vs. compounded. "18% a year is 1.5% a month." It isn't: 1.5% compounded monthly is about 19.6% a year. The compounded monthly rate for 18% is about 1.39%.
Drifting inputs. A rate, a count, or a number of months that changes between steps without anyone saying so.
Rounding stated one way, used another. "About 2,207 orders" in the text, 2,206.6 in the formula.
Percent vs. percentage points. A margin going from 42.6% to 39.3% fell 3.3 points, which is not the same as falling 3.3%.

None of these is an arithmetic error. That's why "double-check your math" as an instruction does so little: the model re-does the multiplication and confirms it.

The copy-paste math-check prompt

Paste it into a fresh chat in ChatGPT, Claude, or Gemini, not the one that produced the answer, with your original question and the AI's answer filled in:

Check the numbers in the AI answer below. Do not trust any figure in it.

1. List every number in the answer that was calculated (not copied from my question). For each, write the formula that should produce it, using only figures from my question.
2. Recompute each one yourself, one operation per line. Work it out before you look at the answer's value.
3. Mark each one MATCH, MISMATCH (give both values), or CAN'T TELL (say which assumption it hinges on).
4. Check the inputs: flag any figure the answer used that isn't in my question, or that changed between steps (a rate, a count, a number of months).
5. Check the base and the units: percentages taken of the right base, monthly vs. yearly, per-order vs. total, percent change vs. percentage points, simple vs. compounded.
6. Finish with one line: the wrong number that would change a decision, if there is one.

My original question:
[paste question]

The AI answer:
[paste answer]

Step 1 is the important one. Writing the formula from your inputs, before looking at the answer's value, is what separates a check from a rubber stamp. Step 5 exists because base and unit errors survive step 2: recomputing a wrong formula gives the same wrong number.

What happens on a real AI answer?

I asked a model (Claude Sonnet, no tools, no code execution) a small-business question with eleven inputs: last year's revenue, cost of goods as a percentage, a monthly subscription, ads for nine months, payment fees of 2.9% plus €0.30 per order across 1,870 orders. Then next year with 18% growth and ads running all twelve months. It asked for both years' profit, the percentage change, and the compounded monthly rate equal to 18% a year.

Then I computed every figure in Python.

The model got all of it right. Last year's profit €35,913.30, next year's €39,074.93, +8.8%, 1.39% a month. It even added that 18% ÷ 12 = 1.5% would compound to about 19.6%. The only blemish: it wrote "about 2,207 orders" and then used 2,206.6 in the fee line, a €0.12 difference.

So the first test was a test of false alarms. I ran the check prompt on that answer in a fresh context (Claude Sonnet, no code execution):

Every calculated figure: MATCH. No false positives.
The 2,207 vs. 2,206.6 inconsistency, flagged as CAN'T TELL with "no effect on the result," which is correct.
An assumption the question left open: whether revenue and costs were both stated net or gross of VAT. I hadn't said, and it was right to ask.

A clean answer is useful to have, but it doesn't show the prompt catches anything. So I made a copy of the same answer with two planted errors, the first two shapes above:

Percent change divided by next year's profit: +8.1% instead of +8.8%.
Monthly rate given as 18 ÷ 12 = 1.5%, labeled compounded.

A second fresh context ran the same prompt on the planted copy:

Item	True value	Planted	Checker verdict
Profit change	+8.8%	+8.1%	MISMATCH, and it named the cause: divided by next year's profit instead of last year's
Monthly rate	1.39%	1.5%	MISMATCH, "a simple division presented as a compounded rate," with 1.015^12 ≈ 1.196 as proof
Every other figure	correct	correct	MATCH

Two planted errors, two caught, zero false positives across both runs. It also checked a claim hidden in prose, that the ad increase absorbs most of the extra gross margin, and confirmed it: ads take 5,250 of 8,411.63, about 62%.

Where does this prompt stop?

Three limits showed up in the test itself:

The two runs didn't flag the same things. The first raised the VAT question; the second didn't. Run it once and you get one reading, not a guarantee.
It contradicted itself once. In the planted run it called the 2,206.6 figure "consistent," then noted the same 2,207 vs. 2,206.6 gap in the very next section, under Inputs. Read the whole output, not just the summary line.
It checks with the same kind of mental arithmetic that made the answer. That held up here, but a checker and an answerer that share a blind spot will agree on the wrong number.

And the bigger limit: this was one question, two runs, one model. It shows the prompt finds the errors it is built to find. It doesn't show it finds everything.

How do you make the numbers trustworthy?

Use the prompt for triage, then settle anything that matters outside the chat:

Take the formulas from step 1 and run them yourself. A spreadsheet or three lines of Python. You're checking the model's formulas, which is faster than checking its arithmetic.
Read step 5's verdict on the base first. Wrong base and simple-vs-compounded are the errors that change decisions, and they're the ones a calculator won't catch for you.
Treat every CAN'T TELL as a question back to yourself. In the test, the VAT basis was a real gap in my question, not in the answer.
Fix the input, not the output. If a number is wrong because the setup was wrong, correct the question and regenerate. Patching one figure in a table leaves the figures derived from it wrong.

Can't I just tell the AI to use Python?

If your model can run code, yes, and the arithmetic will be exact. It still won't fix the setup. Code computes 3161.63 / 39074.93 perfectly, and +8.1% is still the wrong answer to "how much did profit grow." The check that matters is whether each number is the right formula for the question you asked, and that is what steps 1 and 5 of the prompt do.

Written with AI assistance. The test question, the original answer, and both checker runs were produced as described (Claude Sonnet, no code execution, separate fresh contexts), and every value was checked in Python. The two errors in the second run were planted by me and are disclosed as such. Results are reported faithfully, including the inconsistency and the run-to-run difference.

This is part of the Verify AI Output series, alongside catching AI hallucinations and checking AI citations. I keep my verification prompts, this one included, in one Notion workspace; if you want that library already organized, the AI-Augmented Notion Workspace is free, pay what you want.

If you run your AI work on a system, run the rest on one too. An ATS resume template in English and French, for Word and Google Docs: on Gumroad.

How to Check AI Citations: A Copy-Paste Prompt That Catches Fake Sources (Tested)

Yvoo — Tue, 29 Sep 2026 14:51:35 +0000

Ask an AI model for sources and it will give you sources. Authors, year, journal, volume, pages — the full costume of scholarship. The trouble is that the costume is exactly what the model is best at producing. A citation can be 90% real and still be wrong in the one place that matters, and nothing in its formatting tells you which 10% to distrust.

The usual advice — "always check the sources" — is correct and useless, because nobody checks four references by hand every time. What works is a triage step: a prompt that tells you which citation to check, which detail in it is shaky, and the exact query that settles it in under a minute. Below is that prompt, a test run scored against the real bibliographic records, and an honest account of what it missed.

What does a fake ChatGPT citation actually look like?

Rarely a paper that doesn't exist at all. The common shapes, roughly from easiest to hardest to spot:

Invented paper — plausible authors, plausible journal, no such article. The classic, and the one people already know to look for.
Real paper, rewritten title — the authors, year, journal, and page numbers are all correct; the title has been paraphrased into something the paper never said. Passes a glance, fails a copy-paste search.
Real paper, wrong job — the citation is accurate, but the text uses it for a claim the study didn't test.
Real paper, stale finding — accurate citation, accurate summary, and the result has since failed to replicate.

The last three are the dangerous ones, because every surface check — "does this author exist, does this journal exist" — comes back clean.

The copy-paste citation-check prompt

Paste it into a fresh chat — not the one that produced the answer, so the model has no stake in defending its own references. It works the same in ChatGPT, Claude, or Gemini:

Audit every source cited in the text below. Do not assume any of them exist.
For each citation:
1. Copy it exactly as written.
2. Rate it: LIKELY REAL / UNSURE / LIKELY FABRICATED, with one line why.
3. Name the one detail most likely to be wrong (author, year, title, venue,
   or the finding it is cited for).
4. Does the text use it for something the source actually studies? (yes/no/unsure + why)
5. Give the exact query a human should paste into Google Scholar to settle it.
Then list any claims in the text that sound sourced but cite nothing.
Text: [PASTE THE AI ANSWER WITH ITS SOURCES]

Step 4 is the one most citation checkers skip, and it's where a lot of the damage lives. A real paper used for the wrong claim is more persuasive than a fake one, because it survives the existence check.

What happens on a real AI answer?

I didn't plant errors this time. I asked a model, with no web access, a normal question: what does the research say about whether the Pomodoro technique improves focus and productivity — cite 4 academic sources. It returned a careful answer that admitted direct research on the technique is limited, plus four references. Then I ran the citation check on that answer in a fresh context (one pass, Claude Sonnet), and separately verified all four references against their publisher records and DOIs.

Ground truth first:

#	Citation as given	Reality
1	Ariga & Lleras (2011), Cognition 118(3)	Real paper, correct authors, journal, and pages. Subtitle rewritten — the real one ends "…task goals preempt vigilance decrements", not "…mediate the effects of switching on vigilance".
2	Trougakos et al. (2014), Academy of Management Journal 57(2)	Real paper, correct metadata. Title rewritten — given as "Lunch breaks unpack: Individual choices influence recovery effects and end-of-day well-being"; the real one is "Lunch Breaks Unpacked: The Role of Autonomy as a Moderator of Recovery during Lunch".
3	Zacher, Brailsford & Parker (2014), Journal of Vocational Behavior 85(3)	Correct, word for word.
4	Baumeister et al. (1998), Journal of Personality and Social Psychology 74(5)	Correct, word for word. The effect it reports did not replicate in a 23-lab preregistered study (Hagger et al., 2016).

No invented papers. Two of four titles quietly rewritten, with every number around them correct. That is what an honest-looking AI bibliography tends to look like, and it's why "the DOI-style details check out" proves very little.

What the checker caught:

#2 flagged UNSURE, title named as the weak detail. It said the title did not match its recollection and that the real paper centers on autonomy as a moderator of recovery — which is exactly right.
#2's misuse, too. The text used a study of the midday lunch break as evidence for Pomodoro-style short breaks. The checker called that "a scope mismatch even if the citation itself is real."
#4's stale finding. Citation rated LIKELY REAL (correct), but step 4 came back "unsure/partially no", and the checker noted the 1998 study did not test whether breaks restore performance, and flagged the effect's "serious replication failures." The original answer mentioned neither.
The unsourced summary. It singled out the closing "the consensus is…" sentence as the strongest claim in the passage with no citation behind it.

What did it miss?

#1. It rated Ariga & Lleras LIKELY REAL and guessed the page range was the detail most likely to drift. The pages were right; the subtitle was invented. The checker recognized the paper and never questioned the title wording.

That miss is the whole lesson. A model auditing citations from memory has the same memory that produced them. When it knows a paper well, it confirms the paper exists — and a rewritten subtitle sails through with it. The prompt narrowed four citations to one confirmed problem, one misuse, and one outdated finding; it did not make the fourth check unnecessary.

How do you settle the flagged ones fast?

The prompt's real value is step 5: a ready-made query for each source. The routine that caught the miss above takes about a minute per citation:

Paste the title in quotes into Google Scholar. Not the authors — the exact title. A rewritten title returns nothing, or returns the real paper with a visibly different title. That single search would have caught #1 and #2.
Open the publisher page, not a summary. Compare the title and the abstract with the claim the text makes. This is where "wrong job" citations show up.
Search the finding plus "replication". For anything from psychology or nutrition before about 2015, this takes ten seconds and occasionally changes everything.
Fix by replacing, never by softening. If a citation fails, swap in the real one or delete the claim. Rewording a bad citation into "research suggests…" launders it.

Can't I just tell the AI "only cite real sources"?

You can, and it will sincerely try. The four references above came from a model that hedged its answer and admitted the direct research was thin, and it still rewrote two titles. It wasn't lying; it was reconstructing from memory, and reconstruction is lossy in precisely the places that look authoritative. An instruction can't give a model access to a record it doesn't have. A separate audit pass, plus one exact-title search per flagged source, can.

Written with AI assistance. The test answer, the audit pass, and the ground-truth check were run as described — no web access for the first two, publisher records and DOIs for the third — and reported faithfully, including the miss. The input answer is summarized above; the two rewritten titles are quoted exactly as the model produced them.

This is part of the Verify AI Output series, alongside catching AI hallucinations and fact-checking ChatGPT. I keep my research prompts — literature review with a no-invented-citations rule, source compilation, fact verification — in one Notion workspace; if you want that library already organized, the AI-Augmented Notion Workspace is free, pay what you want.

If you run your AI work on a system, run the rest on one too. An ATS resume template in English and French, for Word and Google Docs: on Gumroad.

Notion AI vs. NotebookLM: Which One Should Hold Your Notes?

Yvoo — Tue, 25 Aug 2026 12:29:26 +0000

Notion AI vs. NotebookLM is a comparison between two tools that both say "ask questions about your own stuff" and mean different things by it. Notion AI works on content that is already living in your Notion workspace — pages, databases, meeting notes — and can act on it (fill a property, draft a page, summarize a thread). NotebookLM is a reading tool: you hand it a fixed set of sources, and it answers only from those sources, with citations back to the exact passage. Google renamed NotebookLM to Gemini Notebook in July 2026; it's the same product, and this article uses both names. One is a workspace with AI inside it; the other is a research desk with no workspace at all.

That difference decides the choice more than any feature list does. If your material is in Notion and you want it worked on, Notion AI. If your material is a pile of PDFs, transcripts, and docs and you want to interrogate it without hallucinations, NotebookLM. Most people who search this comparison actually need both, in a specific order. The rest of this article is about that order.

Is NotebookLM the same kind of tool as Notion AI?

No. NotebookLM is source-grounded by design: every answer comes from the documents you uploaded to that notebook, and it shows inline citations so you can check them. It does not know anything you didn't give it, and that limitation is the feature. Google's own help pages list what a source can be — PDF, Google Docs, Slides, Sheets, Word, text and Markdown files, web pages, public YouTube videos with captions, audio files, images, ePub, or pasted text — with a cap of 500,000 words or 200 MB per source and up to 50 sources per notebook on the free Standard tier (Gemini Notebook help: sources); paid Google AI plans raise that to 100–600 depending on tier (plan limits, checked 2026-08-25).

Notion AI is not a notebook; it's a layer over a workspace. It reads your pages and databases without you uploading anything, and it can write back: autofill a database property, draft inside a page, summarize a page, and — on the Business plan — run the Notion Agent, AI Meeting Notes, Enterprise Search, and Research Mode (Notion pricing, checked 2026-08-25). Free and Plus plans get "trial" AI only.

So the honest first question isn't "which is smarter" — it's "where does my material live, and do I want it read or acted on?"

What does NotebookLM do that Notion AI can't?

Three things, and they're the reasons to keep it around even if you live in Notion.

Grounded answers with citations. Ask NotebookLM "what did the vendor promise about data retention?" across six contracts and it returns the passages, not a paraphrase you have to trust. Notion AI can answer questions about pages in your workspace, but the answer is a synthesis: it lists the pages it drew from, but doesn't pin each sentence to a passage the way NotebookLM does.

A hard wall around the sources. NotebookLM won't reach for general knowledge to fill a gap; if the answer isn't in the notebook it says so. For research, due diligence, or studying a corpus, that wall is the whole point.

Audio and study formats from the corpus. NotebookLM can turn a notebook into a podcast-style Audio Overview, a Video Overview, a study guide, an FAQ, or a briefing doc. Notion AI generates text inside pages; it isn't built to produce a listenable summary of twelve documents.

What NotebookLM can't do: it doesn't store your ongoing work, has no databases, no properties, no automations, no collaboration surface beyond sharing a notebook. It's where you go to understand a body of material, not where the material lives afterward.

What does Notion AI do that NotebookLM can't?

Act on structured data. A Notion database with an AI autofill property can tag, summarize, translate, or extract a field for every new row without you asking. NotebookLM has no rows.

Work where the rest of your work already is. Meeting notes, project pages, CRM-ish databases, wikis — Notion AI reads them in place. There is no upload step, and nothing goes stale because you forgot to re-upload the latest version.

Be part of a workflow. Notion's native automations plus AI properties mean "new entry → AI summarizes → status flips → someone is notified" runs without a human in the loop. NotebookLM is a conversation; it doesn't trigger anything.

What Notion AI can't do: give you a citation-locked, sources-only answer. If you need "prove it from the documents," Notion AI is the wrong tool, and its database AI is built for per-row work rather than reasoning across a whole corpus in one pass.

Can NotebookLM read your Notion workspace?

Not natively. As of the help pages linked above, NotebookLM's source list doesn't include a Notion connector. The workable paths are manual: export a Notion page as PDF or Markdown and add it as a source, or paste the text. That's fine for a one-off deep read of a handful of pages, and painful for anything you'd want kept in sync — which is the main reason the two tools stay separate instead of one replacing the other.

The reverse doesn't exist either: Notion AI can't query a NotebookLM notebook. The bridge between them is you, exporting in one direction.

So which one should you actually use?

Use the order that matches how information actually moves:

NotebookLM for the reading phase. Drop the raw material in — contracts, transcripts, a course, a stack of papers — and interrogate it until you know what matters. Keep the citations.
Notion for what survives. The decisions, the extracted facts, the action items go into a Notion database, where AI properties keep them tagged and where the rest of your work can reference them.
Notion AI for the ongoing part. Once material lives in Notion, use Notion AI to summarize, draft, and autofill against it, because that's the material you'll touch every week.

If you only have budget or attention for one: pick by where your material lives. A Notion-centric team gets more from Notion AI's Business plan than from NotebookLM. A researcher or student whose material is PDFs and lectures gets more from NotebookLM, which is free for that job, and can keep Notion on the free plan as a plain notebook.

Notion AI vs. NotebookLM: the honest comparison

	Notion AI	NotebookLM
Built for	Working on and acting on content already in your Notion pages and databases	Reading and questioning a fixed set of uploaded sources, with citations
Knows your material automatically?	Yes — it's the workspace	No — you upload each source; 50 sources per notebook on the free tier, 500k words / 200 MB per source
Citations to the exact passage	Page-level references only — it lists which pages it drew from, not the passage	Yes, inline, every answer
Writes back / automates	Yes — AI database properties, drafting in pages, Notion Agent on Business	No — conversation and generated study formats only
Reads Notion pages	Native	Only via manual export or paste; no Notion connector listed
Audio / study formats	No	Audio Overview, Video Overview, study guide, FAQ, briefing doc
Price	Free and Plus get trial AI; full Notion AI needs Business at €19.50/member/month billed annually	Free (Standard) with a Google account: 50 sources/notebook, 50 chat queries/day, 3 Audio Overviews/day; paid Google AI plans raise all three

Neither column is the winner. The table says which tool already owns the job you're trying to do.

Prices and limits above are from each vendor's own pages as checked on 2026-08-25 — Notion's pricing page showed EUR. Both change; check before budgeting.

FAQ

Is NotebookLM a replacement for Notion?
No. NotebookLM has no pages, databases, tasks, or automations — it's a research tool over documents you upload. It can replace the "read a pile of PDFs and take notes" step, not the workspace where the notes end up.

Can I use NotebookLM and Notion AI together without paying for both?
Yes. NotebookLM is free with a Google account, and Notion's free plan gives you the workspace (with trial-level AI). The paid step is Notion Business if you want full Notion AI on top. The two-tool flow above works on free NotebookLM plus free Notion, minus the AI database properties.

Which one hallucinates less?
NotebookLM, by construction: it answers only from the sources in the notebook and cites them, and it will say when the answer isn't there. Notion AI answers from your workspace but doesn't lock every sentence to a source. For anything you'd have to defend, verify in NotebookLM.

Why not just use ChatGPT or Gemini for this?
You can, and for a single document it's fine. The difference is that a general chat assistant doesn't hold a persistent, citable corpus the way NotebookLM does, and doesn't live inside your working database the way Notion AI does. Both specialized tools exist because the general one loses either the citations or the structure.

Does NotebookLM keep my notebooks private?
Google's privacy page says notebook content isn't used to train its foundation models unless you submit feedback, and Workspace/Education accounts additionally get no human review (privacy and terms). If you're uploading client material, read the page for your account type rather than assuming.

This is the split I run myself: NotebookLM for the reading, a Notion database for what survives it. If you want the Notion side already built — the databases, AI properties, and SOPs wired for exactly that handoff — that's what the AI-Augmented Notion Workspace is. The full workspace is free, pay what you want: try it on a real task and see whether it earns a place in your setup.

If you run your AI work on a system, run the rest on one too. Life & Work OS is a Notion life planner with a sample and a blank edition: on Gumroad.

Trademarks referenced belong to their respective holders. NotebookLM, Gemini Notebook, Gemini, and Google are trademarks of Google LLC; ChatGPT is a trademark of OpenAI; Notion is a trademark of Notion Labs, Inc. This comparison is independent and not endorsed by any of them.

Last updated: 2026-08

Notion AI vs. Microsoft Copilot: What the New Notion Connector Actually Changes

Yvoo — Mon, 03 Aug 2026 13:46:47 +0000

Notion AI and Microsoft Copilot solve different problems by default: Notion AI works on content already sitting in your pages and databases, while Copilot works across the Microsoft apps you already use — Word, Excel, PowerPoint, Outlook, Teams. That split used to make the comparison simple. It got more complicated once Microsoft shipped a live connector that lets Copilot read your Notion workspace directly. Most "Notion vs. Copilot" articles were written before that existed.

Is Notion AI the same kind of tool as Microsoft Copilot?

No. Notion AI is a feature inside Notion — it runs on your existing pages, databases, and connected apps, and its whole value is that it already knows where your stuff is. Microsoft Copilot is broader: it's Microsoft's AI layer across the entire 365 suite, embedded in Word, Excel, PowerPoint, Outlook, and Teams, with agentic capabilities that draft, edit, and act inside those apps (Microsoft's official app breakdown, Copilot's agentic capabilities in Word/Excel/PowerPoint going GA, April 2026). One lives inside a single workspace; the other lives across an entire office suite. Those two territories now overlap, though: Microsoft ships a Notion connector for Copilot, covered below.

What does Notion AI actually do inside your workspace?

Notion AI's job is to act on content you've already put in Notion without you re-explaining any of it. Per Notion's own AI product page, that includes the Notion Agent (handles multi-step tasks using workspace context), AI Meeting Notes (transcribes and summarizes), Enterprise Search (searches across Slack, Google Drive, GitHub and other connected apps), database autofill, and in-line writing help. Full access — the Agent, Meeting Notes, and Enterprise Search — sits behind the Business plan; Free and Plus get a limited trial of the lighter features only (Notion's pricing page, checked 2026-08-03: Free €0, Plus €9.50/user/month, Business €19.50/user/month, all billed annually; Enterprise is custom-quoted). It's a workspace assistant, and a genuinely strong one for anything that starts with "something I already wrote in Notion" — it isn't built to reach outside that workspace on its own.

What does Microsoft Copilot do that Notion AI can't?

Reach across an entire office suite most teams already run on. Copilot drafts and edits in Word, builds formulas and charts in Excel, designs outlines in PowerPoint, drafts and summarizes threads in Outlook, and recaps meetings and surfaces action items in Teams — all as one assistant with shared context across those apps (Microsoft's app-by-app rundown). If your actual bottleneck is spread across email, spreadsheets, and slide decks, that's a real advantage Notion AI doesn't try to match — Notion AI was never meant to touch your Outlook inbox. The honest cost: the Business add-on runs $18/user/month annually as a limited-time rate through September 2026 (standard $21/user/month annually, or $25.20/month if billed monthly), and it's an add-on — you need an underlying Microsoft 365 Business or Enterprise license to buy it at all (Microsoft's official Copilot pricing page, checked 2026-08-03).

Can Copilot actually read your Notion workspace now?

Yes. Microsoft added Notion to the list of Microsoft-published federated Copilot connectors — along with Canva, HubSpot, Intercom, Linear, and a handful of others — using the Model Context Protocol (MCP) to fetch your Notion content live rather than copying it into Microsoft's index (Microsoft Learn's federated connectors overview, page dated 2026-06-22). It's read-only, it authenticates with your own Notion credentials so you only see what you already have access to, and it currently works in Copilot Chat, Copilot in Excel, and the Researcher agent. There's a catch worth knowing before you plan around it: it's off by default for a new tenant admin, and even once an admin turns it on, Microsoft holds it in an admin-only review window for seven calendar days before regular users can see it. This isn't a consumer feature you flip on yourself — it's an IT-admin-gated connector inside Microsoft 365 Copilot, not something available in the standalone consumer Copilot app.

So which one should you actually use?

Depends on where your content already lives and where your bottleneck actually is. If your knowledge base is Notion and your daily friction is "I have to re-explain context every time," Notion AI solves that natively — it's already inside the workspace. If your daily friction is spread across Word, Excel, Outlook, and Teams, Copilot's cross-app reach is doing something Notion AI was never built to do, and now it can read your Notion pages too if your admin has turned the connector on. Most teams running both tools aren't choosing one over the other — they're deciding which one owns which job, the same way you'd decide who owns a task between two coworkers with overlapping but different skills.

Notion AI vs. Microsoft Copilot: the honest comparison

	Notion AI	Microsoft Copilot
Built for	Working on content already in your Notion pages and databases	Working across Word, Excel, PowerPoint, Outlook, and Teams
Knows your workspace automatically?	Yes — that's the whole point	Only for Notion specifically if an admin has enabled the federated connector; native everywhere inside Microsoft 365
Full AI features	Notion Agent, AI Meeting Notes, Enterprise Search — gated to the Business plan	Drafting, editing, and agentic actions across the full Microsoft 365 app set
Where it lives	Inside Notion pages and databases	Inside Microsoft 365 apps, plus Copilot Chat and Researcher; can now reach into Notion via a federated MCP connector
Setup for cross-tool access	None needed — native	Admin must enable the connector tenant-wide; new connectors sit in a 7-day admin-only window first
Price	Free tier exists; full AI needs Business at €19.50/user/month annually	Add-on only — needs a Microsoft 365 license; Business add-on $18–21/user/month annually

Neither row is meant to declare a winner. It's meant to tell you which tool already owns the job you're trying to do.

Prices above are pulled straight from each vendor's own pricing page as checked on 2026-08-03 — Notion's page showed EUR, Microsoft's showed USD. Currencies aren't converted here on purpose; check your own region's price before budgeting.

FAQ

Can Microsoft Copilot use my Notion pages without an admin setting anything up?
No. The Notion connector is a Microsoft-published federated connector, off by default for new tenants and gated behind a 7-day admin-only review window before regular users can even see it. It's not a personal toggle inside consumer Copilot.

Does the Notion connector copy my Notion content into Microsoft's systems?
No. Federated connectors fetch data live over MCP at query time and don't index or store it in Microsoft 365 — the source of truth stays in Notion.

Is Notion AI available on the free plan?
Only a limited trial of the lighter features (docs generation, database autofill). The full set — Notion Agent, AI Meeting Notes, Enterprise Search — requires the Business plan.

Do I need Microsoft 365 Copilot to get any AI features in Word or Excel?
For the agentic, assistant-style features described here, yes — those are the paid Copilot add-on. Some lighter AI-adjacent features have shipped free in specific Microsoft 365 apps at various points, so check your specific plan's current feature list before assuming either way.

Is this connector the same as Notion's own AI integrations with Slack or Google Drive?
No — that's the reverse direction. Notion's Enterprise Search connects Notion AI out to other apps' content; the federated connector covered here lets Microsoft Copilot reach into Notion. They're two separate integrations solving opposite directions of the same problem.

This is the setup I actually run: a Notion workspace holding the structured system, AI doing the reasoning and drafting on top of it. If you want the Notion side already built for AI-driven work — the prompts, the SOPs, and the databases wired for exactly this — that's the AI-Augmented Notion Workspace. The full workspace is free, pay what you want: try it on a real task and see whether it earns a place in your setup.

If you run your AI work on a system, run the rest on one too. Life & Work OS is a Notion life planner with a sample and a blank edition: on Gumroad.

Trademarks referenced belong to their respective holders. Notion is a trademark of Notion Labs, Inc.; Microsoft, Microsoft 365, and Copilot are trademarks of Microsoft Corporation. This comparison is independent and not endorsed by either company.

Last updated: 2026-08

Verify AI Output Before You Ship It: 3 Prompts to Check AI Accuracy

Yvoo — Sat, 01 Aug 2026 10:09:12 +0000

Every AI answer you use lands somewhere: a config, a migration, a doc your teammates will trust. Shipping it unverified means its mistakes ship too — under your name. This article is the working routine I use to verify AI output before it ships: three copy-paste prompts to check AI accuracy, each doing one job, composing into a check that takes minutes, not an afternoon.

The first two — a hallucination sweep and an AI fact-checking prompt — come from earlier in this series (linked below, each with its own test run). The third — building a verification checklist sized to the stakes — is new here, tested on a booby-trapped example further down.

What does it actually take to verify AI output?

Three moves, in order, each answering a different question:

Sweep — which claims are even in here, and which look fabricated? Broad and shallow, across the whole answer.
Stress-test — is this one load-bearing claim actually true? Narrow and deep, on the claims that would change your decision.
Checklist — what's the complete set of checks this text deserves, given the stakes? The step that turns "I checked some things" into "I checked the right things."

Most people stop after an instinctive version of step 1. The failures that reach production usually live in steps 2 and 3.

Prompt 1: sweep the answer for hallucinations

The condensed version:

Audit the text below for hallucinations.
List every factual claim as a numbered line; label each
VERIFIABLE, SUSPECT, or FABRICATION-PATTERN (named
source/study/number with no citation).
End with the 3 claims most likely to be wrong, ranked.
Text: [PASTE THE AI ANSWER]

In part one's test run, this pattern caught all three planted errors in a sample answer — including a fabricated Stanford study. The trade-off: it hands back labels, not verdicts, and the flag count grows fast with text length.

Prompt 2: stress-test the claim you're about to act on

The short form:

Stress-test this claim. Do not assume it is true.
State what evidence would prove it wrong, the 2-3 conditions
it silently depends on, and the likeliest confounder.
Verdict: SUPPORTED / UNCLEAR / DOUBTFUL, one line why,
plus the single fastest check a human should run.
Claim: [PASTE ONE CLAIM]

The design is adversarial on purpose — it builds the case against the claim instead of inviting agreement. In part two's test run, this fact-checking prompt took "using an ORM prevents SQL injection" from code-review folklore to a DOUBTFUL verdict with the exact escape hatches that break it.

Prompt 3: build a verification checklist sized to the stakes

The new one, in full — this is the step that decides how much checking the text deserves:

Build a verification checklist for the AI-generated text below.
1. State the stakes: LOW / MEDIUM / HIGH, and why in one line.
2. List 3 checks for LOW stakes, 6-8 for MEDIUM or HIGH — each
   check names what to verify and the fastest way to verify it.
3. Order checks so the most damaging-if-wrong claim comes first.
4. End with the one claim that invalidates everything if wrong.
Text: [PASTE]

Damage-ordering is the point. A checklist that starts with the most dangerous claim means that even if you only do the first check, you did the right one.

Does the checklist prompt actually catch what matters?

I fed it four sentences of plausible AI-style upgrade advice — "upgrade PostgreSQL 12 to 16 in place with pg_upgrade, downtime under a minute, back up with pg_dumpall, run ANALYZE after, extensions are upgraded automatically so no manual steps are needed" — with that last claim as the planted trap: fluent, reassuring, and false. One pass, Claude Sonnet, fresh context. What came back:

Stakes: HIGH, with the right reason — following this on a production database risks silent data-access failures after the backup window closes.
The planted trap ranked as check #1 — called false as a blanket claim, with the fastest check spelled out (SELECT * FROM pg_extension;, then per-extension compatibility notes).
The same claim named as the invalidating one — the run's closing line: rely on it, and you can "complete the upgrade believing it succeeded" only to find broken functionality after rollback is gone.
Coverage I hadn't planted: it flagged that "downtime under a minute" silently depends on --link mode, that a backup you haven't test-restored isn't a backup, that the 12→16 multi-version jump itself needs verifying, and that the text has no rollback plan at all — eight checks, damage-ordered.

That last bullet is the real argument for the checklist step: it doesn't just audit the sentences that exist, it surfaces the checks the text should have mentioned and didn't.

Where does the free checklist prompt stop?

Three walls, visible in that same run:

Facts-first coverage. The checks orbit the claims present in the text. Logic errors, edge cases, and compliance exposure surface only if the text happens to hint at them — nobody asked "who can sue us over this?"
Stakes by gut feel. LOW/MEDIUM/HIGH in one line is a vibe check. It was right this time; nothing guarantees the same call on subtler input.
Structure drifts. Check count, depth, and phrasing vary run to run — fine for one-off use, weak as a routine you rely on daily.

For the routine version I maintain the full prompt as a paid product: AI Verification Checklist Builder on PromptBase. It sizes the checklist from a stakes rubric instead of a one-line guess, extends the checks to logic, edge cases, and legal review instead of stopping at facts, and ends every run the same way — with the load-bearing claims that invalidate everything else if wrong.

How do the three prompts fit together?

The composition rule is short:

Situation	Move
Whole AI answer, unvetted	Sweep (prompt 1), then stress-test the survivors that matter
One claim you're about to act on or repeat	Stress-test (prompt 2) directly
Text about to ship somewhere real	Checklist (prompt 3) — then actually run the top checks

And one rule above all three: the model's audit is the map, not the territory. Every verdict and every checklist item still ends with a human running the check — a grep, a doc page, a test restore. The prompts don't replace verification; they make sure the minutes you spend verifying land on the claims that can actually hurt you.

Written with AI assistance. The checklist test run in this article was performed as described — one pass, Claude Sonnet, fresh context — and reported faithfully; the earlier prompts' test runs are documented in their own articles. Reproduce this one: the input is quoted above.

The full checklist version is linked in the section above. If your bottleneck is the prompt itself rather than the output, I also maintain Optimizer: Diagnose & Rewrite. Earlier in this series: catching AI hallucinations and fact-checking ChatGPT.

The full workspace is free, pay what you want: AI-Augmented Notion Workspace.

If you run your AI work on a system, run the rest on one too. An ATS resume template in English and French, for Word and Google Docs: on Gumroad.

How to Fact-Check ChatGPT: The Copy-Paste Prompt I Use to Verify AI Output

Yvoo — Thu, 30 Jul 2026 14:12:30 +0000

A ChatGPT answer doesn't stay in the chat window. It gets pasted into a PR description, quoted in a design doc, repeated in a meeting as "apparently…" — and at that point its errors become your errors, with your name attached. Fact-checking the answer before you repeat it is not paranoia; it's the same hygiene as running the tests before you merge.

The good news: you don't need to verify everything, and you don't need a research afternoon. You need a triage rule and one copy-paste fact-check prompt — it works the same in ChatGPT, Claude, or Gemini. Both are below, along with a real test run and an honest account of where the short version runs out of road.

Why fact-check ChatGPT answers at all?

Because the model is optimized to be plausible, and plausible is not the same as true. Language models produce the answer that best fits the shape of the question — which usually overlaps with the truth, and sometimes doesn't. The failure mode is not obvious nonsense; it's the confident sentence that is 90% right with one wrong load-bearing detail. No amount of fluent wording distinguishes the two from the outside. Only checking does.

Which claims are actually worth checking?

Not all of them — that's the mistake that makes people give up on verification entirely. The triage rule I use:

Check the claims that would change your decision if they turned out to be wrong. Skip the rest.

In practice that means three categories get checked, in order:

Claims you're about to act on — "this API is rate-limited at X", "this license allows Y".
Claims you're about to repeat to someone else — anything heading into a doc, a PR, or a conversation where you'll be the source.
Specifics that smell too neat — precise percentages, named studies, tidy version histories.

Everything else — background info, general context, phrasing — can stay unverified, because being wrong there costs you nothing.

The copy-paste ChatGPT fact-check prompt

Once triage hands you a claim that matters, stress-test it. Paste this into a fresh chat — deliberately not the chat that produced the claim, so the model has no stake in defending itself:

Stress-test the claim below. Do not assume it is true.
1. Restate the claim precisely; note any ambiguity.
2. Falsifiability: what evidence would prove it wrong?
3. List the 2-3 conditions the claim silently depends on.
4. Name the most likely confounder or alternative explanation.
5. Verdict: SUPPORTED / UNCLEAR / DOUBTFUL, one line why,
   and the single fastest check a human should run.
Claim: [PASTE ONE CLAIM]

The design is intentionally adversarial. Most "is this true?" prompts invite the model to agree with itself; this one forces it to construct the case against the claim — what would falsify it, what it silently depends on, what else could explain it. Agreement has to survive the attack to show up in the verdict.

What happens on a real claim?

I fed it a claim you've probably heard stated as fact in a code review: "Using an ORM prevents SQL injection." One pass, Claude Sonnet, fresh context — the prompt itself is model-agnostic and pastes into ChatGPT unchanged. What came back:

The ambiguity surfaced first: does "prevents" mean immunity or risk reduction? Does "using an ORM" cover the raw-SQL escape hatches every ORM ships?
Falsifiability, concretely: one real case of an injectable ORM codebase disproves it — and the pass pointed exactly where such cases live: raw() / text() / execute() escape hatches with string concatenation, and untrusted input used as identifiers (table names, column names, sort direction), which ORMs typically don't parameterize — they parameterize values.
The silent conditions: developers never touch raw-query APIs; untrusted input never reaches identifier position; the ORM's own parameterization is bug-free.
The confounder — my favorite part: the thing that actually prevents injection is parameterized queries. The ORM just defaults you onto that path. Crediting the ORM confuses the tool with the mechanism.
Verdict: DOUBTFUL — risk reduced, not eliminated — with a fastest-check I'd genuinely use: grep the codebase for the ORM's raw/execute escape hatches and look for string concatenation.

That's a better security review of the claim than most humans give it, and it took under a minute. Note what made it work: the claim was load-bearing (people skip input sanitization because of it), and the prompt attacked instead of agreeing.

Where does the one-claim prompt stop?

Used daily, the short version has four walls you'll hit:

One claim at a time, and you do the extracting. A full ChatGPT answer contains a dozen claims tangled into prose; pulling them out and picking the load-bearing ones is on you. (That extraction step is a separate tool — see the hallucination checker from part one of this series.)
No graded confidence. SUPPORTED / UNCLEAR / DOUBTFUL is three buckets; when you're deciding whether to ship, "how doubtful, exactly?" matters.
No evidence structure. The short prompt names what evidence would settle the claim, but doesn't organize what supports versus what refutes — you rebuild that on your desk.
Consistency drifts. Freeform output means the depth of the audit varies run to run and model to model.

I stress-test claims often enough that I maintain the full version as a paid prompt: Fact Checker: Claim Stress Test on PromptBase. Same adversarial core, plus a 1–5 confidence rating, structured evidence-for/evidence-against, and the same audit depth on every run — built to push back, not agree.

Hallucination check or fact-check — which one do you need?

They're different passes and they compose:

Hallucination check (part one of this series): sweep a whole AI answer, extract every claim, flag fabrication patterns. Broad and shallow — it finds the suspects.
Claim stress test (this article): take one claim that matters and pressure-test it in depth. Narrow and deep — it interrogates the suspect.

Sweep first when the whole answer is unvetted; stress-test the survivors you're about to act on. On a claim someone hands you in isolation — a stat in a meeting, a "best practice" in a review — skip the sweep and go straight to the stress test.

The fast AI fact-checking routine

Whatever the verdict, the model's word is the map, not the territory. The closing routine:

DOUBTFUL verdicts: run the "fastest check" the audit named. It's usually a grep, a changelog, or one official doc page.
SUPPORTED verdicts on high-stakes claims: still spot-check the single strongest condition it listed. Support from a model is an argument, not a source.
Anything with a named study or precise number: search the exact source. Can't find it fast? Treat it as fabricated and cut it.
Never repeat a claim more confidently than your verification supports. "Docs say X" and "a model reasoned X" are different sentences — keep them different.

Written with AI assistance; the test run above was performed as described (one pass, Claude Sonnet, fresh context) and reported faithfully in summary. Reproduce it: paste the ORM claim into the checker and compare.

Full version: Fact Checker: Claim Stress Test. Previous in this series: How to Catch AI Hallucinations. Next: Verify AI Output Before You Ship It.

The full workspace is free, pay what you want: AI-Augmented Notion Workspace.

If you run your AI work on a system, run the rest on one too. An ATS resume template in English and French, for Word and Google Docs: on Gumroad.