I haven’t even paid for Claude Code yet, and I’m already anxious about wasting it. Which is a ridiculous thing to be nervous about, but here we are.

I did what anyone would do and googled “Claude Code tips” only to end up staring at tab after tab of slash commands, config files, and workarounds.

Every one of them hinted I was about to burn through my quota before I even started 🙈

For context, I’ve bounced among Codex, Cursor, and Antigravity, and I’ve only used Claude Code a little at work. Now I’m about to subscribe so I can use it on my own projects, and I’d rather not learn the quota lessons the expensive way.

So I skipped the tip lists and went straight to Anthropic’s own docs. From there, I sorted what you need on day one (especially coming from Cursor) from what can sit on the shelf for a while.

I’m starting in the Desktop app because it’s closer to what I’m used to, so each step below gives you the Desktop way and the terminal way. Follow whichever one you end up opening.

Since I haven’t logged hundreds of hours here, I’m not asking you to take my word for any of it. The main claims link back to the docs they came from. By the end, you’ll know which version to open, what happens to your AGENTS.md, how to stop leaking quota, and what your first session looks like.

None of it requires making Claude Code your whole personality, because there’s plenty of fish in the super intelligence sea.

Let’s get started 👇

Should I Use Claude Code in the Desktop App, the Terminal, or VS Code?

Honestly, it matters less than the internet makes it sound, because every one of them runs the same underlying engine. Your CLAUDE.md files, settings, and MCP servers (connectors to outside tools) follow you from one to the next, so you’re only choosing where you want to watch the work happen.

The web version at claude.ai/code is the odd one out. It runs in Anthropic’s cloud, so it suits repos that aren’t on your machine.

For everyday work on your own laptop, you’re choosing between the other three.

Why Start With the Claude Desktop App if You’re Coming From Cursor?

The Desktop app is the gentlest way in, and it’s where I’m starting. You download Claude, sign in, and click the Code tab, and that’s the whole setup.

Note: The app already includes Claude Code, so there’s no separate install, but it does need a paid plan.

Each conversation is its own session, listed in a sidebar, and you can run several side by side. Diffs (the before-and-after view of what Claude changed) open in a visual viewer where you can comment on individual lines. The app even has its own terminal and file editor, so you never have to leave it to run a command.

If that sounds familiar, it should. It’s literally another variation of Cursor’s Agents Window, similar to the one in Antigravity and VS Code. They’re all peas in the same pod.

If you’d rather stay in an editor, the VS Code extension shows diffs inline, and the install page has an Install for Cursor link.

What Does the Terminal Do Better Than the Desktop App?

I was really curious about this one because I want to maximize my use. It turns out the terminal does a few things better, though none of them matter on day one.

It’s the full-featured version, and the one most tutorials assume you’re using (which explains a lot about why the internet makes it sound mandatory). It has a dontAsk permission mode that Desktop doesn’t, and permission modes are the settings that control how much Claude can do before it checks with you. It also has the flags built for scripts and automation, which Desktop has no equivalent for.

I plan to start in Desktop and try the terminal once I want those features (if they’re not eventually rolled into Desktop first, since everything seems to consolidate these days). The good news is that your sessions follow you either way:

• Type /desktop in a terminal session to continue it in the Desktop app.
• Type /resume in the Desktop prompt box to pick up a session you started in the terminal.

(Not gonna lie, I love this feature 😁)

Hey! I’ll be referencing quite a few commands and certain features throughout the post. Everything is up to date as far as I could find while looking at the docs from the day of writing this. That said, things change super rapidly, so don’t be surprised if something is different.

How Do I Install Claude Code on a Mac?

For the Desktop app, download the universal Mac build, which covers both Intel and Apple Silicon. Sign in, click the Code tab, and you’re done. If clicking Code asks you to upgrade, you need a paid plan first!

The Desktop app doesn’t give you a claude command in the terminal, though. If you want that too, one line does it:

curl -fsSL <https://claude.ai/install.sh> | bash

Open a fresh terminal window afterward and run claude --version. If it prints a number, you’re set. Then cd into a project, type claude, and log in when it asks. (And if you’d rather keep going in Desktop, use the handoff from the earlier section to move that session over.)

If you’re a Homebrew person, there are two casks, and the difference is how fast you want new versions:

1. claude-code follows the stable channel, which runs about a week behind
2. claude-code@latest gets new versions as soon as they ship

