Setting up Cursor AI on a Mac so it works with your existing folders

Installing Cursor on a Mac is a five minute job. Download the build, drag it into Applications, sign in. The part that decides whether the tool is actually useful comes after that, and it has almost nothing to do with the installer: which folder gets opened, how the terminal fits into the picture, what the agent is allowed to read, and where the settings from the previous editor go. Those choices are what separate an editor that reads a project correctly from one that produces confident answers about the wrong files.

Pick the right build before downloading

Three facts settle the download. The official quickstart lists macOS 12 (Monterey) and later, with both Apple Silicon and Intel supported. The download page offers three Mac builds: ARM64, x64, and Universal. And the install page states that a Cursor account is needed before starting, which is free on the Hobby plan and does not ask for a card.

Matching the build to the machine is straightforward. Open the Apple menu, choose About This Mac, and read the chip line. An M-series chip means the ARM64 build. An Intel line means the x64 build. The Universal build contains both and runs anywhere, at the cost of a larger download, which makes it the right pick when one file has to be handed to a mixed fleet of Macs.

The account question is worth settling before the first launch rather than after. On a work machine, signing up with a personal address and later moving to a company Teams seat means re-doing rules, settings sync, and billing. A minute spent checking which account the team uses saves that.

One more thing belongs in the pre-flight check: where the working folder lives. Cursor reads the contents of the folder that gets opened so its search and agent can find things. A folder on a network share or a slow external drive will feel sluggish in a way that has nothing to do with the AI. For the first hour, pick something on the internal disk.

Install, then decide what the first folder is

The install steps themselves match any other Mac app. Download the file, drag Cursor into the Applications folder, launch it from there, and sign in when prompted. Launching from the disk image in the Downloads folder works once and then leaves people wondering why the app is missing from Applications later, so move it first.

The first real decision arrives immediately after sign-in, when Cursor asks which folder to open. That folder becomes the boundary of everything the AI can see. Open a folder that is too wide, such as the home folder or the whole Documents folder, and the search pulls in unrelated files, which makes answers vaguer rather than better. Open one that is too narrow, such as a lone src directory, and the configuration files, the test suite, and the build scripts sit outside the boundary, so the agent cannot run the checks that would prove its own work.

The practical rule for code is the top of the git repository, the level that holds the .git directory. For non-code work, the same principle applies in plain terms: open the level that contains everything related to the job and as little else as possible.

Once the folder is open, the fastest way to test whether the boundary is right is to open the agent panel with Cmd + I and ask it to explain the codebase and name the files worth reading first. The quickstart suggests exactly this as a first move. If the summary matches what is actually in the project, the boundary is correct. If it describes something unrecognisable, the folder is wrong, not the model.

Connect the terminal to the editor

Most people arriving at Cursor on a Mac already have a terminal habit. Two connections are worth making on day one.

The first is the shell command. Open the command palette with Cmd + Shift + P, find "Shell Command: Install 'cursor' command", and run it. After reopening the terminal, typing cursor . in any directory opens that directory in Cursor. The command lands in /usr/local/bin, so which cursor confirms whether it registered. This removes the daily ritual of finding a folder in Finder that is already open in a terminal tab.

The second is the agent's own use of the terminal. Cursor's agent runs commands to install dependencies, run tests, and check builds. How much of that happens without approval is set in Cursor Settings under Agents, in Approvals and Execution. Per the official help, Cursor 3.6 and later default to Auto-review, with Allowlist and Run Everything as the other options. Auto-review screens commands and asks when something looks risky. Leaving the default in place for the first week, and actually reading what ran, is the cheapest way to learn where the boundary of comfort sits.

There is also a terminal-only route that skips the editor entirely. The Cursor CLI installs with curl https://cursor.com/install -fsS | bash and runs as the agent command, supporting the same Agent, Plan, and Ask modes. It is a separate thing from the cursor shell command described above, and the two names are easy to confuse. For work on a remote box, or a quick change that does not justify opening a window, the CLI is often the shorter path.

Bring the old setup across, and keep the old editor

Nobody should rebuild an editor configuration by hand. The official help describes a one-click import: open Cursor Settings with Cmd + Shift + J, go to General, then Account, and click Import under VS Code Import. Extensions, themes, settings, and keybindings come across together. For moving between machines, or for more control over what transfers, a VS Code profile can be exported and imported manually.

