Claude Workflow Tips

Claude is the most powerful tool I've used to date. It's been a genuine game-changer in both my personal and professional life. The more I use it, the more workflow tips I pick up, and this page is where I collect them.

These tips come from my own day-to-day use of Claude in many of 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. 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).

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" philosophy. I never really used Sunsama itself; hearing about it from Marc Thomas on an episode of 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. If I want help, 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.

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, and it'll plan with you rather than at you.

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, 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).
• Claude Cowork covers both bases: its Projects have an Instructions section that works just like Claude Chat's project instructions, and it also reads a CLAUDE.md at the root of whatever folder you're working in. Use whichever fits your setup, or both together.

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.

You don't have to write these instructions 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.

Export Your Claude Data for Better Search

You can request an export of all your https://claude.ai/ data from your account settings (Settings > Privacy > Your data > Export data). I export mine periodically and keep the exports in dated subfolders. 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.

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 (in Claude Code, often via a slash command; see that tip below). Better still, many of my skills eventually graduate into scheduled tasks that run on their own, so I don't have to kick them off at all.

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. 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 (related article: "Developing internal skills for recurring documentation processes like release notes"). Tom's I'd Rather Be Writing podcast and blog are great resources 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 Google 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

Use Claude Code for More Than Code

Despite the name, Claude Code is my favorite way to use Claude for plenty of work that has nothing to do with code. It's the same Claude, pointed at ordinary folders on your computer: I use it to draft and polish writing, reorganize files, plan projects, dig through data exports, and run personal routines like my post-payday savings math. A few reasons it's often the version I reach for:

• Your data stays portable. Everything you and Claude produce lives as plain files in folders you own: Markdown notes, trackers, transcripts, drafts. Nothing is locked inside a chat app, so you can search it, version it with Git, back it up, or take it to any other tool.
• Your standing instructions are always in force. Every session begins by automatically reading your CLAUDE.md, so your conventions, guardrails, and shorthand apply every single time, with nothing to re-attach or re-explain.
• It's the leanest way in. Claude Cowork wraps this same engine in a friendlier interface, and I use both, but Claude Code is the more streamlined of the two.

And you don't have to live in a terminal: Claude Code also comes as a desktop app, which is how I use it most. Many of the tips in the Claude Code & Claude Cowork section below (organizing your files, tracker files, transcripts) are exactly this kind of non-coding work.

Create a Global CLAUDE.md for Rules That Apply Everywhere

The CLAUDE.md tip above covers giving each project its own standing instructions. Claude Code also supports a global one: a file at ~/.claude/CLAUDE.md that Claude reads automatically at the start of every session, in every project, layered beneath the project's own CLAUDE.md. The split is simple: project files describe how a particular project works, and the global file holds what's true about you, everywhere. A few examples from mine:

• Personal facts. Details Claude should get right in anything it drafts for me, no matter which project I'm in: the correct names, spellings, and pronouns for the people in my life, and similar background I'd otherwise have to repeat.
• Writing preferences. The style rules I want every draft to follow (tone, phrasing habits, punctuation dos and don'ts), so everything Claude writes for me sounds like me by default.
• Standing working rules. Whenever Claude moves or renames a file, it must find and update every doc that referenced the old path, so my tracking files never go stale after a reorganization.
• Standards for things Claude builds. Every new skill or scheduled task Claude creates for me must include my Reflect & Improve loop (see that tip above), so I never have to remember to ask.

One gap this closes: the "Instructions for Claude" personal preferences you set on claude.ai apply in Claude Chat and Claude Cowork, but Claude Code never sees them. Mirroring the ones that matter in your global CLAUDE.md gives you the same always-on preferences there too.

Keep it lean. Everything in this file loads into every single session, so each line should earn its place: truly universal rules go in the global file, project specifics stay in the project's file, and where the two overlap, the more specific project file naturally governs.

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 web app for browsing Louis Wain's cat art, an app that emails me whenever my favorite YouTube channels post a new video (a notification feature that isn't native to YouTube), and custom connectors (see above) for tools I use daily.

The workflow is approachable: describe what you want in plain language, give Claude the relevant context, 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.

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 easy to fix.

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 tends to live 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.

Turn Repeated Prompts into Slash Commands

Similar to shorthand (above): Claude Code lets you save an entire prompt as a custom slash command. Drop a Markdown file into your project's .claude/commands/ folder and its filename becomes a command: add-photos.md becomes /add-photos, which expands into the full written-out prompt when you type it. I keep slash commands for this website's recurring workflows, like processing a new batch of photos into my photo gallery (/add-photos walks Claude through renaming, converting, thumbnailing, and updating the page, with confirmation steps before anything changes) and auditing my CLAUDE.md against the current state of the project (/review-claude-md).

Two things make this better than re-pasting a saved prompt. First, typing / shows a menu of every command you've defined, so your routines are discoverable instead of buried in a notes app. Second, unlike instructions in CLAUDE.md, a slash command's text loads only when you invoke it, so rarely-used routines don't take up space in every session. My rule of thumb: standing rules and shorthand go in CLAUDE.md, and whole repeatable procedures become slash commands or graduate into skills (above).

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. 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. And whenever you set up an automation like this, it's worth having Claude document how it works in a README, so future-you (and future Claude) can pick it back up without re-deriving everything.

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 (above).

Claude Code & Claude Cowork 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.

Organize the Files on Your Computer

