Claude Workflow Tips

Claude is the most powerful application I've used to date. It's been a genuine game-changer in both my personal and professional life. The more I lean on it, the more small workflow habits I pick up that make it even more useful, and this page is where I collect them.

These tips come from my own day-to-day use of Claude in all its forms: Claude Code, Claude Cowork, and Claude Chat. It's a living document, so I'll keep adding to it as I discover more. And because Claude evolves so quickly, some of what's here may become outdated over time; I'll do my best to keep it current.

General Tips

Structure Your Prompts with XML Tags

When a prompt contains more than one kind of content (your instructions, the text you want Claude to work on, an example to follow), Claude has to work out where each part begins and ends. XML tags make those boundaries explicit, so Claude spends less effort guessing at the structure and more on the actual task.

You don't need to know XML to use this. You invent your own tag names, wrap each section in a matching open and close tag, and that's it.

Without tags, everything runs together and Claude has to infer where the instruction stops and the content starts:

Rewrite this to be more concise. Keep the technical terms.
Our system, when it receives a write operation, will invalidate
the relevant cache entries...

With tags, there's no ambiguity about what's an instruction and what's the text to change:

Rewrite the text in <draft> to be more concise. Keep all technical terms.

<draft>
Our system, when it receives a write operation, will invalidate
the relevant cache entries...
</draft>

A few rules for valid tag names:

• Open and close tags must match exactly, including case: <draft> ... </draft>
• No spaces; use underscores or hyphens instead: <user_data>, not <user data>
• Don't start a name with a number or the letters "xml"

Beyond that you have free rein. Descriptive names like <email> or <rules> work better than generic ones like <text1>, because the name itself hints at how Claude should treat the block.

This pays off most when a prompt has several sections to keep separate, or when you want to refer to a section by name in your instructions ("match the tone in <example>"). For nested content like multiple documents, you can stack tags to show the hierarchy:

<documents>
  <document index="1">
    <title>Q3 Report</title>
    <content>...</content>
  </document>
</documents>

<question>What was Q3 revenue?</question>

Tip: type both tags first, then fill in the content between them. It's the simplest way to avoid forgetting the closing tag.

Use Claude as a Writing Partner

One of my most frequent uses of Claude is as a writing partner. I have it draft, tighten, and pressure-test almost anything I need to write: emails and replies, letters, tricky or sensitive messages, even a card to someone I love. A few ways I use it:

• Draft from scratch. Give it the gist plus the context (for a reply, paste in the thread you're responding to) and let it produce a first version you refine.
• Polish your own draft. Paste what you wrote and ask it to tighten the wording, fix the tone, or make it warmer or more direct.
• Pressure-test before you send. Ask how a message might land, or whether you're missing anything, especially for anything delicate.

The trick is giving it enough context and a clear sense of your voice and intent. It's not there to replace your writing; it's there to help you get to a better version, faster.

Show Claude Images & Screenshots

Claude can see, not just read, so don't limit yourself to text. Paste in a screenshot or photo whenever that's faster than describing something. I regularly hand it images to:

• Pull information out of a picture: numbers off an invoice or receipt, a tracking number, or text from a photo.
• Make sense of what's on screen: paste a screenshot of an error, a confusing setting, or a chart and ask what's going on.
• Generate alt text for images, or describe what's in a photo.
• Identify or explain something: a logo, a product, or what a diagram is showing.

Often a quick screenshot gets you a better answer than a paragraph trying to describe the same thing.

Research Decisions & Compare Options

Claude is a great research assistant and sounding board when you're trying to decide something. I use it to compare options and think through choices: weighing insurance plans, comparing products before buying, getting up to speed on an unfamiliar topic, or laying out the tradeoffs of a bigger decision. With web search or research mode turned on, it can pull in current information and cite its sources, so you're not relying only on what it already knows. Give it your specific situation and constraints, then ask it to lay out the options, the tradeoffs, and what it would want to know before deciding. Treat it as a thinking partner rather than an oracle; the final call is yours (see the guardrails tip below).

Leverage CLAUDE.md & Project Instructions

One of the highest-leverage things you can do is give Claude standing context about who you are, what you're working on, and how you like things done, so you don't have to repeat yourself every session.

• In Claude Code and Claude Cowork, that context lives in a CLAUDE.md file at the root of a project. Claude reads it automatically at the start of each session.
• In Claude Chat, the equivalent is a Project's custom instructions (plus your account-level personal preferences).

A strong CLAUDE.md usually covers a few things: what the project is and where everything lives, the conventions and preferences you want followed, any working norms or guardrails (more on those below), and a short start-of-session routine. The more of your standing context it captures, the less you have to re-explain.

This is also how you get predictable, near-deterministic results from repeatable tasks. When a workflow is spelled out once (the exact steps, the format, the terminology to use, the edge cases to watch for), Claude produces essentially the same high-quality output every time rather than something slightly different on each run. I rely on this heavily for recurring work: a carefully written set of project instructions turns a fuzzy "help me with this" into a reliable, repeatable process.

The best part: you don't have to write it by hand. Ask Claude to draft or update your CLAUDE.md based on the project. It's usually better than I am at capturing the details that matter.

Have Claude Write README.md Files to Capture Context

Beyond CLAUDE.md, have Claude write README.md files to capture context you'll want later, for both your future self and future Claude sessions.

Any time you finish setting something up or figure out how a system works, ask Claude to document it in a README. Months from now, when you (or Claude) come back to it, that written context saves you from re-deriving everything from scratch.

Build Reusable Skills & Templates

When you find yourself asking Claude to do the same kind of task over and over, turn it into a reusable skill, a saved set of instructions Claude can follow on demand. I have skills for things like processing new photos for this website, figuring out how much I can safely move to savings after payday, putting together research packets before sales demos, and generating a weekly report at work. Once a skill exists, kicking off the task is as simple as invoking it.

The same idea applies to plain templates. For example, I keep a website optimization checklist (OPTIMIZATION-CHECKLIST.md) that I copy into each new website project and work through with Claude (it's in a dozen of my projects by now). Claude checks off items as it finishes them, and because the file persists, I can stop and pick up right where I left off across sessions. Templates can be bigger than one file, too: for the kind of project I set up over and over, I keep a ready-made project-template folder (its own CLAUDE.md plus starter files) that I copy to spin up each new one, so every project starts from the same baseline. Reusable instructions, whether a formal skill, a simple checklist, or a whole starter folder, save time and keep your results consistent.

Make Your Skills Self-Improving

Here's a favorite pattern to layer onto the skills above: have a skill keep a running "friction log" and periodically propose its own improvements, so it gets sharper the more you use it. The important part is that it's suggest-only. The skill writes proposed refinements to a log for you to review and apply, but it never edits itself, which keeps a human in the loop (see the guardrails tip below) while still letting it learn from how its runs actually go. I got this idea from Tom Johnson's article "Developing internal skills for recurring documentation processes like release notes". His I'd Rather Be Writing podcast and blog are well worth a follow if you're a technical writer, a documentarian, or just curious about AI.

To add it to a skill, I keep a reusable prompt on hand and paste it into the skill-building conversation. Tweak the knobs first if you like (how much autonomy it has, how often it reflects), or just use the defaults:

I'm building a skill (see above/below). Before we finish, add a final "Reflect & improve" continuous-improvement step to it, following the spec below. This is a reusable pattern I add to my skills, so understand the full intent and adapt it to THIS skill specifically.

WHY: I want the skill to get sharper over time by learning from how its own runs actually go (a built-in "friction log"), WITHOUT ever silently changing its own behavior. The reflection step is a closed suggestion box; I'm the human-in-the-loop who reviews and applies changes.

NON-NEGOTIABLE RULES:
1. SUGGEST ONLY (default). The skill must NEVER edit its own instructions/SKILL.md or change any of its rules, thresholds, inputs, sources, output format, or behavior on its own. It only writes suggestions to a separate log for me to review and apply. (If I've set the autonomy knob to "auto-fix small mechanical stuff only," it may directly apply low-risk mechanical fixes like a dead/changed URL or a stale date, and must log everything else as a suggestion. Never go beyond the level I set.)
2. This reflection step is the LAST step of every run / invocation.
3. Keep it lightweight — it shouldn't bloat runtime or the skill's normal output.

WHAT TO IMPLEMENT:
A. Create a dedicated `improvement-log.md` in the skill's existing data/output folder (wherever its other working files live; if it has none, pick a sensible stable path and tell me). Seed it with a short header that explains: it's a suggest-only friction + improvement log, the skill writes here but never edits itself, and how I review/apply suggestions. Newest entries on top.
B. Add this improvement log to the skill's list of known working files, so the agent reads recent entries during the weekly synthesis.
C. Add a "Reflect & improve (SUGGEST ONLY)" section as the skill's final step, containing:
   - EVERY RUN — light friction note: append a dated 1–3 line entry capturing this run's friction — tools/sources that errored or returned an empty/JS-shell response, dead or stale data, steps that wasted effort, coverage gaps, and any calibration/quality observations specific to this skill's job. "No notable friction" is a valid entry.
   - WEEKLY SYNTHESIS — [Sunday by default] only: read the last ~7 days of friction notes plus the skill's run log/history, look for recurring patterns, and append a dated "Weekly synthesis" entry with a short, prioritized list of concrete, actionable proposed refinements. Tag each `STATUS: AWAITING REVIEW`. Do NOT apply them.
   - HEADS-UP (at most once per week): if the weekly synthesis surfaced notable proposals, give me a one-line pointer through the skill's existing notification/output channel — fold it into a message that's already going out if possible; otherwise emit a minimal standalone notice. If the skill has no notification channel, skip the heads-up (the log is enough).
D. TAILOR everything to THIS skill's domain. Don't copy generic examples — name the actual tools, sources, file paths, and realistic failure modes this specific skill has. The friction-note examples should read like they were written for this skill.
E. If the skill also has a separate human-readable instructions/README doc, mirror a short version of this "Reflect & improve" section there so the two stay in sync.
F. DEFAULTS to assume unless I said otherwise in a Parameters block: suggest-only autonomy; friction note every run + weekly synthesis on Sundays; human-in-the-loop review (I'll say "review the [skill] improvement log" when I want to act). If any default genuinely doesn't fit this skill — e.g., it isn't scheduled/recurring, has no persistent storage, or has no output channel — don't force it; tell me and propose the right adaptation.

When you're done, show me exactly what you added (the new log file + the section) and confirm the skill itself was not otherwise changed.

Use Connectors to Expand What Claude Can Do

By default, Claude works with the text in your conversation. Connectors (also called MCP servers) extend that reach, letting Claude work directly with your other tools and data. I connect it to my calendar and Google Drive, my task manager, work tools like Slack and our support inbox, and even my finances, so it can pull real context and take action instead of me copying things back and forth.

Connecting the tools you already use turns Claude from a great conversationalist into something closer to an assistant that can actually get things done on your behalf. Start with one or two connectors for the tools you touch most. Beyond the official ones, there are many community-built MCP servers: to add a custom one, point Claude at the project's GitHub repo (or download a zip of it) and ask it to walk you through installing and connecting it. And if a tool you rely on has no connector at all, you (or someone technical) can build one from scratch. I've built a few of my own, including one for my task manager and one for the product I support at work.

Set Guardrails & Keep a Human in the Loop

The more capable Claude gets, the more it pays to be explicit about what it should and shouldn't do on its own. Decide which actions always need your sign-off, and put those expectations somewhere Claude will see them: your CLAUDE.md, your project instructions, or just the current conversation. A few guardrails I lean on:

• Ask before anything destructive or hard to undo, like deleting files, overwriting data, or force-pushing, and prefer making a backup first.
• Keep a human in the loop for anything that goes out into the world. I let Claude draft and prepare, but I'm the one who actually sends the email, publishes the page, or moves the money.
• Pause and confirm before spending money or changing a live system.

Think of Claude as a capable assistant with you as the final check. This matters more as you connect more tools (above), since that's when Claude can start taking real actions on your behalf.

Claude Code Tips

Build Your Own Apps & Tools with Claude Code

You don't have to be a professional developer to build real software anymore. I'm not one (I only ever learned the basics of HTML and CSS), yet with Claude Code I've built a pile of small apps and tools that make my life easier: a free local audio and video transcription tool, a little web app for browsing an art archive, a podcast-guest finder, and a handful of custom connectors (see above) for tools I use daily.

The workflow is approachable: describe what you want in plain language, let Claude write the code, run it, and iterate together until it works. Start small, with something that scratches a real itch. There's a particular satisfaction in having an idea for a tool in the morning and actually using it by that afternoon.

Put Claude to Work in an Existing Codebase

Claude Code isn't only for building things from scratch; it's also great for working inside a large codebase you didn't write (or wrote a while ago and have since forgotten). Point it at an existing project and it can explore the code, explain how a piece works, trace where something is defined, and make changes that fit the patterns already there. I use it this way on a big, established codebase at work: instead of hunting through unfamiliar files myself, I describe what I'm trying to do and let Claude find the relevant spots and propose the change. It flattens the learning curve on any project that's too big to hold in your head.

Let Claude Run Git for You

If you use Git but don't love memorizing its commands, let Claude Code handle it. I rarely touch the terminal for version control anymore. I just tell Claude what I want in plain English ("commit this," "create a branch," "undo my last commit") and it runs the right commands.

You can still run Git yourself whenever you want, of course. But offloading the routine stuff removes a lot of friction.

Create Your Own Shorthand

You can teach Claude your own shorthand for the multi-step routines you run often by defining it in your CLAUDE.md. My favorite example is "ship": when I say ship (or ship it), Claude commits my changes, merges the branch into main, and pushes to GitHub, all three steps from one short word.

The same idea works in Claude Chat and Claude Cowork, where the shorthand lives in a Project's custom instructions rather than a CLAUDE.md. I keep Projects whose instructions spell out an entire recurring routine (which sources to pull, the rules to apply, the exact format to produce), triggered by a single word. I open the Project, type "go," and Claude runs the whole thing. Because the routine is written down once, every run comes out consistent, and it stops at a draft for me to review rather than sending anything on its own (see the guardrails tip above).

Defining shorthand like this means Claude does the same thing every time, and I don't have to spell out the steps. You can define as many as you like. I also have a "commit no push" for when I want to save my work without shipping it yet. Pick the routines you repeat most and give each a simple trigger word.

Use Plan Mode for Bigger Changes

For anything beyond a quick edit, use Plan Mode. Instead of diving straight in, Claude first explores the relevant files, thinks through the approach, and writes up a plan for you to review and approve before it changes a single thing. That way you catch a wrong assumption or a missing requirement while it's still just words on a screen, not something you have to undo later. I use it for any non-trivial task: I skim the plan, redirect anything that's off, then let Claude execute against it. It's the difference between "go do this and hope" and agreeing on the approach first.

Have Claude Run & Check Its Own Work

Don't just take Claude's edits on faith; have it run and verify what it built. When I'm working on a website or app, Claude spins up a local preview, loads the page, and actually checks the result (reading the rendered output, watching for errors, even taking screenshots) before telling me a change works. The same idea applies beyond code: ask it to run the tests, re-read the file it just wrote, or walk back through its own output looking for mistakes. Building in a verification step catches problems while they're still cheap to fix, and it means "done" actually means done.

Set Up Automations with Claude Code

Claude Code can set up recurring automations on your computer, not just run one-off commands. You describe the outcome you want in plain language, and it configures the whole thing (on a Mac, that's usually a scheduled job called a Launch Agent), then verifies it's working. Two I rely on:

• Automatic backups. A nightly job that commits a folder and pushes it to GitHub, so my work is continuously versioned and backed up without me lifting a finger. This is great for writing projects, not just code.
• Automatic updates. A daily git pull that keeps a local copy of a codebase current, so Claude always has the latest version to read and answer questions about.

You don't need to understand the underlying plumbing. Tell Claude the outcome and the schedule, and it will set it up and show you how to pause or change it later.

Keep Your Session History from Auto-Deleting

By default, Claude Code deletes old session transcripts after 30 days. I'd rather keep mine indefinitely and never lose the history or context of past work, so I bumped the retention way up in my Claude Code settings. In ~/.claude/settings.json, set:

{
  "cleanupPeriodDays": 99999
}

That effectively means "never delete." Your past sessions become a surprisingly useful archive, which pairs well with exporting your data for search (below).

Claude Cowork & Claude Code Tips

Default to Markdown Files

When you're working with Claude on anything file-based, Markdown (.md) is a great default, and it's worth understanding why. The real advantage isn't Markdown specifically; it's that Markdown is plain text with just enough structure, which hits a sweet spot for a language model:

• It tokenizes cleanly and cheaply, with almost none of the syntactic overhead that tags add in XML or HTML.
• The structure it does have (headings, lists, emphasis, code fences) maps onto meaning the model can use to navigate a document.
• It's everywhere in the training data, so Claude is fluent at both reading and writing it.
• It's human-readable and diffs cleanly in Git, which matters for files you'll hand-edit over time.

That last point is really why CLAUDE.md is Markdown: it's instructional prose meant for both you and Claude to read and review.

Just don't force everything into Markdown. When your content has real structure, reach for the format that matches it:

• Structured or nested data: JSON or YAML, which are unambiguous and machine-parseable (Markdown has no schema).
• Tabular data: CSV, once you're past a handful of rows.
• Delineating sections within a prompt: XML tags (see the XML tip above).

The takeaway: plain text is what Claude handles best, and Markdown is the strongest general-purpose plain-text format for human-readable, document-style content. For data with real structure, use the format built for that structure.

Keep Your Folder Structure Organized & Consistent

Claude works better when your files are organized, and so do you. Keep a clean, consistent folder structure across your projects: predictable names, logical grouping, one obvious home for each kind of thing. When everything has a place, it's easier for Claude to find the right context and for you to point it in the right direction.

Set Up Git in Your Claude Folders

For any folder you actively work in with Claude, consider putting it under Git. Version control gives you a local safety net: every change is tracked, and you can always roll back if something goes sideways. Push the repository to a service like GitHub and you also get an off-site backup. This pairs especially well with letting Claude run Git for you (above).

Add Dated "context" Subfolders

Inside a project, I like to keep a context/ subfolder with dated subfolders in YYYY.MM.DD format (e.g. context/2026.07.04/). Whenever I want to give Claude relevant background for what I'm working on (reference docs, screenshots, notes, exports), I drop it into a dated folder. It keeps context organized and easy to point Claude at, and the dates make it clear what's recent.

Use Transcripts to Give Claude Context

Transcripts are one of the best ways to give Claude context about a topic. If you have a recorded meeting, call, interview, or presentation, get a text transcript (a .md file is ideal) and hand it to Claude. It can summarize it, pull out the action items and next steps (I do this after most meetings and calls), answer questions about it, or use it as background for related work. It's especially handy for recurring meetings: I run each week's transcript of the same team sync through Claude to capture decisions and action items in the same format every time. If the transcript is rough, Claude can clean it up first, labeling who's speaking and fixing obvious mis-transcriptions. A good transcript packs an enormous amount of context into a single file, and dropping it into a dated context/ folder (above) keeps it easy to point Claude back to later.

Export Your Claude Data for Better Search

You can request an export of all your Claude data from your account settings. I export mine periodically and keep it in a dated folder. Two reasons:

• Better search. When I want to resurface a specific past chat, which I do fairly often, I've found it more reliable to point Claude Code or Claude Cowork at my exported data than to hunt through the app's own search. Tip: search for distinctive strings (names, email addresses, unusual phrases) rather than common words, which return noisy matches.
• Clean Markdown copies of any chat. The export includes the full content of your conversations, so you can have Claude turn any past chat into a tidy Markdown file, handy for archiving or feeding as context into a new session.

Track Ongoing Work with PROGRESS.md, TODO.md, & HOMEWORK.md

For ongoing projects, a few dedicated Markdown files keep you and Claude on the same page:

• PROGRESS.md is a living status file: where things stand, what's done, what's next, known issues, and a dated log of each session. I keep the stable orientation in CLAUDE.md and let PROGRESS.md hold the current state, and I have Claude read it first thing so it's immediately caught up.
• TODO.md is a running task list. This works especially well for shared projects, where each item can note who's on it and when it was finished.
• HOMEWORK.md tracks action items or "homework" from recurring sessions or meetings, so nothing falls through the cracks in between.

You don't need all three for every project; reach for whichever fits. The common thread is a durable, plain-text place to track state that both you and Claude can read and update.

End Sessions by Updating Your Context Files

Get in the habit of ending a work session by having Claude bring your context files up to date. A prompt I use:

Please make sure CLAUDE.md and every other relevant file in this project is fully accurate and up to date based on everything we did this session.

This keeps your CLAUDE.md, PROGRESS.md, and other docs from drifting out of date, so your next session starts with accurate context instead of stale notes.

Leverage Scheduled Tasks

Both Claude Cowork and Claude Code can run scheduled tasks: recurring jobs that fire automatically on a schedule and deliver the results to you. This turns Claude into something that works for you in the background, not just when you're sitting at the keyboard.

A few I run in Cowork:

• A daily morning briefing at 6 AM that pulls together my calendar, top tasks, the local weather, a gentle habit nudge, and a quote to start the day.
• Several monitors that periodically scan for new things worth knowing, like real-estate listings in my area, price drops on things I've been eyeing, and news on topics I follow.

Claude Code can do the same on your own machine (I have a weekly work report that runs on a schedule that way). Set one up for anything you'd otherwise check manually on a regular cadence, and let it come to you instead.

Claude Chat & Claude Cowork Tips

Use Projects to Stay Organized & Build Context Over Time

In Claude Chat and Claude Cowork, Projects are the main way to stay organized. A Project groups related chats together and gives them shared context: custom instructions plus any files or knowledge you add.

Instead of starting cold every time, spin up a Project for each ongoing area of your life or work (a website, a trip you're planning, a research topic) and let context accumulate there. Over time the Project "remembers" the relevant background, so each new conversation picks up closer to where the last one left off.

Plan Your Day & Week with Claude

One of my favorite personal uses: Claude as a calm daily and weekly planner. I connect it to my task manager (I use Things, via a connector) and my calendar, then run a short planning ritual inspired by Sunsama's "start calm, stay focused, end confident." I never really used Sunsama itself; hearing an episode about it on the Love At First Try podcast was the catalyst that got me to build my own planning system with Claude.

Each evening I plan the next day. Claude pulls up tomorrow's calendar and my task list, we estimate how long each task will really take, and it checks whether that actually fits the free time I'll have. Then it helps me prioritize, defer whatever won't fit to a specific day (not a vague "later"), and sequence what's left into a realistic shape. Weekly, I zoom out to pick a few priorities and spread recurring tasks across the days.

The point isn't to cram more in; it's the opposite. A shorter, realistic plan means you start calm and end the day feeling accomplished instead of behind. Tell Claude how you like to work (I want mine warm and realistic, not a productivity coach cracking a whip), and it'll plan with you rather than at you.

Miscellaneous Tips

A grab bag of smaller, more specific tips. This section will grow over time.

Talk to Claude with Dictation

Typing isn't the only way in. I often talk to Claude instead, using dictation, which is especially handy when I want to dump a lot of context or think out loud. Speaking is usually faster than typing, and it lowers the friction of giving Claude the full picture. Your device's built-in dictation works fine, and there are dedicated tools (I use Wispr Flow) that transcribe more accurately and let you dictate into any app. If you tend to keep your prompts short because typing is a chore, dictation is an easy way to give Claude more to work with.

Let Claude Crunch Your Data & Spreadsheets

Claude is genuinely good at data analysis, so put your numbers in front of it. Paste a table, upload a CSV or spreadsheet, or connect the source directly, then ask it to find patterns, summarize, or sanity-check the figures. I lean on this constantly: writing and fixing Google Sheets formulas, analyzing expenses and spotting variances from month to month, reconciling records that are supposed to match, and running the math on recurring calculations. You can go from "here's a messy export" to "here's what it actually says" in one step, and because you can keep asking follow-up questions, it doubles as a way to understand your data, not just crunch it.

Let Claude Help with Tedious Forms & Questionnaires

Forms, questionnaires, and paperwork are a slog, and Claude is a great helper for getting through them: procurement and vendor questionnaires, intake forms, tax forms, and the like. I don't have it fill them out and take its word for it. I use it to check my own answers, explain what a confusing question is actually asking, point me in the right direction, and draft wording that I then verify before submitting. Give it the form (a PDF or screenshot works) plus the relevant context, and it turns a tedious, error-prone task into a faster one where you stay firmly in the driver's seat.

Vet Suspicious Emails & Links

When an email or link looks off, ask Claude before you click. I regularly paste in a questionable message, or the real destination behind a link, and ask whether it seems legitimate and why. Claude is good at spotting the usual phishing tells: mismatched or lookalike domains, manufactured urgency, odd sender addresses, and requests that don't fit the supposed sender. It's a quick gut-check that has flagged more than one bit of spam and phishing for me. Two caveats: don't paste truly sensitive information into a chat just to vet it, and treat Claude's read as a second opinion rather than the final word; when you're genuinely unsure, the safest move is to verify through a trusted, independent channel.

Consolidate & Clean Up Your Gmail Filters

If you've used Gmail for years, your filters have probably multiplied into a redundant, hard-to-follow mess. Claude can consolidate them for you, and the trick is to feed it the right input. Instead of having it read screenshots, export your filters first: Gmail lets you download all of them as a single XML file (Settings → Filters and Blocked Addresses → Export), which Claude can parse precisely. Keep that export as a backup while you're at it.

When I did this, Claude parsed all 84 of my filters, grouped them by what they actually do, merged the duplicates and near-duplicates, and produced a new import file with just 20 filters that preserve the exact same behavior, then ran a coverage audit to confirm every original filter was accounted for.

A few of the smarter consolidations it made:

• Merged pairs of "from a friend" and "to a friend" filters into one, using Gmail search syntax in the "Has the words" field. That field accepts full search operators, so a single filter can match "from X OR to X," something the separate From and To fields can't do, since they combine with AND.
• Combined two long sender lists, de-duplicated and alphabetized them, then re-split them into balanced A–I and J–Z lists that stay under Gmail's character limit.
• Collapsed all the "skip inbox and mark as read" filters into two (financial versus marketing), and merged five separate "delete" filters into a single trash filter.
• Dropped one broken filter that had no action at all.

The result was a single consolidated XML file I could bring in via Settings → Filters → Import. Because I'd kept the original export as a backup, it was safe to delete all the old filters first. (Filter order doesn't matter, since every matching filter fires on each message and their actions simply stack.) Going from 84 tangled filters down to 20 clean ones made the whole setup far easier to understand and maintain.

Listen to Other People Talk About How They're Using Claude

One of the best ways to get better with Claude is to hear how other people use it. Some of my favorite podcasts that talk about Claude are The Panel, Startup to Last, and Love At First Try. I'm sure there are many more, and you can always use Claude to find them. 😏