Two caveats are worth knowing before that import.

Extensions come from Open VSX rather than the VS Code Marketplace. Most popular extensions are present, some Marketplace-only ones are not, and the same extension name can point at a different publisher. Cursor routes extension search and download through its own proxy and runs automated malware and supply-chain analysis before an extension is offered, and team plans can add an install cooldown or restrict installs to approved publishers. Even so, checking the publisher on the extensions that matter is a two-minute job after import.

The second caveat is really a reassurance: both editors can stay installed. They run as separate applications and can open the same project, which means migration does not have to be a single irreversible step. Running one project in Cursor for a week while everything else stays where it is gives a real answer about fit.

Question	Where the answer lives
Which build for this Mac	About This Mac, then ARM64, x64, or Universal
Does the AI see the right files	Ask the agent to explain the project after opening the folder
Can the agent run commands	Cursor Settings, Agents, Approvals and Execution
Will old extensions work	Check the publisher in the extensions panel after import

Decide what the agent may not read

Every folder opened in an editor with an agent in it deserves one deliberate decision about exclusions. Cursor reads a .cursorignore file at the root of the folder, written in the same style as .gitignore, and blocks the listed paths from the agent, Tab, and inline edit.

The documentation is explicit about the limit of that mechanism: terminal commands and MCP server tools used by the agent cannot be blocked by the ignore file. A command the agent runs in the terminal can still read a file the ignore list covers. This is not a flaw to be worked around with a longer ignore list. It is a reason to keep credentials, customer exports, and anything under a confidentiality obligation outside the working folder in the first place.

The related setting is Privacy Mode, described on the pricing page as something enabled in settings or by a team admin, with a guarantee that code data is not used for training by Cursor or its model providers when it is on. For a work machine, confirming that switch belongs in the same five minutes as the install.

Pricing shapes this decision too, because it determines whether a team account is involved at all. The published plans are Hobby at no cost, Pro at 20 dollars a month, Pro Plus at 60, Ultra at 200, and Teams at 40 per user per month, with prices listed exclusive of tax. The Hobby plan includes the core features with limited agent usage, which is enough to judge whether the workflow fits before anyone files an expense.

Write the project conventions down once

By the third day of use, the same instructions start repeating in every request: use TypeScript, keep components small, run the tests before declaring victory. Cursor's rules system exists for exactly that, and setting it up early pays back quickly.

There are three places a rule can live. User rules are global, stored on the Cursor account, and sync to any machine signed into it, which suits personal preferences such as a preferred response style. Project rules live in .cursor/rules/ inside the folder and are version-controlled, so a whole team inherits them from git. An AGENTS.md file at the root of the folder does the same job in plain markdown for teams that would rather not learn another format.

Two details from the documentation prevent the most common failure. Project rules must use the .mdc extension, because a plain .md file inside .cursor/rules/ is ignored by the rules system. And when rules conflict, they apply in the order team rules, project rules, user rules, with earlier sources winning. A personal preference will not override a project rule that says the opposite.

The advice on content is to keep each rule under 500 lines, split large ones into focused files, and reference files rather than pasting their contents so the rule does not go stale. Starting small works better than writing a manifesto on day one: when the agent makes the same mistake twice, add one line.

Count the windows, not the features

After a week, the editor side of the setup settles down. What remains visible is the traffic between windows. Files get located in Finder, moved into the project folder, handed to an agent running in a terminal, and the results get checked somewhere else again. An editor with an agent inside it shortens the writing, and it can quietly lengthen this other loop, because more work now happens while attention is elsewhere.

That loop is worth measuring before buying anything else. For a day, notice each switch between Finder, the terminal, and the editor. If almost every switch is inside the editor, the fix is here: finish the shell command setup, import the old keybindings, and tighten the ignore rules. If most switches are between Finder and a terminal, the editor was never the bottleneck, and a file manager with a built-in terminal addresses the part Cursor does not.

What to change first

Open the correct folder, run the shell command so cursor . works, and leave command approvals at the default for the first week. If the remaining friction turns out to be Finder and terminal ping-pong rather than writing code, compare how a file manager with a terminal in the same window handles it in Compared with other file managers, and check what that approach covers in Features.