Note: Homebrew installs don’t update themselves, so run brew upgrade claude-code (or claude-code@latest) when you want a newer version.

Does Claude Code Read My AGENTS.md or Cursor Rules?

This generally confuses people (me included), but the short version is that you probably already have most of what you need.

Your AGENTS.md works as it is, and your Cursor rules come over with one command. There’s one trap you need to know about, though, and it’s coming up below.

Do I Need a CLAUDE.md at All?

No, you don’t need a CLAUDE.md. You can start without one, since most first prompts work fine without any setup.

Nor do you have to copy your AGENTS.md into a CLAUDE.md because if your repo has an AGENTS.md and no CLAUDE.md in the project folder or any folder above it, Claude Code reads the AGENTS.md instead.

That fallback only exists in newer versions, 2.1.277 or later, so check yours like this:

• In the terminal, run claude --version.
• In the Desktop app, type /status in a session and read the Claude Code row.

Tip: Desktop carries its own copy of Claude Code, so the terminal command can show a different number than the one you’re actually using.

If yours is older, update and start a new session. In Desktop, open Claude > Check for Updates. For Homebrew, run brew upgrade, and the native installer updates itself.

Why Is Claude Code Ignoring My AGENTS.md?

Probably because a CLAUDE.md showed up somewhere. The moment a CLAUDE.md, a .claude/CLAUDE.md, or a CLAUDE.local.md exists in that path, AGENTS.md gets skipped entirely.

So if you create a CLAUDE.md with two lines in it, Claude Code reads those two lines and ignores the rest of your AGENTS.md.

Yes, really.

Your personal ~/.claude/CLAUDE.md doesn’t count, but CLAUDE.local.md does. Creating one for your own notes can switch off the AGENTS.md everyone else shares 😬

The fix that works in both apps is a CLAUDE.md that pulls AGENTS.md in on its first line and adds anything Claude-specific underneath:

@AGENTS.md

## Claude Code
Plan first for anything that touches `src/payments/`.

Tip: In the terminal you can also type /config and set Project instructions to claude-md-and-agents-md to load both files. I couldn’t confirm that setting in Desktop’s settings, so the import line is the safer route there. Or you can follow my hybrid approach where I’ll initialize or init an existing project with Claude Code in terminal then transfer over to Desktop 😏

I Have Cursor Rules. Do They Come With Me?

Mostly, yes, and there are two ways to bring them over: /import cursor and /init.

/import cursor is the bigger one. It brings your Cursor setup into Claude Code, including instruction files, MCP servers, commands, subagents, and skills.

Tip: Add --dry-run to preview all of it without writing anything. It needs version 2.1.265 or later, and /import codex does the same for Codex.

If you only want the rules, run /init. It reads .cursor/rules/ and .cursorrules and folds the relevant parts into a starter CLAUDE.md. Treat that file as a rough draft, because most of what you do next is deleting lines.

Both are built-in commands, so you can find them in the terminal and Desktop by typing / to browse the list. If one isn’t there, run it once in a terminal inside the project. Both apps read the same project files, so the result carries over.

Tip: To check that your file loaded, the terminal’s /context lists the memory files. Desktop goes a step further and displays context in the session rail sidebar.

Related: All You Need To Know About AI Workflow Files And How To Use Them

What Should Go in a CLAUDE.md, and How Long Should It Be?

A CLAUDE.md earns its place by telling Claude what it can’t learn from reading your code, and every extra line costs context in every session. Think of it as the stuff you’d have to tell a new teammate because it isn’t written down anywhere, and nothing more.

The recommendation I found was to keep it under 200 lines, because longer files eat context and Claude follows them less reliably (though I know people who have lengthy versions 🤷‍♀️).

So what goes in? Your exact test, typecheck, and lint commands, plus spots where the code is misleading. Add the decisions that never made it into the repo and anything you’ve had to correct twice.

Skip the architecture tour and the file layout, since Claude can read the repo on its own.

File paths are fine when they’re instructions, like “API handlers live in src/api/handlers/“.

An @path is different, because it pulls that entire file into context every session.

Tip: Wrap a path in backticks and it stays plain text instead of importing the whole file.

To edit the file in Desktop, open the Files pane from the menu in the session’s title bar, make your changes, and click Save.

Note: Edits you make to CLAUDE.md mid-session don’t apply until you start fresh. In Desktop, that means a new session. In the terminal, run /clear or /compact, or restart. Trim the file, then start fresh.

