A Deep Dive Into Excel’s Time and Date Functions

Because time is money, and you’re currently losing both by not knowing these.

Let me paint you a picture.

It’s Monday morning. You have a spreadsheet. The spreadsheet has dates in it. Someone — let’s call them “Past You” — has entered those dates in seventeen different formats, across three different columns, using a mix of text strings, actual date values, and what appears to be a cry for help disguised as a number.

You need to calculate how many days until a project deadline. You need to extract the month. You need to figure out whether a delivery happened on a weekend. And you need all of this before the 9am standup, which is in four minutes.

This is the moment Excel’s date and time functions were born for. And yet — most people know maybe three of them.

Not you. Not anymore. By the end of this article, you’re going to know all of them, how they work, when to use them, and why someone who doesn’t know them is basically navigating a city without GPS and too proud to ask for directions.

Let’s go.

First, A Two-Minute Explanation That Will Save You Hours

Before we dive in, here’s the thing most people never explain about dates in Excel: Excel doesn’t actually store dates as dates.

Seriously. Under the hood, every date is just a number. January 1, 1900 = 1. January 2, 1900 = 2. Today (April 16, 2026) = some number in the 46,000s. Excel just formats those numbers to look like dates, which is very considerate of it.

Why does this matter? Because once you understand that dates are numbers, everything about date functions suddenly makes logical sense. Adding 7 to a date gives you next week. Subtracting two dates gives you the number of days between them. The formula isn’t doing anything mystical — it’s just arithmetic with a nice coat of paint.

Times work the same way, but as decimal fractions of a day. Noon (12:00) = 0.5. 6am = 0.25. Midnight = 0. Got it? Good. Now let’s talk functions.

The “What Day/Time Is It Right Now?” Functions

TODAY()

What it does: Returns today’s date. Recalculates every time the file opens or refreshes.

Syntax: =TODAY()

Real-life example: You’re tracking a project deadline in B2 (let’s say it’s May 30, 2026). In C2 you put =B2-TODAY() and now you always know, instantly and without doing math in your head, exactly how many days you have left. Which might be motivating. Or terrifying. Either way, accurate.

💡 Pro Tip: TODAY() is “volatile” — it recalculates constantly. If you need a permanent timestamp of when something was entered, use Ctrl+; instead, which hard-codes the date and never changes.

NOW()

What it does: Returns the current date and time down to the minute. Also recalculates every time the sheet refreshes.

Syntax: =NOW()

Real-life example: You’re building a log of customer support tickets. Every time a new ticket is submitted, you want to record the exact timestamp. =NOW() in the timestamp column gives you something like “16/04/2026 09:47” — date and time, together, in one cell. Extremely useful when “when was this submitted?” is a question that leads to arguments.

💡 Pro Tip: NOW() returns a number with decimals. If you subtract NOW() from a future date and you get a weird decimal, that’s because it’s including the fractional time of day. Use INT(NOW()) to strip the time and get just today’s date as a whole number.

The “Build a Date From Parts” Functions

DATE(year, month, day)

What it does: Constructs a proper Excel date from three separate numbers — a year, a month, and a day. This is your rescue function when someone has helpfully stored the year in column A, the month in column B, and the day in column C.

Real-life example: You have an export from an ancient database system. Column A says “2026”, column B says “4”, column C says “16”. None of it is usable as a date yet. =DATE(A2,B2,C2) stitches them together into April 16, 2026 — a real, actual Excel date you can calculate with.

💡 Pro Tip: DATE() handles overflow beautifully. =DATE(2026,13,1) doesn’t give you an error — it gives you January 1, 2027, because month 13 just rolls into the next year. This is wildly useful for adding months to dates without weird edge cases.

TIME(hour, minute, second)

What it does: Same concept as DATE(), but for time. Constructs an Excel time value from separate hour, minute, and second components.

Real-life example: You’re managing shift schedules. In your system, start times come in as three separate columns: 9 (hour), 30 (minute), 0 (second). =TIME(A2,B2,C2) combines them into 9:30:00 AM — a real time value you can then use for duration calculations, comparisons, and scheduling logic.

💡 Pro Tip: Need to add 90 minutes to a time? Don’t add 90. Add TIME(0,90,0). Excel will handle the rollover correctly. Adding the raw number 90 will add 90 days, not minutes, and you’ll have a very confusing schedule.

The “Tear a Date Apart” Functions

YEAR(date)

What it does: Extracts just the year from a date. Returns a four-digit number.

Real-life example: You have a column of transaction dates going back five years and you want to create a pivot table by year. Add a helper column with =YEAR(A2) and suddenly you have a clean “Year” field to group on. Simple, extremely useful, used approximately nine million times a day in spreadsheets around the world.

MONTH(date)

What it does: Extracts the month number (1 through 12) from a date.

Real-life example: Your sales report needs a “Month” column for filtering. =MONTH(A2) gives you a number. Combine with =TEXT(A2,"MMMM") if you want the actual month name instead. Report looks good, boss is happy, you leave on time. This is the dream.

💡 Pro Tip: To convert a month number back to a name, use =TEXT(DATE(2000,A2,1),"MMMM"). Classic Excel party trick.

DAY(date)

What it does: Extracts the day of the month (1 through 31) from a date.

Real-life example: You need to flag all invoices issued on the last day of the month. =DAY(A2)=DAY(EOMONTH(A2,0)) — yes, we’ll get to EOMONTH shortly — checks whether the day of an invoice date equals the last day of its month. Month-end billing logic, solved.

HOUR(time), MINUTE(time), SECOND(time)

What they do: Extract the hour, minute, or second from a time value, respectively.

Real-life example (all three): You’re analyzing customer call durations. The start time is in A2, end time in B2, and the duration is in C2 as a time value. Now you need this in a readable format. =HOUR(C2)&"h "&MINUTE(C2)&"m "&SECOND(C2)&"s" turns 0:47:23 into “0h 47m 23s.” Your operations manager will use words like “professional” and “organised.” You will nod calmly.

The “What Day of the Week Is This?” Functions

WEEKDAY(date, [return_type])

What it does: Returns a number representing the day of the week for a given date. The return_type argument controls the numbering system (1=Sunday through Saturday, 2=Monday through Sunday, etc.). Default is 1.

Real-life example: You’re scheduling automated reports and need to make sure nothing sends on a weekend. =WEEKDAY(A2,2) returns 6 for Saturday and 7 for Sunday (Monday-based numbering). Wrap it in an IF: =IF(WEEKDAY(A2,2)>5,"Weekend","Weekday") and you’ve got an instant flag. No more reports going out on a Saturday to an inbox nobody checks.

💡 Pro Tip: Use return_type = 2 (Monday = 1, Sunday = 7) if you’re in Europe or working on business logic that treats Monday as the start of the week. This avoids a lot of off-by-one headaches.

WEEKNUM(date, [return_type])

What it does: Returns the week number of the year for a given date. Week 1 is the week containing January 1st. The return_type argument controls which day the week starts on.

Real-life example: You’re reporting on weekly sales performance and your stakeholders reference “Week 15” and “Week 28” instead of actual dates (because they’re creatures of habit and you’ve accepted this). =WEEKNUM(A2) gives you the ISO week number, which you can use to group, sort, and slice your data by week without ever writing a formula that involves seven nested IFs. Everyone who has written seven nested IFs to solve this problem knows the pain being avoided here.

ISOWEEKNUM(date)

What it does: Returns the ISO week number — the international standard used in Europe and most professional business contexts. ISO weeks always start on Monday and the first week of the year is the one containing the first Thursday.

Real-life example: You’re working with a European partner who refers to “KW16” (Kalenderwoche 16 — German for calendar week 16). =ISOWEEKNUM(A2) gets you on the same page without having to explain to your German colleague why your week numbers are off by one. Cross-border collaboration, sorted.

The “How Much Time Has Passed?” Functions

DATEDIF(start_date, end_date, unit)

What it does: Calculates the difference between two dates in a specified unit: “Y” for years, “M” for months, “D” for days, “YM” for months excluding years, “MD” for days excluding months, “YD” for days excluding years.

This function is technically undocumented by Microsoft. It exists, it works perfectly, but Microsoft didn’t include it in their official function list for mysterious reasons that nobody has ever fully explained. It’s the Excel equivalent of a secret room.

Real-life example: You’re calculating employee tenure for an HR report. =DATEDIF(A2,TODAY(),"Y") gives you complete years of service. Want to be precise? =DATEDIF(A2,TODAY(),"Y")&" years, "&DATEDIF(A2,TODAY(),"YM")&" months" gives you “3 years, 7 months.” The kind of thing that makes an HR system look polished and thorough. Very satisfying.

💡 Pro Tip: Always make sure end_date is greater than start_date. DATEDIF throws an error if the dates are the wrong way around and, unlike most Excel errors, it is not subtle about it.

DAYS(end_date, start_date)

What it does: Returns the number of days between two dates. Cleaner than subtraction for some scenarios.

Real-life example: Subscription renewal tracking. Column A has sign-up dates, column B has today’s date. =DAYS(B2,A2) gives you subscription age in days. When this hits 365, you know it’s renewal time. Simple, readable, does exactly one thing.

DAYS360(start_date, end_date, [method])

What it does: Calculates days between two dates based on a 360-day year (twelve 30-day months). This is a financial standard, not a mistake.

Real-life example: You’re working in accounting and calculating interest on a loan or bond using the 30/360 day count convention that the financial industry uses. =DAYS360(A2,B2) gives you the “banking days” between two dates. If someone in finance handed you a spreadsheet using this function and you thought it was a typo — it wasn’t.

💡 Pro Tip: The optional method argument is for US (FALSE) vs. European (TRUE) day count conventions. Yes, there are two. Yes, this matters in international financial documents. Yes, getting them mixed up is awkward.

NETWORKDAYS(start_date, end_date, [holidays])

What it does: Returns the number of working days (Monday–Friday) between two dates. You can optionally pass a range of holiday dates to exclude those too.

Real-life example: Project management gold. Client signs off on a project on April 16. The deliverable is due May 16. =NETWORKDAYS(A2,B2,HolidayRange) tells you how many actual working days you have, excluding weekends and any public holidays you’ve listed. This number will either reassure you or cause a mild crisis. Either outcome is useful information.

💡 Pro Tip: Build a dedicated “Holidays” named range in your workbook and reference it in every NETWORKDAYS formula. When holidays change next year, you update one list and every formula updates automatically. This is the kind of forward-thinking that makes colleagues ask if you took a course somewhere.

NETWORKDAYS.INTL(start_date, end_date, [weekend], [holidays])

What it does: Same as NETWORKDAYS but lets you define which days are the “weekend.” Because not everyone works a Monday–Friday schedule, and Excel knows this.

Real-life example: You’re calculating delivery times for a logistics company where the drivers work Tuesday–Saturday and have Sunday–Monday off. =NETWORKDAYS.INTL(A2,B2,2,HolidayRange) with weekend code “2” means Monday and Tuesday are treated as non-working days. No more manually adjusting day counts because the formula assumed a Western workweek that your operations don’t follow.

💡 Pro Tip: The weekend argument accepts both number codes (1–7, 11–17) and a 7-character string like “1000001” where each character represents Mon–Sun and “1” means non-working day. The string method is more flexible for unusual schedules.

WORKDAY(start_date, days, [holidays])

What it does: Returns the date that is a certain number of working days after (or before, with a negative number) a start date. Skips weekends automatically.

Real-life example: An order is placed on April 16. Your SLA promises delivery within 5 business days. =WORKDAY(A2,5,HolidayRange) returns April 23 — which is the correct delivery deadline after skipping the weekend. Much better than telling a customer their order arrives “in 5 days” and then having them show up on Saturday to collect it.

WORKDAY.INTL(start_date, days, [weekend], [holidays])

What it does: WORKDAY with the same custom weekend flexibility as NETWORKDAYS.INTL.

Real-life example: Same logistics scenario as above, but now you’re calculating the dispatch date by counting backwards. =WORKDAY.INTL(DeadlineDate,-3,2) tells you: if this needs to arrive by X, we need to ship by Y, on a Tuesday-Saturday schedule. Operations managers tend to love people who think this way.

The “Find The Start or End of a Period” Functions

EOMONTH(start_date, months)

What it does: Returns the last day of the month that is a specified number of months before or after a date. Months = 0 gives you the last day of the current month.

Real-life example: You’re calculating invoice due dates set to the last day of the month following the billing date. =EOMONTH(A2,1) returns the last day of the month after any given billing date. January invoice? Due February 28 (or 29 in a leap year — Excel handles this correctly without you doing anything heroic). This alone is worth the price of knowing EOMONTH.

💡 Pro Tip: EOMONTH(A2,0)+1 gives you the first day of the next month. Because the day after the last day of a month is always the first day of the next one. Simple math, endlessly useful.

EDATE(start_date, months)

What it does: Returns the date that is exactly a specified number of months before or after a given date. Unlike adding 30, this respects the actual calendar.

Real-life example: Subscription renewals. Customer signs up on January 31. One month later is… February 28 (or 29). Not March 2. =EDATE(A2,1) handles this correctly where =A2+30 does not. If your subscription billing is off by a few days every month, there’s a good chance someone used A2+30 somewhere. Go find it.

💡 Pro Tip: Use negative values to go backwards in time. =EDATE(A2,-6) gives you the date six months before A2. Useful for calculating notice periods, lookback windows, and “when should we have started worrying about this.”

The “Convert Text to Actual Dates” Functions

DATEVALUE(date_text)

What it does: Converts a date stored as text into a proper Excel serial number (real date). Essential when importing data from systems that export dates as strings.

Real-life example: Your CRM export gives you dates like “April 16, 2026” stored as text. Excel won’t calculate with them. =DATEVALUE("April 16, 2026") converts it into a real date value you can actually use. Then format the cell as a date, and you’re back in business.

💡 Pro Tip: If your text dates are in a regional format Excel doesn’t recognize, DATEVALUE may give you an error. This is Excel’s polite way of saying “I have no idea what 16/04/2026 means in your locale.” In that case, combine MID, LEFT, RIGHT, and DATE to manually parse the components. Not glamorous, but effective.

TIMEVALUE(time_text)

What it does: Converts a time stored as text into an Excel decimal time value.

Real-life example: Your helpdesk system exports call times as text strings like “09:47:00 AM.” =TIMEVALUE("09:47:00 AM") returns 0.406944… which Excel recognizes as a time and can calculate with. Now you can compute average call duration, flag calls over a certain length, and build actual operational reporting instead of just staring at a column of text.

The “Format and Display” Functions

TEXT(value, format_text)

What it does: Converts any number or date into a text string with a specified format. Technically a general-purpose function, but utterly indispensable for dates.

Real-life example: You’re building an automated email subject line in a formula. You want it to say “Weekly Report – Week 16, April 2026.” ="Weekly Report – Week "&WEEKNUM(TODAY())&", "&TEXT(TODAY(),"MMMM YYYY") produces exactly that, updating itself every week. Your reports look like they were crafted by hand. They were not. That’s the whole point.

💡 Pro Tip: Common date format codes — “D” = day number, “DD” = zero-padded day, “DDD” = Mon/Tue/Wed, “DDDD” = Monday/Tuesday…, “MMM” = Jan/Feb/Mar, “MMMM” = January/February…, “YYYY” = four-digit year. Combine freely. Format to taste.

The “Rounding Times” Functions

FLOOR(number, significance) and CEILING(number, significance)

What they do: Round a time (or date) down (FLOOR) or up (CEILING) to the nearest specified interval.

Real-life example: You’re calculating billable hours and your company bills in 15-minute increments. A call lasts 47 minutes. Rounded up to the nearest quarter hour: =CEILING(A2,TIME(0,15,0)) gives you 1:00 — one hour billed. Rounded down: =FLOOR(A2,TIME(0,15,0)) gives you 0:45. Your billing system is now as pedantic as your accountant. That’s a feature.