The tip above says to keep your folders organized; this one is about what to do when they aren't. Claude Code and Claude Cowork can see your actual file system, which makes them terrific partners for digital decluttering. I recently used Claude to reorganize years of accumulated files across two Google Drive accounts (cloud-synced folders work fine, since to Claude they're just local folders), and it turned a project I'd been dreading into a series of pleasant conversations.

The workflow that worked for me:

• Start with a read-only audit. Ask Claude to explore a folder and report what it finds (inconsistent naming, duplicate or misfiled content, clutter, huge files) without changing anything. You'll be surprised what's hiding in there: my audit surfaced everything from folders full of machine-generated junk to plaintext password-recovery codes I'd forgotten about.
• Set ground rules up front. Mine were "never delete anything, moves and renames only" and "don't touch these specific folders." Claude honored them for the whole project, and anything that genuinely warranted deleting was proposed to me first (see the guardrails tip above).
• Approve a plan before anything moves. Have Claude propose the reorganization (what moves where, and why), then go item by item. A nice surprise: when I explained the reasoning behind my structure, Claude often concluded my "mess" was actually deliberate organization and recommended leaving it alone. The goal is your system, tidied, not someone else's system imposed on you.
• Make Claude verify its own work. After every batch of moves, Claude counted my files before and after to prove nothing was lost or left behind. Batch renames are great for this too: Claude normalized thousands of my date-prefixed files and folders to a consistent YYYY.MM.DD format so everything sorts chronologically, and verified every single file survived.
• Keep a tracker file. Claude maintained a running Markdown file (in the spirit of the tracker-file tip below) logging every decision we made and every batch it completed. Months from now, I'll know exactly what changed and why, and any future Claude session can pick up where we left off.

One caution from experience: before moving any folder that software depends on (a code project, an app's data folder, anything a shortcut or scheduled job points at), ask Claude to first search for references to that folder's path and tell you what might break. Claude found twenty-some hidden references to one folder I wanted to rename and repaired every one of them as part of the move. That single check is the difference between a tidy reorganization and a mysterious pile of broken workflows.

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 (.md is ideal) and hand it to Claude. It can summarize it, pull out the action items and next steps (I do this after many meetings), answer questions about it, or use it as background for related work. 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.

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

For ongoing projects, certain Markdown file types can help 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 projects with shared GitHub repositories, where each item can note who's on it and when it was finished.
• HOMEWORK.md, a variant of TODO.md, tracks action items or "homework" from recurring sessions (e.g. therapy) or meetings, so nothing falls through the cracks in between.

You don't need all three for every project; use whichever fits and make your own file types depending on what's needed. 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. Many of mine started life as a skill (above) that I later set to run on its own schedule.

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 and news on topics I follow.

Another Cowork pattern I especially like: have a scheduled task drop its findings into a Gmail draft (via the Gmail connector) instead of only reporting back in chat. The draft waits in my inbox as a durable copy I can read later or forward on myself, and because it only ever drafts, never sends, a human stays in the loop (see the guardrails tip above).

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, shared memory, 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.

Run a Separate Desktop App for Each Claude Account

If you have more than one Claude account (I have a personal one and a work one), the desktop app has an annoying limitation: it can only be signed into one account at a time, and as of mid-2026 there's no built-in account switcher, so you end up logging out and back in constantly. The fix, which I picked up from a Reddit thread and have been happily using since: run two instances of the desktop app side by side, each permanently signed into its own account.

This works because the app keeps everything about your login (credentials, settings, conversations, connectors) in a single data folder, and you can point a second instance at a different folder. On a Mac, quit Claude fully, run this one command in Terminal, and a fresh instance appears, ready to sign into your second account:

open -n -a "Claude" --args --user-data-dir="$HOME/Library/Application Support/Claude-Work"

To skip Terminal after that first run, make a tiny launcher app for each account: open Script Editor, wrap that same command in AppleScript's do shell script "...", export it as an Application, and pin it to your Dock. I have "Claude Personal" and "Claude Work" launchers, each with its own icon so they're easy to tell apart. (On Windows, the same trick works with desktop shortcuts to claude.exe plus the same --user-data-dir flag.)

A few gotchas worth knowing up front:

• Sign in with only one instance open. The login handoff goes to whichever instance is running, so with both open it can land in the wrong one.
• Don't duplicate the Claude app itself. Point every launcher at the one real app; copies fall out of sync when the app updates.
• Never launch the same profile twice. The app won't stop you, and two instances sharing one data folder risks corrupting it. My launchers first check whether their instance is already running and simply bring it forward instead of relaunching.
• Know what's shared and what isn't. Each instance has its own login, conversations, connectors, and Cowork scheduled tasks; anything file-based on your computer, like skills and your global CLAUDE.md, is shared by both.

That scheduled-tasks detail turned out to be the sleeper benefit. Tasks only run while their account is signed in, so back when I juggled one app, my work tasks quietly missed their runs whenever I was logged into my personal account. With both instances always signed in, everything fires on schedule.

Fittingly, I didn't set any of this up by hand. I asked Claude to do it, and it verified the approach on my Mac, built and tested the launchers, moved my scheduled tasks to the right instance, and documented everything in a README for future reference. If this tip sounds fiddly, that's the real move: describe the end state you want and let Claude handle the plumbing.

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 sometimes 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 often: 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 can be a slog, and Claude is a great helper for getting through them. 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 share 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 > Select All > Export), which Claude can parse precisely. (Keep that export as a backup.)

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 and Blocked Addresses > Import filters. 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 I'd Rather Be Writing, 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. 😏