And yes, rules exist here too. Files in .claude/rules/ with a paths: filter load only when Claude works on matching files.

How Does the Claude Code Usage Limit Work?

Anthropic doesn’t publish message counts, which is a big part of why this made me nervous. I couldn’t find a number to plan around.

What you can find is what drains the limit faster, and the good news is that most of it is in your hands. Conversation length, model choice, and whether the cache stays warm (more on that in a minute) decide most of it.

Explore: Claude Free Tier Actually Slaps Now (If You Use It Right)

What Counts Toward My Usage Limit?

A long conversation in your browser eats into the same pool for code since chat, Claude Code, and Desktop all spend from one shared allowance.

Two clocks run at once:

1. a session limit resets five hours after your first message
2. a weekly limit resets at a fixed time for your account (verified Ultra accounts skip the five-hour one)

What you burn depends on conversation length, features you use, model, and effort level.

In the Desktop app, click the usage ring next to the model picker to see your context window usage and your plan usage for the period. Or, like on claude.ai in the browser, go to Settings > Usage to see how much of your session is left.

In the terminal, type /usage. It splits your usage by skill, subagent, plugin, and MCP server, and calls out anything eating more than a tenth of it.

Note: I’m on the enterprise plan for work, and it doesn’t really work with a weekly limit. It’s (sadly) a monthly limit. So depending on the status of your subscription, your limits may vary.

Does Claude Code Really Remember My Project for an Hour?

I’d heard about the one-hour window, and it does exist, but calling it memory is misleading, since the model remembers nothing between requests.

What happens instead is that Claude Code resends the whole conversation every time. The prompt cache is a copy of what the server already processed, so re-reading it costs less.

Subscriptions get a one-hour cache for the main conversation, and the timer keeps resetting while you work. An active session stays warm, but if you step away for more than an hour, the cache expires, and your next message pays full price to re-read everything.

A long conversation may get compacted for you shortly before that happens. The window also drops to five minutes once you’re drawing on extra usage credits.

Tip: In the terminal, /usage also shows a Prompt cache line after your first reply, which tells you whether the cache is warm right now.

Does Claude Code Have a Codebase Index Like Cursor?

I’d assumed Cursor had one and Claude Code didn’t, so I figured I’d have to make up for that somehow. Turns out that assumption was out of date.

Current Cursor builds dropped the semantic index, according to a staff reply on the Cursor forum from August. Its agents now use a grep tool plus normal file reads. Claude Code explores your code at the start of every task.

So I stopped worrying about the index and started worrying about my prompts, which is the part I actually control.

Specific prompts save you correction rounds later. All you do is point at the file, describe the symptom, and spell out what a fixed version does. Type @ and a path to attach a file’s contents instead of describing it.

Explore: Is Prompt Engineering Still Worth Learning? What to Learn Next (and When)

Should I Start a New Chat for Every Request in Claude Code?

In Cursor, I used to treat a chat as one request plus a few follow-ups. Here, a session is one task, however many follow-ups it takes, and you start fresh when you switch to something unrelated.

Tip: If you stack unrelated tasks in one session, every new message drags the old ones along, and you keep paying to re-read work you’re already done with.

Most current models have a 1M-token context window, which is how much Claude can hold in view at once. The conversation also compacts on its own before it fills. Running out of room is rare, so the reason to start fresh is to keep a session focused and cheap.

How Do I Start a New Session or Go Back to an Old One?

In the Desktop app, each conversation is a session, so you start fresh with New session in the sidebar or Cmd+N. To go back, click the old session in the sidebar. You can also click a session’s title in the toolbar to rename it, which helps when you have several going.

In the terminal:

• /clear starts a new conversation with empty context
• /clear oauth-migration labels the one you’re leaving, so you can find it in the /resume picker later
• /resume opens that picker
• claude --continue reopens your most recent conversation from your shell

Can I Work on Two Things at Once?

Yes, and each one gets its own session. In the Desktop app, click New session again, and the sidebar keeps both running. Hold Cmd and click a second session to see two side by side.

For a Git project, pick the worktree option next to the branch name, and that session works in its own isolated copy of your project, so two tasks can’t overwrite each other’s edits. In the terminal, claude -w feature-auth starts a session in a new worktree.

Each session keeps its own context, so one task’s history doesn’t ride along into the other. You don’t need to sweat too much about it either. The agents in different chats are smart enough that if another one is working on shared files, one is going to hold off to avoid overrides 🧠