MROUND(number, multiple)

What it does: Rounds a number to the nearest specified multiple. Works on times too.

Real-life example: You want to round all meeting times to the nearest 30-minute slot for a cleaner schedule view. =MROUND(A2,TIME(0,30,0)) rounds 10:17 to 10:00 and rounds 10:22 to 10:30. Schedule looks neat, everybody thinks you planned it this way. You absolutely did not plan it this way.

The Less-Famous Ones (That Are Secretly Brilliant)

YEARFRAC(start_date, end_date, [basis])

What it does: Returns the fraction of a year between two dates. The basis argument controls the day-count convention (actual/actual, 30/360, etc.).

Real-life example: You need to calculate pro-rated annual fees for a service contract that started mid-year. =YEARFRAC(ContractStart,ContractEnd,1) gives you something like 0.623 — meaning 62.3% of the year was covered. Multiply by the annual fee and you have the exact pro-rated amount. Finance teams use this constantly. Most people have never heard of it.

DATESTRING(date)

What it does: Converts a date to a text string in the system locale format. Note: this is a legacy function and availability varies by Excel version.

Real-life example: Mostly used in older workbooks or specific regional output requirements. You’re better off using =TEXT(A2,"DD/MM/YYYY") and controlling the format yourself. But if you encounter DATESTRING in someone else’s spreadsheet, now you know what it does instead of quietly panicking.

Putting It All Together: The Formula That Impresses Everyone

Want a formula that shows off everything? Here’s one for a project status dashboard.

Assume A2 is a project start date, B2 is a planned end date, and today is TODAY().

="Project is "&DATEDIF(A2,TODAY(),"D")&" days in. "&NETWORKDAYS(TODAY(),B2)&" working days remaining, due "&TEXT(B2,"DDDD, MMMM D")&IF(WEEKDAY(B2,2)>5," (⚠️ deadline falls on a weekend!)",".")

This one formula tells you how long the project has been running, how many working days are left, the deadline in plain English, and flags it if the deadline lands on a weekend. It updates every day automatically.

Is it a bit much for a Monday morning? Possibly. Does it make you look like an Excel wizard? Absolutely.

The Bottom Line

Excel’s date and time functions aren’t just a list of things to memorize. They’re a toolkit for turning raw timestamps into actual, actionable information — deadlines, durations, schedules, billing, planning, reporting.

Most people use three of them. Today you learned all of them. That gap between “most people” and you? That’s your edge.

Now go open a spreadsheet and do something useful with it. The deadline is closer than you think — and thanks to NETWORKDAYS, you now know exactly how much closer.

Here’s a cheatsheet for your troubles: https://blog.stibelman.com/excel-date-time-functions-cheatsheet/

Shay Stibelman is a digital consultant based in Milan, Italy. He helps businesses work smarter with the tools they already pay for — and occasionally writes 4,000-word articles about Excel dates because someone has to, and he has a thing about people losing time to easily solvable problems.

VLookup and XLookup – The definitive guide

Everything you ever wanted to know, explained in plain human terms, with real examples, and without making you cry in front of an Excel spreadsheet.

Every year, millions of people open Excel, stare at two separate tables, and think: “there must be a way to connect these things without copying them one by one.” There is. It’s called VLOOKUP. And for a few years now there’s also XLOOKUP, which does the same thing but without the embarrassing flaws. This is the guide nobody ever made you read before leaving you alone with a #N/A error and a ruined Tuesday afternoon.

VLOOKUP: the classic that never goes out of style (but throws tantrums)

VLOOKUP stands for Vertical Lookup. In practice: you give it a value, it goes and finds it in a column of a table, and returns the corresponding value from another column in the same row. Like a waiter who looks up your name on the reservation list and tells you which table you’re sitting at.

Simple in theory. In practice, as we’ll see, that waiter sometimes says #N/A and disappears into the kitchen.

The full syntax