What If Claude Keeps Getting the Same Thing Wrong?

Two corrections are the limit. When the second one doesn’t stick, stop correcting. This comes from personal experience.

Instead, start a new session (/clear in the terminal) and write one fresh prompt that includes what you learned.

Why start new? Mainly because round three would keep two failed attempts in the conversation for Claude to re-read every time.

How Do I Undo Something Claude Did?

In the Desktop app, the stop button or Esc interrupts Claude. In Manual mode, you see a diff for each change and can accept or reject it before it’s applied.

In the terminal, /rewind opens a menu, and so does pressing Esc twice on an empty prompt. From there you can restore the code, the conversation, or both, or summarize from a message you pick.

Rewind can’t undo changes that only happened through shell commands, so it’s no replacement for git.

How Do I Keep a Long Claude Code Session From Getting Cluttered?

Long sessions are where quota disappears, because every message re-reads everything before it. Which means the longer you ramble, the more each new message costs you.

The fixes are small: keep side questions out of the conversation, and carry only what matters into the next session.

Can I Ask a Quick Question Without Adding to the Conversation?

Yes, with a side chat (a surprisingly neat feature). /btw answers a quick question without adding anything to the history, so the conversation you re-read on every turn stays the same size.

In the terminal, type /btw followed by your question. In Desktop, press Cmd+; to open a side chat, or type /btw in the prompt box.

The side chat can read everything in the main thread up to that point, and you close it when you’re done!

It still costs a request, so it isn’t free. Desktop doesn’t save side chats either, so you can’t reopen one after you close the app.

Tip 💁‍♀️
I’m actually really liking this feature. The main way I’ve been using it is to ask a clarifying question or to request a critique of a proposed action or solution. My favorite part: I can ask the side chat agent to pass what it found back to the main session’s chat, which makes for an easy follow-up (aka I don’t need to reiterate a finding or copy-paste).

Should I Use /compact or Ask for a Handoff Note?

Use /compact when it’s the same task and the conversation has grown long. It summarizes the history, and you can point it at what matters.

For example:

/compact keep the API changes and the test commands

It works the same when typed into the Desktop prompt box, and Desktop also summarizes on its own when the context fills (same with Cursor).

Compacting reads the whole conversation itself, so it gets most expensive once the cache has gone cold. Do it at a natural stopping point, not after lunch 😌

A summary can drop small details, though. If you’d rather decide what carries over, ask Claude to write a handoff note to a file like HANDOFF.md covering what’s done, what’s left, the decisions you made, and the commands that matter.

Then start a new session (Cmd+N in Desktop, /clear in the terminal) and point it at the file with @HANDOFF.md. It’s the same pattern the docs use for specs: write the plan to a file, then build from a fresh session.

Your CLAUDE.md survives compaction, but an instruction you only gave in chat might not. If it matters, put it in the file.

What Is Plan Mode in Claude Code, and Which Model Should I Use?

Two settings shape how Claude Code behaves before you type a prompt:

1. whether it can edit files right away
2. which model does the thinking

In Desktop, both sit in the row under the prompt box.

What Is Plan Mode?

Plan mode makes Claude read and propose before it touches anything. It’s meant for looking around a codebase before you change it, and nothing gets edited until you approve a plan. It works exactly the same as in all the other agentic IDEs like Cursor.

In Desktop, open the mode selector next to the send button (Cmd+Shift+M opens it) and pick Plan.

The Code tab starts in Manual (called Ask permissions in older versions), where you see a diff and accept or reject each change.

A mode you pick sticks per folder, except Plan, which applies to the current session only. Auto shows up in the selector when it’s available to you.

Shift+Tab doesn’t cycle modes in Desktop, so use the selector there. In the terminal, Shift+Tab cycles them, claude --permission-mode plan starts in plan mode, and /plan switches into it from the prompt.

Note: On Claude Code 2.1.283 or later, new terminal and VS Code sessions start in auto mode. There, a second model reviews risky actions instead of you approving each one, but that’s no safety guarantee, so keep an eye on the diff.

Which Model and Effort Should I Pick?

Fresh terminal sessions default to Sonnet 5.5 at medium effort on most plans, and medium is plenty for everyday feature work.

Effort is how hard Claude thinks before answering. Raise it for cases that are easy to overlook, like a flaky test or a bug in code you didn’t write. I also tend to raise it for plans that need some serious brainpower.

Sonnet is the cheaper pick for routine work.

In Desktop, the model picker sits next to the send button (Cmd+Shift+I opens it), and Cmd+Shift+E opens the effort menu. In the terminal, /model and /effort do the same jobs.

Tip: Pick both at the start of a session and don’t switch models mid-session. A model switch makes the next turn uncached, so Claude re-reads everything at full price. This is similar to Cursor, in case you didn’t know.

Do I Need Skills, Subagents, MCP, and Hooks in Claude Code?

Not on day one. Each one solves a problem you may never run into, and from what I’ve heard, piling on the tools and directions can degrade performance.

So if you’ve seen all four of these in someone’s setup and felt behind, you’re not.

Skills and Subagents

You most likely know these since Cursor has them too. A skill is a saved procedure, a SKILL.md file in .claude/skills/<name>/. Claude keeps only the name and description handy and loads the rest when a task needs it. That makes it the right home for a long release checklist you don’t want sitting in CLAUDE.md.

In Desktop, type / or click the + button and pick Slash commands to browse what’s available.

Subagents are helper Claudes with their own context window. Claude spins them up itself, so you don’t need to build any. They aren’t free, because every subagent’s requests count against the same allowance and a fresh one has to gather context from scratch. They pay off for parallel work and for noisy output like full test runs.

Tip: Ask subagents to report back in a few lines so you don’t get a wall of results in your conversation. In Desktop, running subagents show up in the tasks pane.

MCP and Hooks

MCP servers connect Claude to outside tools like Google Drive or Jira or Figma or whatever service these days.

In Desktop, click the + button next to the prompt box, pick Connectors, and add what you need. Settings > Connectors manages them. In the terminal, claude mcp add adds one and /mcp manages them.

Each connected server adds its tools to your context whether or not you use it, so disable the ones you don’t need. (I’ve said this before for Cursor, and the same rules apply here, friends.)

Hooks are shell commands that run at fixed points, like formatting a file after every edit. A CLAUDE.md line is advice that Claude usually follows, while a hook is enforced every single time.

Tip: If you’ve told Claude the same rule three times in all caps (losing a few hairs along the way) and it still misses it, that rule wants to be a hook.

Auto memory needs no setup. Claude saves its own notes from your corrections for each repo, and /memory lets you browse or delete them in the terminal. I even ask for certain things to be added to those notes (a direct result of the hair-pulling moments).

Related: When to Replace Your AI Agent’s Context Files With MCP (and When Not To) — when to use it plus what led to my custom one.

What Should My First Claude Code Session Look Like?

If you opened a project right now, here’s the order I’d run it in. The Desktop way comes first, with the terminal version in parentheses.

1. Commit or stash whatever you had going so git has your back. In Desktop, open the Code tab, choose Local, and pick the project folder. (In the terminal, cd into the project and run claude.)
2. Bring your instructions over with /import cursor --dry-run or /init. Then cut CLAUDE.md down to what Claude can’t work out from the code. If you already have an AGENTS.md you like, skip this step.
3. Start a new session so the trimmed file loads. (Cmd+N in Desktop, /clear in the terminal.)
4. Pick Plan in the mode selector (Shift+Tab in the terminal) and give Claude one task: the file, the symptom, and what fixed looks like. Read the plan before you approve it.
5. Switch to Manual or Accept edits to carry it out, then review the diff. (In the terminal, approving the plan does the switching.) In Desktop, click the line-count indicator to open the diff viewer.
6. Start a new session before the next task, or /compact at a natural break if it’s the same one. Use /btw for side questions along the way (I’m naturally curious and legit loving this!)
7. Check the usage ring at the end to see where the quota went. (/usage in the terminal.)

It’s a Wrap

Well, that was a lot, but it was all intentional, and I hope it’s truly helpful for narrowing down how to get started without turning into a Claude Code expert.

I’ll admit three of my own assumptions turned out to be outdated or half right before I’d even started looking into all this. The Cursor index that no longer exists, the one-hour cache in Claude Code, and the one-request-per-chat habit all surprised me.

This stuff changes fast, so when something doesn’t match what you’re seeing on your screen, check the docs.

I’ll follow up with more tips and the more advanced features as I keep working and getting familiar with the interface. For now, I’m fairly convinced all of these tools do the same basic job, and it’s a matter of learning their quirks.

Until then, I’d love to know which Cursor habit you’re hoping carries over, and which one you’re ready to drop.

See ya, friends ✌️