VLOOKUP(lookup_value; table_array; col_index_num; [range_lookup])
ParameterWhat it doesExample
lookup_value – requiredThe value you want to look up. Can be text, a number, or a cell reference.A2 (the cell containing the employee code)
table_array – requiredThe table to search in. Important: the lookup column MUST be the first column (leftmost) of this selection.B2:E500 or HRTable[#All]
col_index_num – requiredThe column number within the table from which to return the result. If the table has 4 columns and you want the third, type 3.3 (returns the value from the 3rd column)
range_lookup – optionalFALSE = exact match (almost always what you want). TRUE = approximate match (useful for brackets, e.g. taxes, score ranges). Default: TRUE, so always type FALSE if you’re not sure.FALSE

Classic trap

The range_lookup parameter defaults to TRUE. This means that if you forget it, Excel will perform an approximate match. On unsorted data, this produces wrong results without warning you. No error. Silently. Like a colleague who misunderstood the instructions but won’t admit it.

Basic VLOOKUP example

VLOOKUP(A2; SalaryTable; 3; FALSE)
→ Looks up the code in A2 in the first column of SalaryTable, returns the value from the 3rd column

Pro Tip

Always use structured table references (Table1[Column]) instead of hard-coded ranges (B2:E500). If you add rows to the table, the formula updates automatically. If you use a hard-coded range, you’ll have to remember to update it manually — and you will definitely forget at the worst possible moment.

XLOOKUP: the younger sibling who turned out better

XLOOKUP arrived in 2019 with Microsoft 365 and fixed virtually all of VLOOKUP’s structural problems. It’s not just “a newer VLOOKUP” — it’s a completely redesigned function that works differently, more flexibly, and more intuitively.

If VLOOKUP is the waiter who searches the list from top to bottom and can only look to the right, XLOOKUP is the maître d’ who can look anywhere, tell you if you’re not on the list without making a scene, and even search starting from the end.

The full syntax

XLOOKUP(lookup_value; lookup_array; return_array; [if_not_found]; [match_mode]; [search_mode])
ParameterWhat it doesExample
lookup_value – requiredThe value you want to find. Identical to VLOOKUP.A2
lookup_array – requiredThe column (or row) to search in. Doesn’t have to be the first one. Can be any column in the table.ClientsTable[ID]
return_array – requiredThe column (or row) to return the result from. Completely separate from the lookup column. Can be to the left, to the right, anywhere.ClientsTable[ClientName]
if_not_found – optionalWhat to return if the value is not found. If omitted, returns #N/A. With this parameter, you can return custom text, zero, or anything else."Not found" or 0
match_mode – optional0 = exact match (default). -1 = exact or next smaller. 1 = exact or next larger. 2 = with wildcard characters (*, ?).0
search_mode – optional1 = first to last row (default). -1 = last to first (useful if you want the most recent occurrence). 2 or -2 = binary search (on sorted data, much faster).-1 (to find the most recent row)

Pro Tip

The if_not_found parameter alone is worth switching to XLOOKUP. The old IFERROR(VLOOKUP(...); "Not found") is verbose and repeats the formula twice. With XLOOKUP you write it once, clean, readable — and your colleagues will look at you with respect.

XLOOKUP(A2; ClientsTable[ID]; ClientsTable[ClientName]; "Client not registered")
→ Looks up A2 in the ID column, returns the ClientName. If not found: "Client not registered"

When to use one and when to use the other: 4 real examples

The short answer: always use XLOOKUP if your Excel supports it. But life is complicated, colleagues use older versions of Office, and sometimes there are legitimate reasons why VLOOKUP is still the right choice. Here they are.

VLOOKUP · Limitations

  • The lookup column must be the first one (leftmost)
  • References columns by number, not by name
  • No native error handling
  • Cannot search right to left
  • Cannot find the last occurrence

XLOOKUP · Advantages

  • Search in any column, return from any column
  • Uses column names, not arbitrary numbers
  • Built-in error handling with if_not_found
  • Searches in both directions
  • Finds the last occurrence with search mode -1

Example 1 · Library · VLOOKUP wins
File shared with colleagues on Excel 2016

The librarian has a catalogue with 8,000 books: ISBN code in column A, title in B, author in C, section in D. She needs to create a file that her part-time colleague — who uses Excel 2016 on the desktop computer in the basement — can open and use without errors.

XLOOKUP doesn’t exist in Excel 2016. If the librarian uses XLOOKUP, the colleague sees nothing but a #NAME? error on every cell. A potential diplomatic incident between floors. VLOOKUP wins here, full stop.

Solution · VLOOKUP (compatibility)
VLOOKUP(A2; Catalogue!A:D; 2; FALSE)
→ Looks up the ISBN in A2, returns the title (column 2). Works on any version of Excel.

Pro Tip

If you’re not sure which version of Excel your colleagues are using, go to File → Save As and check for a compatibility warning. Or just ask them directly. It’s socially acceptable.

Example 2 · Medical Practice · XLOOKUP wins
The lookup column is not the first one

The administrator at a medical practice has a patient table: surname in column A, first name in B, tax ID in C, assigned doctor in D, date of last visit in E. She needs to look up patients by tax ID (column C) and return the doctor (column D).

With VLOOKUP, the lookup column must be the first one. The tax ID is in column C. So she would have to move the columns around — probably breaking other references — or use the classic INDEX+MATCH trick. Or simply use XLOOKUP, which doesn’t have this problem.

Solution · XLOOKUP (search on any column)
XLOOKUP(F2; PatientsTable[TaxID]; PatientsTable[AssignedDoctor]; "Patient not found")
→ Looks up the tax ID in F2 in the TaxID column, returns the doctor. No need to move columns.

Example 3 · School · XLOOKUP wins
Finding the last occurrence (the most recent grade)

The school office keeps a grade register with thousands of rows: every time a teacher enters a grade, they add a row. The same student has dozens of rows. The principal wants to know the last grade entered for each student — i.e. the most recent one, which is the lowest occurrence in the table.

VLOOKUP always finds the first occurrence from the top. There is no native way to make it find the last one. With XLOOKUP, just set the search mode to -1: it searches from the last row upwards, so it finds the most recent occurrence.

Solution · XLOOKUP (last occurrence)
XLOOKUP(A2; GradeRegister[StudentID]; GradeRegister[Grade]; "No grade"; 0; -1)
→ Mode -1: searches from the last row. Returns the student's most recent grade.

Pro Tip

The -1 mode in XLOOKUP is also useful in help desks and warehouses to find the latest transaction or the most recent status update on a ticket or order. Whenever you have time-based data with duplicates and want the latest entry, think XLOOKUP with mode -1.

Example 4 · Shop / Point of Sale · VLOOKUP wins
Simplified tables with a fixed structure

The store manager has a price table with product code in column A and price in column B. Two columns. He’s used it for years. The structure never changes. He sends it every week to three branches, all of which run different versions of Excel — including a tablet running Excel Mobile.

In this case VLOOKUP is perfectly adequate and universally compatible. There’s no column constraint to work around, no need for advanced error handling, no reverse search. Using XLOOKUP here adds nothing and risks breaking the file on older devices. Simplicity wins.

Solution · VLOOKUP (simplicity and compatibility)
VLOOKUP(A2; PriceList!A:B; 2; FALSE)
→ Looks up the product code, returns the price. Works everywhere, including Excel Mobile.

“The right function isn’t always the newest one. It’s the one that solves the problem without creating new ones.”

XLOOKUP and VLOOKUP inside other functions: 3 examples

So far we’ve used lookup functions on their own. But Excel becomes truly powerful when you start using them as ingredients inside larger formulas. The looked-up value becomes the input for a calculation, a condition, or another function. These three situations will almost certainly come up for you.

Nesting 1 · HR Office · IF + XLOOKUP
Conditional bonus calculation based on employee level

The HR department needs to calculate the end-of-year bonus. The rule: if the employee’s level (retrieved from the HR table) is “Senior”, a 15% bonus is applied to the base salary. Otherwise, no bonus.

A naive approach: first make a column with XLOOKUP to retrieve the level, then make another column with IF that reads that column. Result: two columns, double the work, double the chance of making a mistake.

The correct approach: use XLOOKUP directly as an argument of IF. The IF function evaluates the result of XLOOKUP without you needing to see it in a separate cell.

Formula · IF(XLOOKUP(...))
IF(
XLOOKUP(A2; HRTable[ID]; HRTable[Level])= "Senior";
B2 * 1.15;
B2
)
→ If the level found is "Senior" → salary + 15%. Otherwise → salary unchanged.

The formula updates automatically every time the HR table is modified. No manual copy-pasting. No helper columns. No Tuesday afternoon spent updating things by hand.

Pro Tip

This pattern — IF(XLOOKUP(...)="value"; action_if_true; action_if_false) — is one of the most useful patterns in all of Excel. Learn it by heart. Use it every time you need to make a decision based on data that lives in another table.


Nesting 2 · Pharmacy / Warehouse · SUMIF + VLOOKUP
Summing stock for all products belonging to a category

The pharmacy warehouse manager has a stock table with product code, quantity, and category. He needs to create a summary showing the total quantity for each category. But he doesn’t have the category directly in the right column — he needs to retrieve it from the product table for each item.

The solution is to use VLOOKUP as the criteria argument in SUMIF, or — even more elegantly — build a helper column with VLOOKUP and then use it as the criteria. Here we show the helper column approach, which is more readable and less error-prone.

Helper column · Retrieving the category
VLOOKUP(A2; ProductTable!A:C; 3; FALSE)
→ Retrieves the category for each product code. You now have the category in column D.
Final formula · SUMIF on the category column
SUMIF(D:D; "Painkillers"; B:B)
→ Sums all quantities (column B) where the category (column D) is "Painkillers".

Result: a dynamic category summary that updates every time the stock or product table changes. The warehouse manager no longer has to calculate anything by hand and can stop using the phone calculator he keeps hidden under the counter.

Nesting 3 · Help Desk · TEXT + XLOOKUP
Building automatic messages with data pulled from a table

The help desk operator needs to automatically generate a summary text for each ticket: “Ticket #1042 — Client: John Smith — Priority: High — Assigned to: Julia M.” The ticket ID is in column A, all other data is in a separate table.

The solution is to use multiple XLOOKUPs inside a CONCATENATE function (or directly with the & operator), building the string piece by piece with data retrieved from the table.

Formula · Building a message with nested XLOOKUP
"Ticket #"&A2&" — Client: "&
XLOOKUP(A2; Tickets[ID]; Tickets[Client]) &
" — Priority: "&
XLOOKUP(A2; Tickets[ID]; Tickets[Priority]) &
" — Assigned to: "&
XLOOKUP(A2; Tickets[ID]; Tickets[Operator])
→ Result: "Ticket #1042 — Client: John Smith — Priority: High — Assigned to: Julia M."

Pro Tip

This approach is the foundation for building email templates, automated reports, or printable labels directly from Excel. Every time you find yourself copying data by hand to fill in the same text over and over, think of this pattern.

Other functions inside XLOOKUP: 3 examples

Now let’s go the other way: functions nested inside XLOOKUP. Instead of providing a static value to look up, you provide the result of a formula. This allows you to perform dynamic lookups, transform data before searching, or calculate the lookup value on the fly.

Inside LOOKUP 1 · Warehouse / Logistics · XLOOKUP with NETWORKDAYS
Calculating the expected delivery date based on supplier lead time

The logistics manager has a supplier table with supplier ID and lead time in days. For each order he wants to calculate the expected delivery date: order date + supplier lead time, skipping weekends and public holidays. All in a single cell, with no helper columns.

The solution: nest XLOOKUP as an argument of WORKDAY, which calculates a future working date by adding a number of working days to a start date. The days are pulled dynamically from the supplier table via XLOOKUP.

Formula · WORKDAY(date; XLOOKUP(supplier))
WORKDAY(
B2; ← order date
XLOOKUP(A2; Suppliers[ID]; Suppliers[LeadDays]; 0)
)
→ Adds the supplier's lead time working days to the order date. If the supplier doesn't exist: 0 days added.

The if_not_found = 0 parameter of XLOOKUP ensures that new suppliers not yet in the table don’t generate errors — the delivery date simply matches the order date, implicitly signalling that data is missing.

Pro Tip

WORKDAY accepts an optional third parameter: a list of public holidays. If you have a column with national holidays (Christmas, bank holidays, etc.), add it there and the function will automatically skip them in its calculations.


Inside LOOKUP 2 · Sales Office · XLOOKUP with UPPER and TRIM
Finding a client even when the name has been typed incorrectly

The sales rep receives emails with client company names written in different ways: sometimes all caps, sometimes with extra spaces, sometimes with mixed capitalisation. The CRM table stores names in uppercase with no extra spaces. A direct lookup fails because "mario srl" ≠ "MARIO SRL".

The solution is to normalise the lookup value before passing it to XLOOKUP, using UPPER to convert everything to uppercase and TRIM to remove extra spaces. Both functions are nested as the first argument of XLOOKUP.

Formula · XLOOKUP(UPPER(TRIM(...)))
XLOOKUP(
UPPER(TRIM(A2));
CRM[ClientName];
CRM[SalesRep];
"Client not found in CRM"
)
→ Normalises the text in A2 before searching. " mario srl " becomes "MARIO SRL" and is found.

Watch out

This only works if the data in the lookup column of the CRM table is also in uppercase with no extra spaces. If the data there is inconsistent too, you’ll need to apply the same normalisation to the lookup column as well — and at that point it’s better to clean the data at the source rather than doing acrobatics with formulas.

Inside LOOKUP 3 · School · XLOOKUP with TODAY and date comparison
Automatically finding the teacher on duty based on today’s date

The school office has a table with supervision duty dates and the name of the teacher assigned to each date. Every morning someone opens the file and wants to immediately know who is on duty today, without manually searching through the table.

The solution is to use the TODAY() function as the lookup value inside XLOOKUP. TODAY() always returns the current date, so the formula automatically finds the teacher on duty for the day the file is opened. Zero manual interaction.

Formula · XLOOKUP(TODAY(); ...)
XLOOKUP(
TODAY();
Duties[Date];
Duties[TeacherOnDuty];
"No duty scheduled for today"
)
→ Every time the file is opened, it automatically shows the teacher on duty for today.

The if_not_found parameter handles weekends and unscheduled days without generating errors — essential if the file gets opened on a Saturday by an anxious deputy head.

Pro Tip

This same pattern — XLOOKUP(TODAY(); ...) — works for any table with dates: seasonal opening hours, prices that change by period, resource availability by date. It’s one of the most underrated and most useful patterns in Excel.

Summary: what to take away

If you had to explain all of this to a colleague in three minutes by the coffee machine, here’s what you’d say:

VLOOKUP is stable, universal, and works on any version of Excel. It has two major limitations: the lookup column must be the first one, and it doesn’t handle errors natively. It’s perfectly fine for simple tables and files shared with people using older versions of Excel.

XLOOKUP is the modern version without those limitations. It searches in any column, handles missing values with the if_not_found parameter, can search from the last row, and is much easier to read. Use it whenever your Excel supports it (Microsoft 365 and Excel 2021 onwards).

Nesting: both functions become far more powerful when you combine them with IF, SUMIF, TEXT, CONCATENATE as outer functions, or with TODAY, UPPER, TRIM, WORKDAY as inner arguments. Learn the patterns, not the individual formulas.

And the next time you see #N/A, don’t kick the computer. First check whether there’s an invisible space. It almost always is. Almost always.

Final Pro Tip

Select a cell with the value that isn’t being found, press F2 to enter edit mode, and look carefully at the edges of the text: if the cursor starts slightly to the right of the first character, there’s a leading space. Use TRIM and live happily ever after.

CERCA.VERT e CERCA.X: La Guida Definitiva

Tutto quello che avreste voluto sapere, spiegato in modo umano, con esempi veri, e senza farvi piangere davanti al foglio Excel.

Ogni anno, milioni di persone aprono Excel, guardano due tabelle separate, e pensano: “ci deve essere un modo per collegare queste cose senza copiarle a mano una per una.” C’è. Si chiama CERCA.VERT. E da qualche anno c’è anche CERCA.X, che è la stessa cosa ma senza i difetti imbarazzanti. Questa è la guida che nessuno vi ha mai fatto leggere prima di lasciarvi soli con un #N/D e un martedì pomeriggio distrutto.

CERCA.VERT: il classico che non passa mai di moda (ma che fa i capricci)

CERCA.VERT significa Cerca Verticalmente. In pratica: date un valore, vi va a cercarlo in una colonna di una tabella, e vi restituisce il valore corrispondente da un’altra colonna della stessa riga. Come un cameriere che cerca il vostro nome sulla lista prenotazioni e vi dice a che tavolo siete seduti.

Semplice in teoria. In pratica, come vedremo, quel cameriere a volte vi dice #N/D e sparisce in cucina.

La sintassi completa

CERCA.VERT(valore; matrice_tabella; indice_colonna; [corrisp_intervallo])
ParametroCosa faEsempio
valore – obbligatorioIl valore che volete cercare. Può essere un testo, un numero, o un riferimento a cella.A2 (la cella che contiene il codice dipendente)
matrice_tabella – obbligatorioLa tabella in cui cercare. Attenzione: la colonna di ricerca DEVE essere la prima colonna (quella più a sinistra) di questa selezione.B2:E500 oppure TabellaHR[#Tutto]
indice_colonna – obbligatorioIl numero della colonna della tabella da cui prendere il risultato. Se la tabella ha 4 colonne e volete la terza, scrivete 3.3 (restituisce il valore dalla 3ª colonna)
corrisp_intervallo facoltativoFALSO = cerca corrispondenza esatta (quasi sempre quello che volete). VERO = cerca corrispondenza approssimativa (utile per scaglioni, es. tasse, fasce di punteggio). Default: VERO, quindi scrivete sempre FALSO se non siete sicuri.FALSO

Trappola classica

Il parametro corrisp_intervallo ha default VERO. Questo significa che se ve lo dimenticate, Excel farà una ricerca approssimativa. Su dati non ordinati, questo produce risultati sbagliati senza avvisarvi. Senza errore. In silenzio. Come un collega che ha capito male le istruzioni ma non lo ammette.

Esempio base di CERCA.VERT

CERCA.VERT(A2; TabellaStipendi; 3; FALSO)
→ Cerca il codice in A2 nella prima colonna di TabellaStipendi, restituisce il valore dalla 3ª colonna

Pro Tip

Usate sempre i riferimenti di tabella strutturata (Tabella1[Colonna]) invece dei range rigidi (B2:E500). Se aggiungete righe alla tabella, la formula si aggiorna da sola. Se usate il range rigido, dovete ricordarvi di aggiornarlo manualmente, e sicuramente ve ne dimenticherete nel momento peggiore.

CERCA.X: il fratello minore che è cresciuto meglio

CERCA.X è arrivato nel 2019 con Microsoft 365 e ha risolto praticamente tutti i problemi strutturali di CERCA.VERT. Non è solo “un CERCA.VERT più nuovo” — è una funzione completamente ripensata che funziona in modo diverso, più flessibile e più umano.

Se CERCA.VERT è il cameriere che vi cerca sulla lista dal basso verso l’alto e può guardare solo a destra, CERCA.X è il maitre che può guardare ovunque, dirvi se non siete in lista senza fare scene, e persino cercare partendo dalla fine.

La sintassi completa

CERCA.X(valore; matrice_ricerca; matrice_restituzione; [se_non_trovato]; [modalità_corrispondenza]; [modalità_ricerca])
ParametroCosa faEsempio
valore obbligatorioIl valore che volete trovare. Identico a CERCA.VERT.A2
matrice_ricerca obbligatorioLa colonna (o riga) in cui cercare. Non deve essere per forza la prima. Può essere qualsiasi colonna della tabella.TabellaClienti[ID]
matrice_restituzione obbligatorioLa colonna (o riga) da cui prendere il risultato. Completamente separata dalla colonna di ricerca. Può essere a sinistra, a destra, ovunque.TabellaClienti[NomeCliente]
se_non_trovato facoltativoCosa restituire se il valore non viene trovato. Se omesso, restituisce #N/D. Con questo parametro, potete restituire testo personalizzato, zero, o qualsiasi altra cosa."Non trovato" oppure 0
modalità_corrispondenza facoltativo0 = corrispondenza esatta (default). -1 = esatta o prossimo minore. 1 = esatta o prossimo maggiore. 2 = con caratteri jolly (*, ?).0
modalità_ricerca facoltativo1 = dalla prima all’ultima riga (default). -1 = dall’ultima alla prima (utile se volete l’occorrenza più recente). 2 o -2 = ricerca binaria (su dati ordinati, molto più veloce).-1 (per trovare la riga più recente)

Pro Tip

Il parametro se_non_trovato da solo vale già il passaggio a CERCA.X. Il vecchio SE.ERRORE(CERCA.VERT(...); "Non trovato") è verbose e ripete la formula due volte. Con CERCA.X lo scrivete una volta sola, pulito, leggibile, e i vostri colleghi vi guarderanno con rispetto.

CERCA.X(A2; TabellaClienti[ID]; TabellaClienti[NomeCliente]; "Cliente non registrato")
→ Cerca A2 nella colonna ID, restituisce il NomeCliente. Se non esiste: "Cliente non registrato"

Quando usare uno e quando usare l’altro: 4 esempi reali

La risposta breve: usate sempre CERCA.X se il vostro Excel lo supporta. Ma la vita è complicata, i colleghi usano versioni vecchie di Office, e a volte esistono motivi legittimi per cui CERCA.VERT è ancora la scelta giusta. Eccoli.

CERCA.VERT · Limiti

  • La colonna di ricerca deve essere la prima (a sinistra)
  • Si riferisce alle colonne per numero, non per nome
  • Nessuna gestione nativa degli errori
  • Non cerca da destra verso sinistra
  • Non trova l’ultima occorrenza

CERCA.X · Vantaggi

  • Cerca in qualsiasi colonna, restituisce da qualsiasi colonna
  • Usa nomi di colonna, non numeri arbitrari
  • Gestione errori integrata con se_non_trovato
  • Cerca in entrambe le direzioni
  • Trova l’ultima occorrenza con modalità -1

Esempio 1 · Biblioteca · Vince CERCA.VERT
File condiviso con colleghi su Excel 2016

La bibliotecaria ha un catalogo con 8.000 libri: codice ISBN nella colonna A, titolo in B, autore in C, reparto in D. Deve fare un file che anche la collega part-time — che usa Excel 2016 sul computer fisso del piano -1 — possa aprire e usare senza errori.

CERCA.X non esiste in Excel 2016. Se la bibliotecaria usa CERCA.X, la collega vede solo un errore #NOME? su ogni cella. Possibile scenario di crisi diplomatica tra piani. Qui vince CERCA.VERT, punto.

Soluzione · CERCA.VERT (compatibilità)
CERCA.VERT(A2; Catalogo!A:D; 2; FALSO)
→ Cerca l'ISBN in A2, restituisce il titolo (colonna 2). Funziona su qualsiasi versione di Excel.

Pro Tip

Se non siete sicuri di quale versione di Excel usino i vostri colleghi, andate su File → Salva con nome e guardate se c’è un avviso di compatibilità. O chiedete direttamente. È socialmente accettabile.

Esempio 2 · Ambulatorio Medico · Vince CERCA.X
La colonna di ricerca non è la prima

L’amministrativa dell’ambulatorio ha una tabella pazienti: cognome in colonna A, nome in B, codice fiscale in C, medico di riferimento in D, data ultima visita in E. Deve cercare i pazienti per codice fiscale (colonna C) e restituire il medico (colonna D).

Con CERCA.VERT, la colonna di ricerca deve essere la prima. Il codice fiscale è in colonna C. Quindi dovrebbe spostare le colonne, rompendo probabilmente altri riferimenti, oppure usare il classico trucco INDEX+CONFRONTA. Oppure — semplicemente — usare CERCA.X che non ha questo problema.

Soluzione · CERCA.X (ricerca su qualsiasi colonna)
CERCA.X(F2; TabellaPazienti[CodiceFiscale]; TabellaPazienti[MedicoRiferimento]; "Paziente non trovato")
→ Cerca il CF in F2 nella colonna CF, restituisce il medico. Nessun bisogno di spostare colonne.

Esempio 3 · Scuola · Vince CERCA.X
Trovare l’ultima occorrenza (il voto più recente)

La segreteria scolastica tiene un registro voti con migliaia di righe: ogni volta che un professore inserisce un voto, aggiunge una riga. Lo stesso studente ha decine di righe. La dirigente vuole sapere l’ultimo voto inserito per ogni studente — cioè il più recente, che è l’occorrenza più in basso nella tabella.

CERCA.VERT trova sempre la prima occorrenza dall’alto. Non esiste modo nativo di fargli trovare l’ultima. Con CERCA.X basta impostare la modalità di ricerca a -1: cerca dall’ultima riga verso l’alto, quindi trova l’occorrenza più recente.

Soluzione · CERCA.X (ultima occorrenza)
CERCA.X(A2; RegistroVoti[IDStudente]; RegistroVoti[Voto]; "Nessun voto"; 0; -1)
→ Modalità -1: cerca dall'ultima riga. Restituisce il voto più recente dell'alunno.

Pro Tip

La modalità -1 di CERCA.X è anche utile negli help desk e nei magazzini per trovare l’ultima transazione o l’ultimo aggiornamento di stato su un ticket o un ordine. Ogni volta che avete dati temporali con duplicati e volete l’ultimo, pensate a CERCA.X con modalità -1.

Esempio 4 · Negozio / Punto Vendita · Vince CERCA.VERT
Tabelle semplificate con struttura fissa

Il responsabile del negozio ha una tabella prezzi con codice prodotto in colonna A e prezzo in colonna B. Due colonne. La usa da anni. La struttura non cambia mai. La deve inviare ogni settimana ai tre punti vendita che hanno tutti Excel diversi, incluso un tablet con Excel Mobile.

In questo caso CERCA.VERT è perfettamente adeguato e universalmente compatibile. Non c’è nessun vincolo di colonna da aggirare, nessuna necessità di gestione errori avanzata, nessuna ricerca inversa. Usare CERCA.X qui non aggiunge nulla, e rischia di rompere il file sui dispositivi più vecchi. Semplicità vince.

Soluzione · CERCA.VERT (semplicità e compatibilità)
CERCA.VERT(A2; ListinoPrezzi!A:B; 2; FALSO)
→ Cerca il codice prodotto, restituisce il prezzo. Funziona ovunque, anche su Excel Mobile.

“La funzione più giusta non è sempre la più nuova. È quella che risolve il problema senza crearne di nuovi.”

CERCA.X e CERCA.VERT dentro altre funzioni: 3 esempi

Finora abbiamo usato le funzioni CERCA da sole. Ma Excel diventa davvero potente quando iniziate a usarle come ingredienti all’interno di formule più grandi. Il valore cercato diventa l’input per un calcolo, una condizione, o un’altra funzione. Queste tre situazioni vi capiteranno quasi sicuramente.

Nidificazione 1 · Ufficio HR · SE + CERCA.X
Calcolo bonus condizionale basato sul livello del dipendente

Il reparto HR deve calcolare il bonus di fine anno. La regola: se il livello del dipendente (recuperato dalla tabella HR) è “Senior”, si applica un bonus del 15% sullo stipendio base. Altrimenti, nessun bonus.

Un approccio ingenuo: prima si fa una colonna con CERCA.X per recuperare il livello, poi si fa un’altra colonna con SE che legge quella colonna. Risultato: due colonne, doppio lavoro, doppia possibilità di sbagliare.

L’approccio corretto: si usa CERCA.X direttamente come argomento del SE. La funzione SE valuta il risultato di CERCA.X senza che voi abbiate bisogno di vederlo in una cella separata.

Formula · SE(CERCA.X(...))
SE(
CERCA.X(A2; TabellaHR[ID]; TabellaHR[Livello])= "Senior";
B2 * 1.15;
B2
)
→ Se il livello trovato è "Senior" → stipendio + 15%. Altrimenti → stipendio invariato.

La formula si aggiorna automaticamente ogni volta che la tabella HR viene modificata. Nessun copia-incolla manuale. Nessuna colonna di servizio. Nessun martedì pomeriggio dedicato ad aggiornare le cose a mano.

Pro Tip

Questo schema — SE(CERCA.X(...)="valore"; azione_se_vero; azione_se_falso) — è uno dei pattern più utili di tutto Excel. Imparatelo a memoria. Usatelo ogni volta che dovete prendere una decisione basata su un dato che si trova in un’altra tabella.


Nidificazione 2 · Farmacia / Magazzino · SOMMA.SE + CERCA.VERT
Sommare le scorte di tutti i prodotti appartenenti a una categoria

Il magazziniere della farmacia ha una tabella scorte con codice prodotto, quantità, e categoria. Deve creare un riepilogo che mostri la quantità totale per ogni categoria. Ma non ha la categoria direttamente nella colonna giusta — deve recuperarla dalla tabella prodotti per ogni articolo.

La soluzione è usare CERCA.VERT come argomento del criterio in SOMMA.SE, oppure — ancora più elegante — costruire una colonna ausiliaria con CERCA.VERT e poi usarla come criterio. In questo caso mostriamo l’approccio a colonna ausiliaria, che è più leggibile e meno soggetto a errori.

Colonna ausiliaria · Recupero categoria
CERCA.VERT(A2; TabellaProdotti!A:C; 3; FALSO)
→ Recupera la categoria per ogni codice prodotto. Ora avete la categoria in colonna D.
Formula finale · SOMMA.SE sulla colonna con la categoria
SOMMA.SE(D:D; "Antidolorifici"; B:B)
→ Somma tutte le quantità (colonna B) dove la categoria (colonna D) è "Antidolorifici".

Risultato: un riepilogo dinamico per categoria che si aggiorna ogni volta che cambiano le scorte o la tabella prodotti. Il magazziniere non deve più calcolare niente a mano e può smettere di usare la calcolatrice del telefono tenendola nascosta sotto il bancone.

Nidificazione 3 · Help Desk · TESTO + CERCA.X
Costruire messaggi automatici con dati presi da una tabella

L’operatore dell’help desk deve generare automaticamente un testo riepilogativo per ogni ticket: “Ticket #1042 — Cliente: Mario Rossi — Priorità: Alta — Assegnato a: Giulia M.” L’ID ticket è in colonna A, tutti gli altri dati sono in una tabella separata.

La soluzione è usare più CERCA.X dentro una funzione CONCATENA (o direttamente con l’operatore &), costruendo la stringa pezzo per pezzo con i dati recuperati dalla tabella.

Formula · Costruzione messaggio con CERCA.X annidato
"Ticket #"&A2&" — Cliente: "&
CERCA.X(A2; Ticket[ID]; Ticket[Cliente]) &
" — Priorità: "&
CERCA.X(A2; Ticket[ID]; Ticket[Priorità]) &
" — Assegnato a: "&
CERCA.X(A2; Ticket[ID]; Ticket[Operatore])
→ Risultato: "Ticket #1042 — Cliente: Mario Rossi — Priorità: Alta — Assegnato a: Giulia M."

Pro Tip

Questo approccio è la base per costruire template di email, report automatici, o etichette stampabili direttamente da Excel. Ogni volta che vi trovate a copiare dati a mano per riempire un testo sempre uguale, pensate a questo pattern.

Altre funzioni dentro CERCA.X: 3 esempi

Ora andiamo dall’altra parte: funzioni annidate all’interno di CERCA.X. Invece di fornire un valore statico da cercare, fornite il risultato di una formula. Questo permette di fare ricerche dinamiche, trasformare i dati prima di cercarli, o calcolare il valore cercato al volo.

Dentro CERCA 1 · Magazzino / Logistica · CERCA.X con GIORNI.LAVORATIVI.TOT
Calcolare la data di consegna prevista in base al lead time del fornitore

Il responsabile logistico ha una tabella fornitori con ID fornitore e giorni di lead time. Per ogni ordine vuole calcolare la data di consegna prevista: data ordine + lead time del fornitore, saltando weekend e festivi. Il tutto in una cella sola, senza colonne di appoggio.

La soluzione: si annida CERCA.X come argomento di GIORNO.LAVORATIVO, che calcola una data lavorativa futura aggiungendo un numero di giorni lavorativi a una data di partenza. I giorni vengono presi dinamicamente dalla tabella fornitori tramite CERCA.X.

Formula · GIORNO.LAVORATIVO(data; CERCA.X(fornitore))
GIORNO.LAVORATIVO(
B2;← data dell'ordine
CERCA.X(A2; Fornitori[ID]; Fornitori[LeadDays]; 0)
)
→ Aggiunge i giorni lavorativi di lead time del fornitore alla data ordine. Se il fornitore non esiste: 0 giorni aggiunti.

Il parametro se_non_trovato = 0 di CERCA.X fa sì che i fornitori nuovi, non ancora in tabella, non generino errori: semplicemente la data di consegna coincide con la data dell’ordine, segnalando implicitamente che mancano dati.

Pro Tip

GIORNO.LAVORATIVO accetta un terzo parametro opzionale: l’elenco dei giorni festivi. Se avete una colonna con le festività nazionali (Natale, Ferragosto, ecc.), inseritela lì e la funzione le salterà automaticamente nei calcoli.


Dentro CERCA 2 · Ufficio Commerciale · CERCA.X con MAIUSC e ANNULLA.SPAZI
Cercare un cliente anche quando il nome è stato digitato male

Il commerciale riceve email con nomi di aziende cliente scritti in modi diversi: a volte tutto maiuscolo, a volte con spazi in più, a volte con maiuscole miste. La tabella CRM tiene i nomi in maiuscolo senza spazi extra. La ricerca diretta fallisce perché "mario srl" ≠ "MARIO SRL".

La soluzione è normalizzare il valore cercato prima di passarlo a CERCA.X, usando MAIUSC per convertire tutto in maiuscolo e ANNULLA.SPAZI per eliminare gli spazi superflui. Si annidano entrambe le funzioni come primo argomento di CERCA.X.

Formula · CERCA.X(MAIUSC(ANNULLA.SPAZI(...)))CERCA.X(
MAIUSC(ANNULLA.SPAZI(A2));
CRM[NomeCliente];
CRM[ResponsabileCommerciale];
"Cliente non trovato nel CRM"
)
→ Normalizza il testo in A2 prima di cercare. " mario srl " diventa "MARIO SRL" e viene trovato.

Attenzione

Questo funziona solo se anche i dati nella colonna di ricerca della tabella CRM sono in maiuscolo senza spazi. Se i dati sono disomogenei anche lì, dovete applicare la stessa normalizzazione anche alla colonna di ricerca — e a quel punto conviene pulire i dati alla fonte, non fare acrobazia con le formule.

Dentro CERCA 3 · Scuola · CERCA.X con OGGI e confronto date
Trovare automaticamente il docente di turno in base alla data odierna

La segreteria ha una tabella con le date dei turni di sorveglianza e il nome del docente assegnato per ciascuna data. Ogni mattina qualcuno apre il file e vuole sapere subito chi è di turno oggi, senza cercare manualmente nella tabella.

La soluzione è usare la funzione OGGI() come valore da cercare all’interno di CERCA.X. OGGI() restituisce sempre la data corrente, quindi la formula trova automaticamente il docente di turno per il giorno in cui viene aperto il file. Zero interazione manuale.

Formula · CERCA.X(OGGI(); ...)
CERCA.X(
OGGI();
Turni[Data];
Turni[DocenteDiTurno];
"Nessun turno programmato per oggi"
)
→ Ogni volta che il file viene aperto, mostra automaticamente il docente di turno per oggi.

Il parametro se_non_trovato gestisce i weekend e i giorni non programmati senza generare errori — fondamentale se il file viene aperto anche di sabato dal vicedirettore ansioso.

Pro Tip

Questo stesso schema — CERCA.X(OGGI(); ...) — funziona per qualsiasi tabella con date: orari di apertura stagionali, prezzi che cambiano per periodo, disponibilità di risorse per data. È uno dei pattern più sottovalutati e più utili di Excel.

Riepilogo: cosa portarsi a casa

Se doveste spiegare tutto questo a un collega in tre minuti davanti alla macchinetta del caffè, ecco cosa direste:

CERCA.VERT è stabile, universale, e funziona su qualsiasi versione di Excel. Ha due grandi limiti: la colonna di ricerca deve essere la prima, e non gestisce gli errori nativamente. Va benissimo per tabelle semplici e file condivisi con persone che usano Excel vecchio.

CERCA.X è la versione moderna e priva di quei limiti. Cerca in qualsiasi colonna, gestisce i valori non trovati con il parametro se_non_trovato, può cercare dall’ultima riga, e si legge molto più facilmente. Usatelo ogni volta che il vostro Excel lo supporta (Microsoft 365 e Excel 2021 in poi).

Nidificazione: entrambe le funzioni diventano molto più potenti quando le combinate con SE, SOMMA.SE, TESTO, CONCATENA come funzioni esterne, oppure con OGGI, MAIUSC, ANNULLA.SPAZI, GIORNO.LAVORATIVO come argomenti interni. Imparate i pattern, non le singole formule.

E la prossima volta che vedete #N/D, non prendete a calci il computer. Controllate prima se c’è uno spazio invisibile. Quasi sempre è quello. Quasi sempre.

Pro Tip Finale

Selezionate una cella con il valore non trovato, premete F2 per entrare in modifica, e guardate bene i bordi del testo: se il cursore parte un po’ più a destra del primo carattere, c’è uno spazio davanti. Usate ANNULLA.SPAZI e vivete felici.

NotebookLM Is Secretly Unhinged (And You’re Not Using It Right)

You’ve heard of NotebookLM. You might have even used it. You uploaded a PDF, asked it a question, it answered with a little footnote citation, you thought “huh, neat” — and then you closed the tab and went back to Googling things like a person who peaked in 2019.

That’s fine. No judgment. (Some judgment.)

Because here’s the thing: NotebookLM is not a smarter search engine. It’s not a fancy summarizer. It’s not even, really, a chatbot. What it actually is — once you stop using it at surface level — is closer to a private intelligence analyst that you’ve locked in a room with all your documents and told to figure everything out. And lately, that analyst has been getting some genuinely alarming upgrades.

This is the deep dive. The stuff the casual users don’t know. The part where NotebookLM goes from “oh that’s useful” to “wait, it can do what?”

Let’s go.

First: Why NotebookLM Is Fundamentally Different From Every Other AI Tool

Most AI tools work from what they already know. They’ve read the internet, absorbed billions of documents, and they answer your questions from that giant pile of training data. Which sounds great until you realize the giant pile includes Reddit arguments, SEO-optimized nonsense, and things that were true in 2022 and aren’t anymore. This is where hallucinations come from — the AI is pattern-matching from memory, not reading a source, and sometimes the memory is wrong. Confidently wrong. With full eye contact.

NotebookLM doesn’t do that. It’s “grounded” — meaning it only reasons from the sources you give it. Nothing else. No internet wandering, no drawing on general knowledge, no confident fabrications. Every answer it gives you comes with a citation that links directly to the specific paragraph in your document it pulled from. Every. Single. One.

This sounds like a limitation. It is actually a superpower. Because “accurate, verifiable, and specific to your actual material” is more useful than “knows everything vaguely” approximately 100% of the time when you’re doing real work.

And as of 2026, the platform supports up to 600 sources per notebook on paid tiers, with each source supporting up to 500,000 words. That’s not a notebook. That’s a library with a very fast librarian.

The Insane Things NotebookLM Can Actually Do

1. It Makes Podcasts. Real Ones. That You Can Interrupt.

At some point, someone at Google had the idea to make NotebookLM generate a two-host conversational podcast from your documents. This should have been a gimmick. It became one of the most viral AI features of the last two years, with over 10 million monthly users, because the output is genuinely unsettling in how natural it sounds — two AI hosts riffing, disagreeing slightly, going on tangents, synthesizing your 80-page report into a 12-minute conversation you’d actually listen to on a commute.

That alone is insane. But then they added Interactive Mode.

In Interactive Mode, you can join the podcast. Press a button mid-episode and become a third participant. The hosts pause. You ask a question. They answer it — from your sources, cited, grounded — and then continue. You’re essentially gate-crashing your own AI radio show to demand a deeper explanation of slide 14. This is either the future of learning or a sign that we’ve completely lost the plot, and honestly it might be both.

Power user move: don’t just generate one Audio Overview and call it done. Customize each one. Tell the hosts to “focus on the financial implications” or “take a more skeptical, contrarian tone” or “assume the listener already knows the basics.” Generate multiple episodes from the same notebook. You now have a podcast series about your own research. This is a normal thing to do apparently.

2. It Makes Videos. Cinematic Ones. From Your Documents.

The Video Overview feature uses Google’s Veo model to generate narrated, scripted, visually structured explainer videos from your notebook’s content. Not slideshows. Not text-to-speech over static images. Actual cinematic explainers — scripted narratives with visuals and narration built entirely from what’s in your sources.

For educators generating training content. For marketers turning a research report into a shareable video summary. For literally anyone who has ever thought “I need to explain this thing but I do not want to spend six hours in Premiere Pro” — this is the answer. In minutes. From a button.

What remains appropriately bananas is that the video knows your content. It’s not hallucinating a generic explainer — it’s constructing the narrative from your actual documents. Which means it’s wrong about as often as your documents are wrong, which is a much better baseline than “wrong about as often as a confident AI is wrong.”

3. You Can Give It a 10,000-Character Personality

Custom instructions in NotebookLM used to cap out at 500 characters — enough for “be concise and professional,” not enough for anything interesting. In 2026 that limit expanded to 10,000 characters. This changes the tool’s entire personality.

Power users maintain what amounts to a template library of AI personas. Not just “be professional” — entire system-level instructions that define the AI’s role, reasoning style, constraints, and output format. Some examples that are genuinely useful:

The Socratic Learning Coach — instead of giving you answers, it asks you questions about the material and provides corrections when you’re wrong. This is active recall, which is how you actually learn things, as opposed to reading a summary and thinking you’ve learned things (you haven’t).

The Senior Strategy Consultant — responds only in terms of SWOT analysis, actionable recommendations, and executive-level framing. No fluff. No “great question.” Just brutal strategic clarity.

The Devil’s Advocate Auditor — specifically instructed to push back on everything, find weaknesses in arguments, and surface assumptions the sources haven’t proven. You stop asking it “is this good?” and start asking it “why is this wrong?” and suddenly you’re doing much better research.

The point is that the same notebook, with different custom instructions, becomes a completely different tool. Most people set it once to “be helpful” and never touch it again. The power users swap personas the way a consultant switches hats depending on the meeting.

4. It Will Tell You What’s Missing From Your Research

Here’s a trick that feels slightly illegal in its usefulness: instead of asking NotebookLM to summarize what’s in your documents, ask it to identify what’s not there.

The “Source Gap” prompt works like this: “Based on the sources in this notebook, identify what information is missing, which claims are unproven, and where the sources contradict each other.”

You’ve just turned the AI into an auditor of your own research. It will surface blind spots you didn’t know you had. Claims you made that no source actually backs up. Sections where two documents disagree and you never noticed. For anyone writing a report, building a business case, or preparing for a presentation where someone smart is going to poke holes in your argument — this is the move.

Most people use AI to build things. This is using AI to stress-test them. Different, and considerably more valuable.

5. Cross-Notebook Intelligence (The “Second Brain” Setup)

For a long time, the notebook silo was NotebookLM’s most frustrating limitation. Your Marketing notebook couldn’t talk to your Finance notebook. Your Research notebook didn’t know about your Strategy notebook. Great for focus, terrible for synthesis.

The 2026 integration with the main Gemini app changed this. You can now “mount” multiple notebooks as live sources inside Gemini, then query across all of them simultaneously. Your marketing data and your financial data and your competitor analysis — all in the same conversation, synthesizing toward a single strategic question.

This is the “Second Brain” architecture that productivity nerds have been trying to build manually for years. NotebookLM just made it a feature. Query it right and you stop asking “where did I put that information?” entirely — you just ask the question and it knows.

6. The Recursive Knowledge Loop (This One’s Genuinely Clever)

Here’s an advanced workflow that will immediately make your output better and will feel slightly like cheating.

The problem with big research notebooks is noise. You’ve got 30 sources, the AI is synthesizing across all of them, and the output is comprehensive but sometimes muddier than you want. The solution is recursive refinement:

Step 1: Prompt the AI to synthesize everything into one structured master note — a single, clean document that captures only what matters. Export it to Google Docs. Review it. Clean it up. Make it exactly what you want the AI to work from.

Step 2: Upload that refined document back as a source. Deselect all the original raw sources. Now the notebook’s entire intelligence is grounded in your pre-refined “gold standard” document instead of the noisy originals.

Step 3: Generate your Audio Overview, slide deck, video, or whatever you need from this cleaned-up foundation.

The output quality jump is immediately noticeable. You’ve essentially pre-filtered the AI’s context so it only draws from the best version of your research. This is how the people generating suspiciously polished AI-assisted reports are doing it — they’re not just prompting harder, they’re managing the quality of what the AI reads.

7. The “Prompt as a Source” Hack

This one is beautifully silly and completely works.

NotebookLM’s chat window has a character limit. Complex multi-stage workflows with detailed instructions hit that limit fast. The workaround: write your entire workflow as a Google Doc — a 2,000-word set of instructions, references, multi-level logic, output formats, the works — and upload it as a source. Then in the chat, just type: “Execute the workflow described in Source 12.”

The AI reads the source, follows the instructions, and your complex workflow is now effectively unlimited in length. You’ve bypassed the character limit by turning your prompt into a document. It’s technically not a hack so much as using the tool correctly in a way nobody told you about.

8. It Will Transcribe Your Calls and Turn Them Into Deliverables

NotebookLM now supports audio and video uploads — MP3s, MP4s, YouTube links — and transcribes them directly into the notebook’s knowledge base. The transcription becomes a searchable, citable source, just like any document.

The use case that immediately clicks for consultants, coaches, and anyone who sits through a lot of meetings: upload your call recording, and within minutes you have a searchable transcript that you can query for specific moments, summarize into show notes, convert into a FAQ document, or turn into a blog post. Without a third-party transcription service. Without copying and pasting anything. Without reading an 87-minute meeting transcript with your own eyes like some kind of animal.

What makes this better than a standalone transcription tool is the integration. The transcript lives in the same environment as your other research, which means you can cross-reference it immediately. “What did the client say about budget constraints in the call, and how does that compare to what the competitive analysis says about pricing sensitivity?” That’s a real question you can now ask.

9. AI-Generated Slides That You Can Argue With

NotebookLM generates slide decks from your sources, which is useful. What most people don’t know is that you can then argue with the slides in the chat panel and make it redo specific ones.

After generating a deck, you can prompt: “Redo slide 4 to focus on the executive summary and make it more formal.” Or “Slide 7 has too much text — restructure it as a visual comparison.” The AI revises individual slides based on your feedback without regenerating the whole deck.

Power user move: export to PPTX for final polish. The AI gets you to 85% without any of the layout busywork. You take it the last 15% manually in PowerPoint or Slides like a normal person with slightly more dignity than someone who’s fully outsourced their presentations to a machine. (No shame to that person either. We’re all figuring this out.)

10. The Three-Tool Chain That Professional Researchers Use

NotebookLM is excellent at grounded synthesis. It is deliberately not a creative tool, because creativity requires the kind of unpredictability that makes grounded research less accurate. So don’t try to make it do everything.

The workflow that’s quietly becoming standard in research-heavy professional environments:

Perplexity for initial sourcing — it’s built for search and surfacing high-quality URLs fast.

NotebookLM for deep synthesis — import those URLs, cross-reference them with your internal documents, generate structured notes, audit for gaps.

Claude or ChatGPT for creative output — take NotebookLM’s refined, accurate synthesis and hand it to a more generative model for the actual writing, ideation, or creative drafting.

Each tool does what it’s best at. You stop asking one tool to do everything and getting mediocre results across the board. You get Perplexity’s search speed, NotebookLM’s accuracy, and Claude’s writing quality — in sequence, intentionally. This is not cheating. This is knowing your tools.

Pro Tips: The Stuff That Saves You Real Time

Set your custom instructions before you do anything else. Most people generate half a notebook’s worth of output and then realize the AI’s been responding in a style that doesn’t fit. Custom instructions first. Always.

Use white-label notebooks for team knowledge bases. Share a notebook with “Chat-only access” so colleagues can query it without touching your source structure. You’ve just built a searchable, cited company knowledge base that answers questions instantly. In an afternoon. For free.

Generate multiple Audio Overviews per notebook. Each one can take a different angle, tone, or audience. One for executives, one for your team, one for yourself on a run. Same data, completely different listening experience.

For Deep Research, use it to fill the 20% your internal docs don’t cover. Your internal documents probably have 80% of what you need for a project. Deep Research browses live websites to find the rest — competitor pricing, recent regulatory changes, industry benchmarks — and imports the results as a cited source directly into your notebook. Don’t use it to replace your internal research. Use it to complete it.

Build your persona template library and reuse it everywhere. A well-written 10,000-character custom instruction for “Senior Product Manager review mode” or “Socratic exam prep mode” takes 20 minutes to write and saves hours every time you use it. Write it once, paste it in whenever you need it.

The Bottom Line

NotebookLM started life as a clever note-taking tool and has quietly become something else entirely — a full-scale research and content production environment that most of its users are still treating like a fancy search bar.

The gap between what it can do and what most people use it for is enormous. The tips above close that gap. And once you close it, you’ll find it very hard to go back to managing research the old way — the tab-switching, copy-pasting, “where did I put that?” way that eats hours and produces mediocre output.

You now have no excuse. Go build a second brain. Argue with your slides. Join your own podcast. This is your life now.

Shay Stibelman writes about AI tools, digital productivity, and the increasingly blurry line between “working smarter” and “letting the robots do everything” — at blog.stibelman.com. He makes video tutorials for people who’d rather watch someone else figure it out first, which is still a completely valid strategy.

Coming up next: How to build a full content production workflow using only NotebookLM, Claude, and a dangerous amount of caffeine.

Stop using Claude to write for you

AI Is a Brilliant Editor. Stop Making It Do Your Homework.

Using Claude to sharpen your voice — not replace it

Let me describe something that happens approximately ten thousand times a day, in offices, universities, and home desks everywhere from Milan to Minneapolis.

Someone has to write something. A blog post, an email, an essay, a proposal. They open Claude (or whatever AI tool they’ve decided is their personality this week), type “write me a 500-word post about [topic],” and then copy whatever comes out, change maybe three words, and call it done.

Claude — bless its magnificent silicon heart — obliges. It produces text. Beautiful, structured, grammatically impeccable text. Text that sounds like it was written by someone who has read everything ever published but has never once been stuck in traffic, argued with a supplier, or eaten a disappointing sandwich.

And here’s the problem: that text sounds like it. Not like you.

Your professor notices. Your client notices. Your newsletter subscribers definitely notice — and quietly unsubscribe while making a face.

The issue isn’t the AI. The issue is how you’re using it. You’re hiring a ghostwriter when you need an editor. And the difference between those two things is everything.

What Actually Goes Wrong When AI Writes For You

Let’s do a quick experiment. Ask any AI to write something “professional” about, say, climate change. I’ll wait.

You got something back, right? And I’d bet good money it contained at least one of the following:

  • “multifaceted challenge”
  • “synergistic approach”
  • “stakeholder ecosystems”
  • Passive voice that nobody would use in actual speech
  • An opinion that was perfectly balanced on all sides, because the AI didn’t want to offend anyone

That last one is the killer. Because you have opinions. Actual, human, slightly-irrational-in-the-best-way opinions. And AI’s default instinct is to sand them down until they’re smooth, inoffensive, and completely forgettable.

The text isn’t bad, exactly. It’s just not yours. It sounds like a very polished press release written by a committee. And nobody — nobody — subscribes to a newsletter because they love press releases from committees.

There’s also the detection problem. AI detectors are getting very good. And even when they miss it technically, humans catch it instinctively. We’ve all developed a kind of radar for writing that’s technically correct but weirdly soulless. You know the feeling. You start reading something and thirty words in you think “…is this a robot?” and you’re right.

The Correct Way to Use Claude for Writing

Here’s the approach that actually works — and it’s three steps, none of which involve asking Claude to write anything from scratch.

Step 1: Write Your Messy Draft First

Open a document. Any document. Your notes app, a Google Doc, the back of an envelope if that’s what’s available.

Write your thoughts. Badly. In fragments. In bullet points. In whatever chaotic form they take when you’re thinking out loud. Don’t edit. Don’t filter. Don’t worry about structure or grammar or whether your sentences are complete.

Here’s what that looks like in practice:

- climate policy is infuriating because we know exactly what needs 
  to happen and just... don't
- renewables getting cheap fast, EVs catching up, good
- but governments still moving at glacial speed, bad
- feels like we keep having the same conversation for 20 years
- personally skeptical that individual action is the point, 
  think systemic change matters more
- young people justifiably angry about inheriting this mess

Is this beautiful prose? No. Does it sound like a human being who has thoughts and feelings about things? Absolutely yes. This is gold. This is the raw material.

Don’t skip this step. It’s the whole thing. If you start by asking Claude to write and then try to “edit it to sound like you,” you’re fighting uphill the entire time. You’re always reacting to Claude’s choices instead of expressing your own. Start with your voice, then refine it.

Step 2: Give Claude the Right Job Description

Most people mess this up here. They paste their notes into Claude and say “improve this” or “turn this into a paragraph.” Claude, desperately trying to be helpful, then rewrites everything and strips out all your personality in the process.

You need to be specific. You need to give Claude a role — and the role is editor, not author.

Here’s the prompt to copy and use:

“You are an editor, not a ghostwriter. Your job is to refine my draft for clarity, flow, and structure — while keeping my voice, my vocabulary, and my exact opinions completely intact.

Do NOT rewrite my ideas. Do NOT make them more formal if they’re casual. Do NOT soften or remove my opinions. If I write ‘honestly’ or ‘I think’ or ‘this is frustrating,’ keep it.

Here’s my draft:

[paste your bullet points here]

Output: a refined version that still sounds unmistakably like me.”

Notice what’s happening here. You’re not asking Claude to think for you. You’re asking it to help you express what you already think, more clearly. That’s a completely different request, and you get completely different results.

Pro tip: Add context about your tone. “I write casually and directly, I occasionally use sarcasm, and I never use the word ‘synergistic.'” The more specific your constraints, the better the output.

Step 3: Read It Out Loud and Fix What Doesn’t Sound Like You

Claude will give you something good. You’re not done.

Read the output out loud. Actually out loud, not in your head. Your ear will catch what your eye misses.

The moment you hit a sentence and think “I would never say that” — change it. Write it in your words. It doesn’t matter if Claude’s version was technically better. It matters that it sounds like a real person wrote it, and that person is you.

Things to watch for and delete immediately:

  • Any word ending in “-istic” that you didn’t put there yourself
  • Passive voice that appeared mysteriously (“it has been noted that…”)
  • Your strong opinion that somehow became “some argue that, while others believe…”
  • Sentences longer than you could comfortably say in one breath
  • Any phrase that sounds like it belongs in a McKinsey slide deck

The finished piece should sound like you on a good day — rested, clear-headed, having thought about the topic properly. Not like you replaced by a very polite robot.

Why Claude Specifically for This

I’ve tested a lot of AI tools on this particular task — the “refine my voice without removing my voice” ask — and Claude handles it noticeably better than most.

The reason, as far as I can tell: Claude actually reads the nuance in the instruction. When you say “keep my casual tone,” most models hear “casual” and nod along, and then hand you back something that’s still weirdly stiff. Claude seems to understand that “casual” means leaving in the contractions, the slightly-too-long sentences, the opinions stated plainly without hedging.

It also handles messy input well. You can paste in bullet points, sentence fragments, half-thoughts, and it will work with what’s there instead of panicking and defaulting to corporate-speak.

And — this is the important one — it knows the difference between “fix my grammar” and “rewrite my personality.” Tell it which one you want. It’ll listen.

Your Cheat Sheet

If you remember nothing else from this article, remember this:

1. Write messy notes first. Your ideas, your words, your opinions. No editing.

2. Paste into Claude as an editor prompt. Key phrase: “keep my voice, my vocabulary, and my exact opinions.”

3. Read the output out loud. Anything that doesn’t sound like you? Change it yourself.

4. The signature stays yours. Because you did the thinking. Claude just helped you express it better.

The Prompt Library (Copy These)

Save these. Adapt them as needed.

For essays and academic writing:

“Edit this draft for clarity, structure, and flow. Keep my voice, my arguments, and my word choices. Don’t make it more formal or academic than it already is. Flag anything that’s unclear, but don’t replace my ideas. Draft: [paste here]”

For professional emails:

“You’re an editor. Tighten this email draft — it still needs to sound like ME, not a corporate template. Keep my tone [casual/direct/warm]. Remove the unnecessary parts. Don’t add phrases like ‘as per my previous email’ unless I wrote them. Draft: [paste here]”

For social media and blog posts:

“Edit this draft for flow and clarity. My writing style is [casual/sarcastic/conversational] — preserve it at all costs. Don’t polish it so much it loses personality. Draft: [paste here]”

For creative writing:

“Act as a line editor, not a co-author. Suggest improvements to sentence rhythm and word choice, but don’t change the story, the voice, or the style. If something is intentionally unconventional, leave it. Draft: [paste here]”

The Bottom Line

Every great writer has an editor. Hemingway had Maxwell Perkins. Every major author you’ve ever admired went through someone else’s red pen before their work reached you.

Your editor now happens to live in the cloud, responds in under three seconds, and has read approximately everything. That’s not a replacement for your brain — it’s a superpower for your brain.

Use it. But use it correctly.

Write first. Let Claude refine. Read it out loud. Fix what doesn’t sound like you.

And for the love of everything — delete the word “synergistic” every single time it appears. Without exception. It has never improved a sentence. It never will.

Role: You are a Senior Copy Editor specializing in stylistic preservation.

Objective: Refine the provided draft for clarity, structural flow, and grammatical precision.

Strict Constraints:

Voice Preservation: Do not sanitize or formalize the tone. If the draft is casual, keep it casual. If it is provocative, keep it provocative.

Vocabulary & Syntax: Retain my specific word choices and sentence structures (e.g., phrases like "I think" or "Honestly" must remain).

No Content Alteration: Do not rewrite my ideas, soften my opinions, or add external perspectives. Your job is to polish the "vessel," not change the "liquid" inside.

Structural Flow: Only adjust transitions and organization to ensure the argument is easy to follow without losing the author’s original intent.

Draft for Review:

[Paste your bullet points/text here]

Requested Output: A polished version of the text that remains unmistakably mine in tone and conviction.

Shay Stibelman is a digital marketing consultant based in Milan, Italy. He helps businesses get smarter with the tools they already have — and occasionally yells at AI output that uses the word “multifaceted” without provocation.

Stop Typing Descriptions Like a Caveman: The Wildest AI Image Tricks Nobody Told You About

So you’re generating AI images by typing things like “a beautiful sunset, cinematic, dramatic lighting, 8k, masterpiece.” And you’re getting… something. Something that sort of looks like what you wanted, if you squint, tilt your head, and lower your expectations.

Meanwhile, other people — the suspiciously talented ones who keep posting incredible AI visuals online and acting like it’s nothing — are doing things that make your workflow look like cave painting. Literally describing images in code. Decomposing photos into layers like it’s Photoshop 3000. Cloning an entire visual style and then changing only the color of someone’s shirt with a text command.

This article is about those tricks. And by the end of it, you’ll either be one of those people, or you’ll at least understand why they’re insufferably smug about their AI-generated product shots.

Let’s get into it.

First, a Very Quick Reality Check

AI image generation in 2025 is not what it was two years ago. We’ve gone from “impressive but kinda weird fingers” to full-blown professional-grade visual engines that can maintain character consistency, render legible text (yes, finally), and edit specific elements of an image without touching the rest.

The tools you need to know about right now: Nano Banana (Google’s Gemini 2.5 Flash Image model, which yes, is actually called that, and no, that name will never not be funny), FLUX.1 Kontext and FLUX.2 from Black Forest Labs, and Qwen-Image-Layered from Alibaba’s Qwen team.

Each one does something that should probably not exist yet. All of them are either free or very cheap. And none of your colleagues know about most of this. You’re welcome.

Trick #1: JSON Prompting — Because “Cinematic Vibes” Is Not a Professional Standard

Here’s the dirty secret of AI image generation: natural language prompts are great for brainstorming, and terrible for repeatability.

You write “futuristic office, moody lighting, professional” and you get something cool. You try to recreate it tomorrow? Different model weights, different random seed, slightly different output. Your “brand consistency” is just vibes at that point.

Enter JSON prompting — and specifically, what it does on Nano Banana.

Nano Banana is built on Gemini 2.5 Flash, which was trained extensively on structured data formats including JSON. This means when you feed it a prompt in JSON format instead of plain text, the model parses it with significantly more precision. Research in 2025 showed that structured prompts improve accuracy on complex tasks by a wide margin — and when you use them correctly, the results are borderline eerie.

Here’s what a basic JSON prompt looks like:

{
  "scene": "minimalist tech startup office, open plan, floor-to-ceiling windows",
  "resolution": "4K",
  "aspect_ratio": "16:9",
  "style": "editorial photography, clean, modern, natural light",
  "mood": "calm, focused, professional"
}

That’s already better than “make it look professional lol.” But here’s where it gets genuinely clever.

The Clone-and-Swap Trick

Want to generate the same image ten times but change only one variable? Say you’re making a product ad and you want to test five different background colors, three different copy headlines, and two different lighting setups. Normally this means ten separate prompt sessions and ten rounds of “why doesn’t this look consistent with the last one.”

With JSON, you build a master template and literally swap out one field at a time:

{
  "scene": "product flat lay, skincare bottle on marble surface",
  "resolution": "4K",
  "aspect_ratio": "1:1",
  "background_color": "dusty rose",
  "lighting": "soft diffused natural light",
  "text_elements": [
    {
      "text": "Pure. Simple. Yours.",
      "position": "bottom center",
      "font_style": "light serif, elegant"
    }
  ]
}

Now change "dusty rose" to "sage green". Regenerate. Change the tagline. Regenerate. You’re not re-describing the whole scene from scratch — you’re editing a config file. This is how product teams generate entire visual catalogs from a single master prompt.

Pro tip on canvas definition

Always define resolution and aspect ratio first. The biggest beginner mistake is skipping this, which results in the model choosing for you — and then you wonder why everything comes out in a slightly odd crop that works for nothing. You can specify 1K, 2K, or 4K. Specify it. Always.

The text rendering game-changer

Nano Banana’s other secret weapon is that it can actually render legible text inside images — something most AI image models handle like a toddler with a Sharpie. But it only works reliably when you use the text_elements array in your JSON prompt, specifying the exact text, position, font style, and size. Vague is the enemy here. Be surgical.

Trick #2: FLUX.1 Kontext — The AI That Finally Listens

You know what’s maddening about most AI image editing? You say “change the jacket to red” and it changes the jacket to red, turns the background slightly warmer, shifts the face a little to the left, and replaces your subject’s nose with something you didn’t ask for.

That’s because traditional inpainting tools work by masking a region, then generating everything from scratch inside that mask. Which sounds fine until you realize “generate from scratch” means the AI gets to make a bunch of decisions you didn’t ask for.

FLUX.1 Kontext does something different. It performs what’s called instruction-based image editing — you tell it what to change, it changes that specific thing and leaves the rest of the image physically untouched. Not “mostly untouched.” Actually untouched.

Tell it “change the shirt color to red.” It changes the shirt. Tell it “remove the glasses.” It removes the glasses and fills in the face correctly. Tell it “swap the background to a rainy London street.” It swaps the background. The character stays the same. The lighting adjusts to match. Nothing drifts.

This is huge for anyone who works iteratively. Which is everyone who makes images professionally.

The Conversational Editing Workflow

Here’s the trick most people miss: because Kontext maintains context across edits, you can stack instructions like a conversation. Start with your base image. Then:

  1. “Add a coffee cup to the table on the left.”
  2. “Make it nighttime outside the window.”
  3. “Give the person a slightly more formal outfit.”
  4. “Add soft lamp lighting from the right.”

Each step builds on the previous result. You’re not regenerating from scratch each time — you’re directing, like a photographer giving notes to a set designer in real time. The creative process actually feels like a creative process instead of a slot machine.

Why the speed matters more than you think

Kontext generates at under 10 seconds per edit. That sounds like a spec-sheet detail, but it’s actually what makes iterative editing viable. When each edit takes 30+ seconds, you stop experimenting. You commit too early. You end up with “good enough.” At under 10 seconds, you iterate freely, and free iteration is where good work happens.

Trick #3: Qwen-Image-Layered — AI Photoshop From the Future (That’s Free)

Okay. This one is genuinely unhinged, in the best way.

Most AI image editors treat your image like a mural painted on a wall. You want to change one part? Good luck not accidentally smearing the rest. The reason is technical but also kind of philosophical: regular AI image models see your photo as one giant grid of fused pixels — foreground, background, shadows, text, everything baked together into one inseparable mass.

Professional design software solved this decades ago. They use layers. You move text without touching the background. You recolor an object without re-rendering the whole scene. AI image models never had this because they operate on flattened images. Until now.

Qwen-Image-Layered is an open-source model from Alibaba that does something no one thought would arrive this fast: it takes a regular flat image and automatically decomposes it into multiple separate, transparent RGBA layers — basically generating a Photoshop PSD file from a JPEG. Automatically. From a single prompt.

You tell it how many layers you want. Ask for 4, you get 4 layers. Ask for 8, you get finer separation. A poster with bold text breaks down into: the background, the main subject, the typography, the decorative elements — each as its own independent, editable layer with its own transparency channel.

Then you edit each layer independently. Want to recolor just the product? Edit layer 2. Want to swap the text? Edit layer 3. Nothing else moves. Nothing else drifts. Because you’re editing a layer, not re-generating an image.

The product photo workflow that kills your shot list

Here’s a real use case that will make any marketer’s eyes light up:

  1. Take one product photo.
  2. Run it through Qwen-Image-Layered and decompose it into 4 layers: background, product, props, text/branding.
  3. Edit Layer 1 (background) to swap in five different scene variations — studio white, kitchen counter, outdoor table, lifestyle setting.
  4. Edit Layer 2 (product) to recolor for different SKU variants.
  5. Recombine.

You just generated 10+ product images from a single original photo without a single additional photoshoot. The kind of thing that used to cost a full day of studio time now costs about twenty minutes and a moderately powerful computer.

Recursive decomposition (yes, it goes deeper)

One more thing: the decomposition is recursive. You can take any layer and decompose that into sub-layers. Need to separate the reflection on the product from the product itself? Decompose the product layer. It goes as deep as you need. This is either incredibly useful or a productivity black hole, depending on your relationship with perfectionism.

It’s free, open-source (Apache 2.0 license), available on HuggingFace, and frankly embarrassing for companies currently charging $50/month for layer-based editing software.

Trick #4: FLUX.2 Multi-Reference Stacking — Consistency at Scale

Here’s a problem that haunts anyone generating AI images for brand work: consistency. You generate a great character, a great style, a great product look — and then trying to replicate it across different scenes is a nightmare. The vibe shifts. The face drifts. The lighting feels different. The brand colors are “close enough” until they’re not.

FLUX.2 — the latest generation from Black Forest Labs — handles this at an architectural level. It can process up to ten reference images simultaneously, merging them into a coherent generation that inherits style, character appearance, and product identity from all of them at once.

This isn’t a filter layered on top. The architecture natively processes multiple visual embeddings and fuses them before the generation step. In practice: feed it your brand photography style guide (3–4 reference images), your character or spokesperson (2–3 images from different angles), and your product (2 images). It synthesizes all of that into a single, coherent visual output that respects all of it simultaneously.

Typography that doesn’t melt

FLUX.2 also significantly improved text rendering inside images. Baseline alignment, kerning, and font weight hold up even in complex compositions. If you’ve ever watched a previous AI model turn the word “SALE” into “SAIE” or “SMLE,” you understand why this is worth celebrating.

Compositional instructions that actually stick

Previous models had a habit of treating complex prompts like abstract mood boards. “Left object at 30 degrees, right object with diffused lighting, center-aligned text” would collapse into a blurry approximation of vibes. FLUX.2 actually follows compositional constraints. Which sounds like the bare minimum, and yet here we are, grateful for it.

Pro Tips Section: The Stuff That Actually Saves You Time

Start with natural language, then convert to JSON. Use a plain text prompt to get a result you like. Then convert that prompt into JSON, adding all the parameters you’d want to control — resolution, style, lighting, composition, text elements. Now you have a reusable template.

Use white backgrounds for single-subject images. Especially when generating product images for e-commerce. White backgrounds give you maximum flexibility for later editing in any tool, and they play nicely with Qwen-Image-Layered’s decomposition engine.

For character consistency across scenes, use Kontext iteratively. Generate your base character once. Then use Kontext’s conversational editing to place them in different environments, outfits, and scenarios — rather than regenerating the character from scratch each time. You’ll get far more consistent facial structure and physical proportions.

Batch with JSON, not with your mouse. If you need 20 variations of the same image, don’t click your way through them. Write a base JSON template, create a simple script that loops through your variables (background color, text, object position), and generate automatically. This is what the power users mean when they say “I scaled avatar creation 15x.” They mean they stopped doing it manually.

For FLUX models: lower the creativity setting when you need realism. The “strength” parameter in image-to-image workflows controls how much the model deviates from your input. High strength = creative reimagining. Low strength = controlled adjustment. Most people leave this at default and then complain the output drifted too much. Turn it down.

Qwen-Image-Layered tip: name your layers. When you decompose, keep a simple text note of what each numbered layer contains. The model doesn’t label them for you, and by layer 6 you will absolutely forget which one is the “text overlay” versus the “foreground decoration.” Future you will be grateful.

The Bottom Line

We’re at a weird inflection point where the gap between “someone who knows these tricks” and “someone who doesn’t” is starting to show up in actual professional output — in how fast people work, how consistent their visuals look, and how many rounds of revision they’re sitting through.

None of this requires a design background. None of it requires coding experience (except maybe the batch JSON scripting, and even that’s one Claude conversation away from done). It requires knowing which tools exist and how to use them in ways that go slightly beyond their default settings.

You now know. Go make something embarrassingly good.

Shay Stibelman writes about AI, digital tools, and the productive chaos of working smarter. He also makes video tutorials for people who’d rather watch someone else figure it out first, which, honestly, is a valid life strategy.

NotebookLM: 10 Tips That Separate the Clickers From the Power Users

So you’ve heard of NotebookLM. Maybe you even tried it. You uploaded a document, asked it a question, it answered, and you thought “okay, cool” — and then went back to doing things the old way.

First of all, same. Second of all, you’re leaving an enormous amount on the table.

NotebookLM is one of those tools that looks simple on the surface and then turns out to have an entire underground city beneath it. The tips below are what separate people who use it occasionally from people who’ve quietly restructured their entire workflow around it. Ranked, because everything is better when it’s ranked.

Let’s go.

Before Anything Else: Why NotebookLM Is Different

Quick reminder, because it matters for everything that follows.

Most AI tools work like a very well-read person: they know a lot of general stuff, and they answer from that general knowledge. The problem? Sometimes they make things up. Confidently. With a straight face. It’s called “hallucination” and it’s the AI equivalent of that colleague who always sounds certain and is occasionally completely wrong.

NotebookLM works differently. It only answers from the documents you give it. Nothing else. It’s not browsing the internet, it’s not drawing on general knowledge — it’s reading your stuff and synthesizing your stuff. Every answer comes with a citation, which you can click to verify. Every. Single. One.

This is not a limitation. This is the whole point. And once you internalize that, these tips will make a lot more sense.

Tip #1: One Notebook, One Topic. No Exceptions.

This sounds boring. It is also the most important thing in this article.

The temptation is to create one giant notebook and throw everything into it — all your projects, all your documents, all your research. It feels organized. It is not organized. It’s a junk drawer with a label on it.

When you mix unrelated content in a single notebook, the AI’s ability to find connections and surface relevant information gets diluted. It’s like asking a very smart person to think about marketing strategy, project timelines, HR policy, and last year’s invoices all at the same time. Even they’d look at you funny.

The fix is simple: one notebook per project, per topic, per purpose. A “Marketing Research” notebook. A “Client X Project” notebook. A “Competitor Analysis” notebook. Each one becomes a focused little expert on exactly that thing and nothing else. The results are dramatically better.

Input discipline. That’s the whole tip.

Tip #2: The Note-to-Source Loop (a.k.a. the Recursive Brain Trick)

This one is a little mind-bending but very worth it.

Here’s the problem: when you have 10 raw documents in a notebook, there’s a lot of noise. Repetition, tangents, conflicting info, irrelevant sections. The AI does its best, but it’s working with messy material.

Here’s the fix: ask NotebookLM to synthesize all of it into one clean, structured note first. A comparison table, a summary document, a structured overview — whatever fits your purpose. Then take that note, clean it up manually if needed, and re-upload it as the only source in the notebook. Deselect all the originals.

Now the AI is working from a clean, verified, “gold standard” document you’ve curated yourself. The Audio Overviews it generates will be sharper. The slide decks will be more focused. The answers will be cleaner.

You’re essentially using the AI to make better raw material for the AI. Recursive, slightly philosophical, extremely useful.

Tip #3: Custom Instructions — All 10,000 Characters of Them

NotebookLM lets you set custom instructions for how the AI should behave in your notebook. Think of it as a permanent system prompt — a briefing you give the AI before every single conversation.

NotebookLM recently expanded this to 10,000 characters (that’s a lot of characters), which means you can now write genuinely detailed instructions. Not just “be formal” — but an entire persona, a role, a set of constraints, a preferred output format, the works.

Power users keep a “persona library” and paste in different ones depending on the task:

  • The Socratic Coach — doesn’t give you answers, asks you questions about the material so you actually have to think (and retain things)
  • The Senior Strategy Consultant — cuts straight to SWOT analysis, actionable recommendations, and executive-level framing
  • The Devil’s Advocate — specifically looks for holes in your argument, contradictions in the data, and reasons your plan might fail

That last one, by the way, is genuinely useful before any big presentation or proposal. Better to hear the problems from your AI than from your client.

Tip #4: Deep Research for the Gaps in Your Own Knowledge

Your internal documents are great, but they don’t know what happened last month. They don’t know what your competitor just announced. They don’t know the regulatory change that was published last week.

NotebookLM has a Deep Research mode that goes out and browses live websites to fill those gaps. You give it a question, it does the legwork across hundreds of sources and comes back with a cited report. You then import that report as a source into your notebook.

The result is a hybrid knowledge base: your internal documents plus the current state of the world, all in one place, all queryable. It’s the difference between working with a snapshot and working with a live picture.

Tip #5: Stop Generating One Audio Overview and Walking Away

The Audio Overview feature — where NotebookLM generates a podcast with two AI hosts discussing your documents — has, remarkably, been used by over 10 million people a month. Which means most of those people generated it once, listened passively, and called it done.

Don’t do that.

The actual power move: customize the prompt before you generate. You can tell the hosts what to focus on, what tone to take, what angle to explore. “Focus on the financial implications.” “Take a more skeptical tone.” “Debate the two main approaches and don’t pick a winner.”

Then generate multiple episodes from the same material, each exploring a different angle. You now have a mini podcast series about your own documents, which is either very cool or very weird, depending on your personality.

And in Interactive Mode, you can join the conversation yourself. Interrupt the hosts. Ask them to go deeper on a specific point. Act as a guest on your own podcast about your own meeting notes. Honestly? We live in remarkable times.

Tip #6: Query Across Notebooks (The Second Brain Move)

For a while, the biggest frustration with NotebookLM was that notebooks were silos. Your Marketing notebook couldn’t talk to your Finance notebook. You had multiple specialized experts who didn’t know each other existed.

That changed. You can now connect multiple notebooks through the Gemini app and query across all of them at once. So when the strategic question requires both the marketing data and the financial data, you don’t have to jump between two notebooks and manually connect the dots yourself.

This is what people mean when they talk about a “second brain.” Not one massive document dump — a network of specialized, focused notebooks that can be interrogated together when needed.

Tip #7: Ask It What’s Missing (The Source Gap Prompt)

Most people use NotebookLM as a summarizer. Summarize this. Explain that. What are the key points?

Useful. But not the most powerful thing you can do.

The most powerful prompt in the advanced user toolkit is the Source Gap prompt: ask the AI to tell you what’s not in the documents. What’s missing. What assumptions are unproven. Where the sources contradict each other. What questions the material raises but doesn’t answer.

You’re asking it to be an auditor, not a summarizer. And auditors find the things that matter — the gaps, the blind spots, the weak links in the argument. For market research, strategic planning, or any document where the stakes are high, this is invaluable.

“What important context is not covered in these documents?” is one of the most useful prompts you will ever type.

Tip #8: Transcribe Everything. Seriously, Everything.

NotebookLM supports audio and video uploads (YouTube links, MP4 files, MP3 recordings), and it will transcribe and analyze them just like text documents.

Think about what that means. Call recordings. Client interviews. Conference presentations you attended. Internal webinars. That hour-long product review meeting where someone promised to send the notes and never did.

All of it becomes searchable, queryable, and summarizable. You can turn a recorded client call into structured notes, FAQs, or a follow-up email in minutes. A recorded training session becomes a searchable knowledge base. A YouTube tutorial on a tool you’re learning becomes source material you can interrogate.

Third-party transcription services cost money and still give you a wall of text you have to process yourself. NotebookLM transcribes it and puts it directly into an environment where you can ask questions about it. That’s a different category of useful.

Tip #9: Revise Your Slides Like a Demanding Art Director

NotebookLM can generate slide decks directly from your source material. One click, full deck, done. Which is impressive enough on its own.

But the real move is what you do after. Once the deck is generated, you can go into the chat and tell it to revise specific slides. “Redo slide 4 to focus on the executive summary.” “Make slide 7 more visual and less text-heavy.” “The intro slide needs to start with the problem, not the solution.”

You’re essentially art-directing an AI slide designer who doesn’t take things personally and never says “but I thought we agreed on this layout.” Just iterate until it’s right, then export to PPTX and polish the final version yourself.

It won’t replace a good designer for anything that needs to look genuinely beautiful. But for an internal strategy presentation at 9am on a Tuesday? It’ll get you there.

Tip #10: Use the Citations to Navigate, Not Just to Verify

Every answer NotebookLM gives you includes clickable footnote-style citations linking directly to the source passage. Most people click them occasionally, to check if the AI got it right.

Power users click them constantly — not to verify, but to navigate.

Got a 500-page document? Don’t use Ctrl+F and hope for the best. Ask NotebookLM a question about the topic you need, and click the citation. You’ve just jumped directly to the relevant section using semantic search. The chat panel becomes a high-speed navigation interface for dense material.

For anyone who works with long contracts, technical documentation, lengthy reports, or academic papers, this alone is worth the price of entry. (Which, for the free tier, is zero. So.)

Bonus: The Three-Tool Chain That Power Users Actually Use

Here’s a workflow that’s become increasingly popular among people who’ve fully leaned into AI-assisted research:

Step 1 — Perplexity for initial web sourcing. It’s great at finding high-quality, current URLs on a topic quickly.

Step 2 — NotebookLM for deep, grounded analysis. Import those URLs, cross-reference with your internal documents, generate structured notes and synthesis.

Step 3 — ChatGPT or Claude for creative output. Take the refined synthesis from NotebookLM and move it to a more creatively fluent model for drafting, writing, or ideation.

Each tool does what it’s best at. Perplexity searches. NotebookLM synthesizes accurately. Claude or ChatGPT writes fluidly. Together, they cover the full research-to-output pipeline without any single tool having to be great at everything.

The Bottom Line (Again, But With More Conviction This Time)

NotebookLM is not a chatbot. It’s not a search engine. It’s not a note-taking app.

It’s a precision research environment that happens to also generate podcasts, slide decks, mind maps, and video summaries from your documents. Used casually, it’s a useful time-saver. Used strategically — with focused notebooks, custom personas, recursive refinement, and the right prompts — it’s genuinely a different way of working with information.

The tips above aren’t tricks. They’re a framework. Start with Tip #1 (notebook discipline), layer in the others as they become relevant to your work, and don’t try to implement all ten in the first week. You’ll lose your mind. Or at least your enthusiasm.

Pick one. Try it. See what changes.

The 500-page document isn’t going to read itself. But NotebookLM will, and it’ll tell you exactly what’s in it, what’s missing, and what you should probably do about it.

Shay Stibelman is a digital marketing consultant based in Milan, Italy. He helps businesses work smarter with the digital tools they already have — or the ones they really should have by now.

Microsoft Office Just Got a Brain. Here’s What That Means For You.

Let’s be honest for a second.

You’ve been using Microsoft Office for years. Maybe decades. You know how to bold text. You know Ctrl+Z is undo and you use it approximately 400 times a day. You’ve survived Excel formulas that looked like ancient Sanskrit, PowerPoint transitions that belonged in a 2003 corporate fever dream, and Word documents that somehow changed formatting by themselves in the middle of the night.

You’ve been through a lot together, you and Office.

And now, Microsoft has added AI to the whole thing. It’s called Copilot, and it lives inside Word, Excel, PowerPoint, Outlook, Teams — basically everywhere you already spend your working hours. Which is everywhere.

So what does that actually mean for you? Good question. Let’s get into it.

First, the Obvious Question: Do I Need to Learn Something New?

Sort of, but not really.

The beauty of Copilot — and AI assistants in general when they’re baked into tools you already use — is that you’re not learning a new interface. You’re not switching apps. You’re not watching a three-part tutorial series on YouTube at 1.5x speed while eating lunch.

You’re just working in the same apps you’ve always used, except now there’s a little AI assistant sitting in the sidebar going “psst. I can help with that.”

The learning curve is: know what to ask. That’s it. And we’re going to cover exactly that.

Word: Your New Writing Partner Who Never Sighs at Your Drafts

Let’s start with Word, because almost everyone uses it and almost everyone has a complicated relationship with the blank page.

Drafting from scratch? Don’t. Describe what you need and let Copilot write a first draft. Not because you’re lazy — because a first draft to react to is always faster than a first draft from nothing. You’ll edit it, reshape it, make it yours. But you’re not starting from zero, and that matters more than people admit.

Rewriting existing content? Select any paragraph, right-click, and ask Copilot to make it shorter, more formal, more casual, or just “better.” It’s surprisingly good at adjusting tone. Handy for when you need to send the same information to your CEO and to a client and they absolutely cannot sound identical.

Summarizing long documents? Ask Copilot to summarize whatever’s open. It reads the whole thing and gives you the key points. This is particularly useful when someone sends you a 20-page document with the note “let me know your thoughts by EOD” at 4:47pm.

The secret move: Ask it to improve your writing, not just change it. There’s a difference between “make this shorter” and “make this clearer and more direct.” Try both. See what happens.

Excel: Finally, Formulas in Human Language

Okay. Excel formulas. Let’s talk.

I love Excel. I also know that a non-trivial percentage of the working population opens a cell, starts typing a formula, makes one small error, and then stares at a #REF! error for 20 minutes while slowly questioning their life choices.

With Copilot in Excel, you can now describe what you want in plain English and it will write the formula for you.

“Show me the total sales for Q3 where the region is ‘North’.” “Calculate the average time between order date and delivery date.” “Flag any rows where the value in column C is more than 20% higher than the previous row.”

It writes the formula. You paste it in. It works. You feel like a genius. Nobody has to know.

But it goes further than formulas. You can ask Copilot to:

  • Spot trends in your data — “What patterns do you see in this dataset?”
  • Suggest charts — “What’s the best way to visualize this data?”
  • Clean up messy data — ask it to identify duplicates, inconsistencies, or blank cells
  • Generate new columns based on logic — “Add a column that categorizes sales as High, Medium or Low based on value”

The spreadsheet isn’t going to build itself. But with Copilot, it’s getting a lot closer.

The secret move: Don’t just ask it to do things. Ask it to explain things. If you’ve inherited a spreadsheet full of formulas someone else wrote (we’ve all been there, and we’ve all had feelings about it), ask Copilot to explain what each formula does. Instant clarity. No archaeology required.

PowerPoint: Slides From Nothing, In Seconds

PowerPoint has a special place in the circle of office suffering. There is nothing quite like the experience of being told you need to “put together a quick presentation” — which, in the history of work, has never once been quick.

Copilot can now generate an entire presentation from a prompt. Or, better yet, from a Word document you’ve already written. You feed it the content, tell it roughly what you need, and it builds slides — with layouts, titles, bullet points, and even suggested images.

Is it perfect? No. Will you need to tweak it? Yes. Will it still save you 45 minutes of dragging text boxes around and trying to remember whether your brand color is #0050A0 or #0052A3? Absolutely.

You can also use it to:

  • Summarize a presentation that someone sent you (because sometimes you receive a 40-slide deck and need to understand it in 3 minutes)
  • Add a new slide on a specific topic without breaking the existing formatting
  • Rewrite speaker notes so they actually sound like something a human would say out loud, rather than a bullet-pointed anxiety spiral

The secret move: After generating slides, ask Copilot: “What’s missing from this presentation?” It will often flag gaps in logic, missing sections, or points that need more supporting data. It’s like having a second pair of eyes that’s read the brief and isn’t being polite about it.

Outlook: Because Email is Still Somehow the Core of Everything

Email. The immortal, indestructible, unstoppable communication format that was supposed to die approximately fifteen times and never did.

Copilot in Outlook does a few things that will make your inbox slightly less of a horror show.

Email summaries: Long email thread with 24 replies and you have no idea what’s happening? Ask Copilot to summarize it. It pulls out the key decisions, open questions, and action items. You’re caught up in 30 seconds. You’re welcome.

Draft replies: You can highlight an email and ask Copilot to draft a reply for you. Give it the key point you want to make and the tone you want to strike, and it handles the rest. This is especially useful for emails you’ve been putting off because they require a delicate touch (read: the ones you’ve had sitting in your inbox for four days with a little mental sticky note that says “ugh”).

Coaching mode: There’s a feature that reviews your draft before you send it and gives feedback on tone, clarity, and whether it might land the wrong way. Think of it as a friend who reads your passive-aggressive email before you send it and gently says “maybe don’t.”

The secret move: Use Copilot to schedule follow-ups. Ask it to draft a follow-up email to send in three days if you haven’t heard back. Copy it into a draft, schedule the send. Never forget a follow-up again. Never lose a deal because it fell through a crack. Very satisfying.

Teams: The Meeting Took Two Hours and You Need It to Be Four Bullet Points

Teams has arguably the most dramatic AI upgrade of the whole suite.

Copilot in Teams can transcribe your meetings in real time, take notes, summarize the discussion, and generate a list of action items — all automatically, while you’re actually present in the meeting and paying attention like a normal human being.

After the meeting, you can ask it things like:

  • “What did we decide about the budget?”
  • “Were there any open questions that didn’t get resolved?”
  • “What did Marco say about the timeline?” (Perfect for when Marco is a fast talker and you lost the thread somewhere around minute 47.)

You can even ask it to catch you up if you joined a meeting late. Which, you know. Happens sometimes. To some of us. More than we’d like to admit.

The secret move: At the end of a meeting, before you hang up, ask Copilot to generate a recap you can paste directly into an email to all attendees. Meeting summary + action items + owners + deadlines, ready to send. Your team will think you’ve become incredibly organized. You have not. You’ve become incredibly smart about using tools.

The Stuff That Works Across All of Them

A few principles that apply no matter which Office app you’re in:

Be specific about tone. “Formal” and “professional” are not the same thing. “Casual” and “friendly” are not the same thing. Tell it exactly what register you need.

Give it context. The more it knows about the situation, the better the output. “Write an email” is a weak prompt. “Write an email to a long-term client explaining a 2-week delay on their project, keeping the tone reassuring and taking responsibility without being dramatic” is a great prompt.

Iterate, don’t regenerate. If the first output isn’t quite right, don’t just click “regenerate” and hope for different results. Tell it specifically what to change. “Make the introduction shorter.” “The second paragraph is too formal.” “Add a sentence acknowledging the inconvenience.” You’ll get there faster.

Use it to think, not just to produce. Ask it questions. “What am I missing here?” “Is there a better way to structure this?” “What objections might someone have to this proposal?” AI is a thinking partner, not just a text generator.

Coming Up: The Deep Dives

This is the overview — the “here’s what’s possible” article. But we’re just getting started.

In the coming articles, I’ll be going deep on each of these apps individually: specific features, real use cases, the tricks that actually save time versus the ones that look impressive in demos and are useless in real life. We’ll also look at specific job roles and workflows — what AI in Office looks like for someone in finance versus someone in marketing versus someone who just wants to get through their inbox and go home on time.

So bookmark this. Or don’t — just Google “Shay AI Office” in three weeks and it’ll probably come up. (That’s SEO confidence right there.)

Pro Tip: The Sidebar Is Your Secret Weapon

Here’s something that most people overlook entirely, and it’s kind of mind-blowing once you start using it.

In Microsoft 365 apps, Copilot lives in a sidebar — a persistent panel on the right side of your screen that you can open at any time, in any document, and just… talk to. You don’t have to use the inline features. You don’t have to right-click or navigate menus. The sidebar is just there, ready, like a very competent colleague who never leaves their desk.

You can have it summarize what you’re working on, ask it questions about the document, get it to generate something new, or just think out loud with it while you work.

And if you’re in the Google Workspace universe instead — Docs, Sheets, Slides, Gmail — the same principle applies with Gemini in the sidebar. Google has their own version of this, and with Gems (custom AI personas you can configure for specific tasks), you can set up a sidebar assistant that’s already tuned for your specific workflow before you even open a document.

Whether it’s Copilot or Gemini, the sidebar is where the real day-to-day magic happens — not in flashy demos, but in the quiet five seconds where you ask a quick question and get back exactly what you needed.

I’m going to write a whole dedicated article about using the sidebar effectively — for both Microsoft and Google — including how to set up Gemini Gems for specific roles and workflows. It’s worth its own deep dive. Stay tuned.

Shay Stibelman is a digital marketing consultant based in Milan, Italy. He helps small and medium businesses get their digital act together — websites, strategy, tools, and the occasional strongly-worded opinion about fonts in PowerPoint presentations.

Using NotebookLM in the office

NotebookLM: The AI Tool That Actually Reads Your Boring Documents So You Don’t Have To

You know that pile of documents sitting in your Google Drive right now? The ones you fully intended to read? The 47-page strategy report from Q3. The onboarding handbook you skimmed on your first day and never opened again. The meeting transcript from that two-hour call where someone finally decided to write everything down, and now the document is longer than the actual meeting.

Yeah. Those documents.

What if I told you there’s a free tool from Google that will read all of them for you, understand them, and then let you have a conversation about them — like a colleague who actually did the reading?

Meet NotebookLM.

So What Even Is This Thing?

NotebookLM is a free AI tool from Google (you can find it at notebooklm.google.com — go on, open a tab). The basic idea is simple: you give it your documents, and it becomes an expert on those specific documents.

This is the key difference between NotebookLM and the regular AI chatbots you might already know. When you ask ChatGPT something, it answers based on everything it was trained on — the whole internet, basically. When you ask NotebookLM something, it answers based only on what you gave it.

Why does that matter? Because it means the answers are grounded in your stuff. Your company docs, your reports, your notes. It’s not guessing or making things up from general knowledge. It’s working from the actual source material you provided.

For office workers, this is kind of a big deal.

Let’s Talk About What It Actually Does

You Upload Stuff, Then You Ask Questions

The workflow is beautifully simple. You create a “notebook” (hence the name, clever right?), you upload your documents — PDFs, Google Docs, copied text, even YouTube links and website URLs — and then you start asking questions.

It accepts up to 50 sources per notebook, and each source can be up to 500,000 words. So yes, you can throw the entire history of your company’s internal documentation at it and it will not complain. Unlike your intern.

Once your sources are in, you can ask things like:

  • “What were the main conclusions of this report?”
  • “Summarize the key action items from these meeting notes.”
  • “What does this contract say about payment terms?”
  • “Are there any contradictions between these two policy documents?”

And it answers. With citations. Actual citations, pointing back to the exact part of the document it pulled the answer from.

You can click those citations and it takes you right to the source. This means you’re not just trusting the AI blindly — you can verify. Which, if you work in any kind of professional environment, is very much appreciated.

The Part Where I Tell You About the Podcast Feature and You Don’t Believe Me

Okay. Deep breath.

NotebookLM has a feature called Audio Overview. You click a button. It takes your documents. And then it generates a podcast — like, an actual podcast with two AI hosts — discussing the content of your documents in a conversational way.

I know. I know what you’re thinking. And yes, it actually works.

It sounds like two real people having a genuine back-and-forth about whatever you uploaded. They ask each other questions, they add context, they even do that thing where one of them goes “that’s a really interesting point” in a way that somehow doesn’t sound completely robotic.

Now, is this useful for office work? Surprisingly, yes.

Imagine you have a long report you need to understand before a meeting tomorrow, but you also have to cook dinner, pick up the kids, and pretend to go to the gym. You generate the audio overview, you put your earbuds in, and you listen to a podcast about your actual documents while doing something else entirely.

You arrive at tomorrow’s meeting having actually absorbed the key points. Your colleagues are impressed. You say nothing. You just nod knowingly.

Real Office Scenarios Where This Thing Shines

The “I Have to Read This Entire Contract” Situation

Legal documents are the worst. They are long, they are dense, and they seem to be written by people who are physically allergic to plain English.

Upload the contract to NotebookLM. Ask: “Explain the key obligations on our side in plain language.” Or: “Are there any clauses here that could be a problem for us?”

You still get your lawyer to sign off on the important stuff (please do that), but at least you show up to that conversation actually knowing what’s in the document. Points for professionalism.

The “We Have Three Years of Meeting Notes and Nobody Knows Anything” Situation

This one is painfully common. Organizations accumulate documents the way offices accumulate branded pens — constantly, mindlessly, and with no real system.

Upload all those meeting notes into a notebook. Now you can ask: “What decisions were made about the website redesign project between January and March?” or “Who was supposed to handle the supplier contract renewal?”

Suddenly your organization’s institutional memory is actually accessible. Which is, if we’re being honest, not something most companies can say.

The “New Hire Who’s Drowning in Onboarding Docs” Situation

Remember your first week at a new job? You got handed approximately 400 documents, told to “read through these,” and then left alone with your thoughts and a very complicated org chart.

With NotebookLM, a new employee can upload all the onboarding materials and just… ask questions. “What’s the process for submitting expenses?” “Who do I contact for IT issues?” “What does this acronym mean?” (Every company has at least seventeen internal acronyms that nobody explains to anyone. Ever.)

It’s like having a patient colleague available 24/7 who has read every single document and won’t judge you for asking the same question twice.

The “I Have to Present This Research and I Barely Understand It” Situation

You’ve been given a stack of reports to turn into a presentation. The reports are full of data, analysis, and conclusions that are each individually understandable but somehow add up to a confusing mess.

Upload everything to NotebookLM. Ask it to identify the three most important takeaways. Ask it what the data actually suggests. Ask it to explain the parts you didn’t follow. Then use that to build your presentation like the confident, prepared professional you now appear to be.

The Study Guide Thing (Yes, Even for Work)

NotebookLM can auto-generate a few things for you from your source material: a summary, a list of key topics, suggested questions to explore, and a study guide with FAQs and a glossary.

Now, “study guide” sounds very school-ish, I know. But think about what that actually is: a quick-reference document that explains the key concepts from your source material, defines the important terms, and anticipates the questions someone might have.

For work, that translates to: briefing documents, quick-reference sheets for your team, onboarding summaries, pre-meeting prep notes.

It builds these in one click. The study guide for a 60-page report takes about 30 seconds to generate. The same thing done manually takes… let’s not even go there.

What It Won’t Do (Let’s Keep It Honest)

NotebookLM only knows what you tell it. It has no knowledge of the outside world, no access to the internet (unless you give it URLs as sources), and no awareness of anything that isn’t in your notebook.

So if you ask it “What’s the current market share of our top competitor?” and you haven’t uploaded any competitive analysis documents, it will tell you it doesn’t know. Because it doesn’t. And honestly? That’s a feature, not a bug. You always know exactly where the answer is coming from.

Also, the audio podcast feature, while genuinely impressive, is not going to replace an actual expert explaining things to you. It’s a good overview. It’s not a consultant. (Speaking of consultants — hi, I’m available.)

And one more thing: like all AI tools, it can occasionally get things slightly wrong or miss nuance. Use the citations. Click through. Verify the stuff that matters. Don’t skip that step.

How to Get Started Without Overthinking It

Here’s your no-pressure plan:

Step 1: Go to notebooklm.google.com. Sign in with your Google account. It’s free.

Step 2: Create a new notebook. Give it a name. Something descriptive like “Q1 Reports” or “Project Phoenix Docs” or honestly just “stuff” — NotebookLM doesn’t judge.

Step 3: Upload one document. Something you’ve been meaning to read but haven’t. A report, a policy doc, a long email thread you saved as a PDF.

Step 4: Ask it one question about that document.

Step 5: Be mildly amazed.

That’s it. You don’t need to set up anything complicated, connect it to other tools, or watch a two-hour tutorial on YouTube. Upload a document, ask a question. That’s the whole thing.

The Bottom Line

NotebookLM is one of those tools that sounds gimmicky until you actually use it, and then you wonder how you managed without it. It’s not trying to replace your brain or your judgment. It’s trying to handle the part of your job that involves wading through large amounts of text to find the information you actually need.

And let’s face it — most office jobs involve a lot of wading through large amounts of text.

So let the AI do the wading. You focus on the actual thinking, the decisions, the relationships, the creative stuff. The parts that actually need a human.

The 47-page Q3 strategy report can wait. NotebookLM’s got it covered.

💡 Pro Tip: Connect Google Drive and Keep It Fresh

Here’s a little bonus that most people miss. When you add a source directly from Google Drive — instead of uploading a PDF or pasting text — NotebookLM treats it as a live source.

That means if the document gets updated, NotebookLM knows about it. You just hit “sync” and the notebook refreshes with the latest version. No re-uploading, no starting over, no accidentally working from a document that’s three versions out of date.

For anything that changes regularly — a running project log, a shared team doc, a client brief that keeps getting revised — this is genuinely useful. Connect the Google Drive version once, and your notebook stays current automatically.

It’s a small thing, but once you start using it, going back to static uploads feels weirdly old-fashioned. Like sending a fax. Not that any of us still do that. Right? …Right?

Shay Stibelman is a digital marketing consultant based in Milan, Italy. He helps small and medium businesses get their digital act together — websites, strategy, tools, and the occasional existential crisis about whether to switch to a new CRM.

AI in Your Office? Yes, You Can Do This (Even If You’re Not a Tech Person)

Okay, so you’ve been hearing about AI for a while now. It’s everywhere. Your colleague keeps talking about it, LinkedIn is full of people claiming it changed their life, and your boss just sent a company-wide email about “embracing new technologies.” Sound familiar?

Here’s the good news: you don’t need to be a developer, a data scientist, or some kind of robot whisperer to actually use AI at work. You just need to know where to start.

So let’s start.

What Even Is AI in This Context?

Before we get into the tools, let’s clarify one thing. When we talk about AI for office work, we’re not talking about building robots or writing code. We’re talking about tools you can open in your browser, type something into, and get useful stuff out of.

Think of it like this: you’ve been Googling things for years, right? Using AI tools is not that different in spirit. You ask, it answers. The difference is that it actually understands what you’re asking — context, nuance, and all.

The most popular ones right now? ChatGPT, Claude (that’s Anthropic’s one), Gemini, Copilot. They’re all in the same family. Pick one and get going. You can always explore the others later.

Let’s Talk About What You Actually Do All Day

Here’s a little exercise. Think about the last three hours at work. What did you spend time on?

Writing emails? Summarizing meeting notes? Trying to figure out how to word that awkward message to a client? Looking something up and then spending 40 minutes in a Wikipedia rabbit hole?

Yep. That’s where AI comes in. And spoiler: those are exactly the kinds of things it’s best at.

Writing Emails (The AI Superpower Nobody Tells You About)

Let’s start with the obvious one, because it’s genuinely life-changing once you get used to it.

How much time do you spend staring at a blank email, trying to figure out how to say something that’s either awkward, sensitive, or just plain boring to write? If you’re like most people, a lot.

Here’s what you do instead: open your AI tool of choice, and just describe the situation out loud (or in writing, obviously). Something like:

“I need to write an email to a client who paid late again. I want to be firm but not rude. The invoice was 30 days overdue.”

Done. It gives you a draft. You read it, tweak it a little if you need to, and send. What used to take 20 minutes of internal debate now takes 3.

The key thing here is to not overthink the prompt. Talk to it like you’d talk to a helpful colleague. The more context you give it, the better the output.

Summarizing Stuff You Don’t Have Time to Read

Raise your hand if your inbox is a war zone. (All hands raised, I assume.)

Now add to that the PDFs, the reports, the long Slack threads, the meeting follow-up docs that are somehow 8 pages long for a 30-minute call.

AI is fantastic at taking long content and turning it into the three things you actually need to know. You paste the text in (or in some tools you can upload the file directly), and ask it to summarize. Or to pull out the action items. Or to tell you the three most important points.

This is not cheating. This is called working smart. Your grandparents called it “reading the executive summary first.” You’re just doing the same thing with a tool.

Meeting Notes? Let Someone Else Handle That

If you’ve ever been in a meeting while simultaneously trying to take notes, you know the problem: you can’t really do both well at the same time. You either miss what’s being said, or your notes are so disjointed they’re useless later.

Tools like Otter.ai, Fireflies, and Notion AI (if your team uses Notion) can record and transcribe your meetings automatically, and then summarize them for you. Action items, key decisions, who said what — all done.

Some of them even integrate directly with Zoom or Google Meet, so the whole thing is basically hands-off. You just… show up to the meeting and participate. What a concept.

Research Without the Rabbit Hole

Ever had to look something up for work and ended up 45 minutes later reading about the history of some completely unrelated thing? Yeah. The internet is a weird place.

AI can help here too. Instead of searching and then filtering through ten tabs, you can ask directly: “Explain how interest rates affect real estate prices in simple terms” or “What are the main differences between B2B and B2C sales approaches?”

You get a clear, direct answer. No ads, no clickbait headlines, no sponsored content trying to sell you something.

Now, a word of caution here: AI tools can sometimes get things wrong. They can confidently state something that’s slightly inaccurate or outdated. So for anything that actually matters — numbers, legal stuff, medical information — always double-check with a reliable source. Think of the AI as your first stop, not your final answer.

Creating Documents, Presentations, and Templates

Blank page syndrome is real, and it’s deeply unpleasant.

Whether you need to write a project brief, draft a proposal, build a presentation structure, or create a standard template for your team, AI can give you a solid first draft in seconds. And working from a draft — even an imperfect one — is infinitely easier than starting from nothing.

Try something like: “Create a simple project brief template for a small marketing campaign, including sections for objectives, target audience, budget and timeline.”

Boom. You’ve got something to work with.

Then you go in, customize it to your actual situation, and suddenly that thing that would have taken you an hour takes you 15 minutes. And you don’t have that specific kind of exhaustion that comes from staring at a blank document.

The Things AI Is Not Great At (Yet)

Alright, let’s keep it real for a second, because this stuff isn’t magic.

AI is not great at making judgment calls that require human context. It doesn’t know your company culture, it doesn’t know that your client is going through a rough patch and needs extra sensitivity, and it doesn’t know that your boss hates the word “synergy” with a passion.

It also doesn’t always know what’s happened recently in the world, depending on which tool you’re using and when its knowledge was last updated. So for breaking news or very current events, go to an actual news source.

And please, for the love of everything — don’t paste confidential company information into a free AI tool without checking your company’s policy on this first. Many companies have guidelines about what can and can’t go into external AI systems. Check before you paste.

Okay, Where Do You Actually Start?

Here’s a simple, no-stress plan for your first week with AI at work:

Day 1: Sign up for one tool. ChatGPT or Claude — both have free tiers, both are good. Don’t try three at once. Pick one.

Day 2: Use it to rewrite one email you’d normally agonize over. See how it feels.

Day 3: Paste in a long document or article and ask it to summarize it for you.

Day 4: Ask it to create a template for something you make regularly — a status update email, a meeting agenda, whatever.

Day 5: Just talk to it. Ask it to explain something you’ve never quite understood about your industry. You’ll be surprised.

By the end of the week, you’ll have a pretty good feel for what it can and can’t do, and you’ll start noticing other places where it fits into your workflow naturally.

One Last Thing

The people who get the most out of AI tools are not the ones who are the most tech-savvy. They’re the ones who are the most curious. The ones who experiment a little, ask weird questions, try things out without worrying about doing it “wrong.”

There’s no wrong way to use these tools. The worst that can happen is you get a bad answer and you try again with a better question. That’s it.

So go on. Sign up for something, ask it something, and see what happens.

Oh, and if your colleague is still emailing you 8-paragraph replies to simple yes/no questions? Maybe forward them this article.