Need recommendations for the best coding apps for Mac

Mac
1

I’ve recently switched to a Mac and I’m overwhelmed by all the different code editors and IDEs available. I need recommendations on the best coding apps for web development and maybe some light mobile work. What do you use, and why do you prefer it over other options?

2

If you’re on macOS and trying to settle on a decent setup for coding, here’s what actually stuck for me after way too much trial, uninstalling, reinstalling, and side‑eyeing other people’s “perfect setups.”

I’m not saying this is definitive. It’s just what I keep coming back to.

Editors & IDEs I Actually Ended Up Using

I bounced between a lot of tools before admitting what worked and what was just “cool.”

1. VS Code

I tried to avoid VS Code at first because it felt like everyone was using it and I didn’t want to be “everyone.” That didn’t last.

  • Plugin ecosystem is ridiculous. I installed too many at first, then stripped it down:
    • Language support (Python, TypeScript, Go, whatever you use)
    • GitLens for blaming my past self
    • A formatter (Prettier, Black, etc.)
  • Debugging is tolerable instead of painful.
  • Remote development via SSH is solid once you stop fighting it.

I do notice it gets heavier if I leave it open for days. Sometimes I just quit it out of spite and reopen to get memory back.

2. JetBrains Stuff (IntelliJ, PyCharm, WebStorm, etc.)

At some point I realized: when I’m working on a bigger project that’s already kind of a mess, I open a JetBrains IDE almost automatically.

  • Refactors that don’t destroy the entire codebase.
  • Built‑in database tools that are “good enough” for day‑to‑day poking.
  • Git integration that is less annoying than most.

I don’t love how heavy they feel on a fanless Mac. On an M-series with enough RAM, though, the performance complaints I used to see online haven’t matched my own experience.

3. Neovim / Vim

This one is not for everyone, and honestly I quit it multiple times before it clicked.

I use Neovim when:

  • I’m SSH’d into a box and don’t want to forward GUIs.
  • I need to edit config files fast without dragging a full editor into it.
  • I’m in a “don’t-touch-the-mouse” mood.

It took me a while to find a config that was powerful but not brittle. If you go down this road, back up your config before you install whatever the hot plugin manager of the week is.

Supporting Tools That Ended Up Being Weirdly Critical

These aren’t “coding apps” in the strict sense, but I don’t write code comfortably on macOS without them.

4. iTerm2

The built-in Terminal works. I used it for a while. Then I tried iTerm2 and did not go back.

Why I kept it:

  • Split panes without thinking too hard.
  • Profiles for different environments.
  • Better search in scrollback.

I didn’t touch most of the advanced options for months. It still felt like an upgrade out of the box.

5. Homebrew

I remember the first time I had to install something like wget on macOS manually. Never again.

Homebrew gave me:

  • Quick installs for languages, databases, CLIs.
  • A single place to update stuff instead of random installers everywhere.
  • A simple way to keep track of what I’d actually added to the system.

Every time I reinstall macOS, I just copy a Brewfile and let it pull my core tools back in. It’s become the spine of my environment.

File Management & Remote Access (Where SFTP/FTP Actually Matters)

Now, this is the part I underestimated for years. I kept assuming I’d live purely in Git and SSH and ignore GUI file tools.

That fantasy broke the first time I had to juggle:

  • A production SFTP server,
  • A staging box with slightly different paths,
  • And a client’s weird legacy FTP server that nobody wanted to touch.

I tried a bunch of SFTP/FTP clients and file managers on macOS. A few of them looked nice. Some were confusing. One or two crashed at the worst possible time. Eventually, I landed on something I didn’t expect to like as much as I did.

6. Commander One (Dual‑Pane File Manager & SFTP/FTP Tool)

I initially installed Commander One because I missed dual‑pane file managers from older systems. I did not think, “this will be part of my dev workflow.” It sort of snuck in.

How it ended up fitting into actual development work:

  • Dual‑pane view
    Side by side:

    • Local code on the left.
    • Remote server or another folder on the right.
      Instead of bouncing between Finder windows or mixing everything in the terminal, I just drag, compare, and move. For one project I had logs in one pane and source in another so I could quickly pull down specific log files without thinking.

  • SFTP/FTP as a first‑class feature
    I had a client whose deployment pipeline was literally “upload via SFTP.”
    With Commander One:

    • I set up SFTP connections once.
    • Saved them.
    • Reused them without re‑typing hostnames, ports, or paths each time.
      It felt closer to how I use an IDE’s remote tools than a separate clunky “FTP app.”

  • Working inside remote locations like they’re just another drive
    I caught myself forgetting I was on a remote server. Browse directories, rename files, move stuff, all from the same window.
    When I needed to quickly tweak some assets, it was faster to use Commander One than to fiddle with command line one‑liners.

  • Developer-specific use cases that surprised me
    Some things I didn’t expect:

    • Cleaning old build artifacts directly on a remote machine.
    • Quickly checking which log directory was actually filling up disk space.
    • Moving around tarballs and backups without messing up paths.

It’s not an editor or IDE. It doesn’t replace Git. But when I’m doing anything that mixes local projects and remote servers, it’s the tool that’s quietly open in the background doing the boring parts cleanly.

That’s also why I still keep it installed even now that most of my “serious” stuff goes through CI: not every environment is modern, and sometimes I just need reliable SFTP/FTP and a sane file manager on macOS, in one place.

A Few Extras That Helped But Weren’t Mandatory

These are nice to have, not must‑have, but they did make day‑to‑day coding on Mac less annoying.

  • Postman / HTTPie / Insomnia for poking at APIs fast.
  • Docker Desktop if you’re doing anything containerized. It’s not perfect, but it works.
  • TablePlus or similar for dealing with databases without living inside psql 24/7.
  • Diff tools like Kaleidoscope or Beyond Compare for visual diffs when Git’s text output isn’t enough.

How I’d Start If I Was Setting Up A Mac For Coding Today

If I had to wipe my machine tonight and start fresh tomorrow, I’d likely install in this rough order:

  1. Homebrew
  2. iTerm2
  3. VS Code (and then a JetBrains IDE if I know the language I’m focusing on)
  4. Git + SSH keys
  5. Commander One for file management and SFTP/FTP
  6. Then the language runtimes, Docker, DB tools, etc.

I got there by breaking things a few times, being overconfident with “I only need the terminal,” and eventually accepting that a mix of GUI + CLI is what actually lets me move quickly without burning out.

Your mileage will vary, but if you’re on macOS, write code regularly, and ever touch remote servers or SFTP/FTP, having Commander One alongside your editor, terminal, and package manager is one of those small choices that ends up saving you from a bunch of tiny daily annoyances.

2 Likes
3

For web + light mobile on Mac, I’d set expectations like this: you’re probably going to end up with 2–3 tools you actually use, not “the one true editor.”

@-mikeappsreviewer already covered VS Code / JetBrains / Neovim really well, so I’ll try not to rehash that whole thing.

Here’s what I’d actually look at, with a slightly different angle:

1. VS Code… but disciplined

Yeah, everyone says VS Code. They’re not all wrong, but the trap is turning it into a bloated spaceship.

For web dev specifically:

  • Core extensions only:
    • ESLint
    • Prettier
    • Tailwind / Vue / React / Svelte plugin depending on your stack
    • GitLens if you want history inline
  • Turn on format-on-save and let it boss you around
  • Use the integrated terminal so you’re not alt-tabbing every 2 seconds

VS Code is the easiest “I just switched to Mac” editor because it’s basically the same everywhere. I slightly disagree with some folks who claim it’s too heavy; on modern M chips it’s totally fine unless you drown it in plugins.

2. JetBrains for when the project gets real

For “light” mobile and serious web backends, JetBrains stuff is still kind of unmatched:

  • WebStorm for pure web (React/Next/Nuxt/etc.)
  • IntelliJ IDEA if you’re touching Java/Kotlin backend + web
  • Rider for .NET if you end up there
  • Android Studio (built on IntelliJ) for Android

They shine when:

  • You’re refactoring a big codebase
  • You want first-class TypeScript, navigation, and code inspections
  • You’re dealing with complex monorepos

I do think people oversell how “heavy” they are on Mac. On an M1/M2 with 16 GB RAM they’re fine. Where I disagree a bit with @-mikeappsreviewer: I don’t bother opening a JetBrains IDE for small scripts or tiny toy apps. That’s VS Code territory for me.

3. Mobile: keep it “light” for real

Since you said light mobile work:

  • React Native or Expo + VS Code
    Runs fine on macOS, and you just use VS Code as your main editor.
  • Flutter
    Also works nicely; you can use VS Code or Android Studio. I’d avoid going full “all JetBrains + all Android Studio” until you actually know you’ll be in mobile a lot.

If you’re just experimenting, don’t overinstall everything. Pick RN+VS Code or Flutter+VS Code and see what sticks.

4. macOS-specific editors worth at least trying

Stuff people rarely mention but actually nice on Mac:

  • Nova (by Panic)
    Native Mac app, super clean, less junk than VS Code. Great for front-end, but fewer plugins. Nice if you want a minimal but polished Mac feel.
  • BBEdit
    Very old-school, very fast, great for “I need to open and rip apart huge files.” Not my main IDE for web, but good side tool.
  • Sublime Text
    Still insanely fast. I wouldn’t build an entire modern stack on it anymore, but as a lightweight code/text tool it’s ridiculous.

5. Terminal + environment

You’re going to live in the terminal no matter what IDE you pick:

  • iTerm2 is solid, as mentioned already
  • Use Homebrew for:
    • Node / nvm
    • Python / pyenv
    • Git, wget, etc.

This is the boring part of setup but it saves you later when Node versions start fighting each other like toddlers.

6. File management & remote stuff

This is where I actually agree pretty strongly with @-mikeappsreviewer: having a sane dual-pane file manager that does SFTP properly is underrated.

Commander One is really solid for this:

  • Dual-pane layout for:
    • Local project in one pane
    • Remote server / staging box / other drive in the other
  • Built-in SFTP/FTP/FTPS support
    Great if some clients still insist on “just upload to this FTP server”
  • Treats remote connections almost like another drive
    Useful for:
    • Cleaning build artifacts on a server
    • Grabbing logs without scripting everything
    • Quick edits on non-Git legacy stuff

It’s not a coding app in the sense of an editor, but if you’re doing web dev that touches real servers, Commander One on macOS quietly becomes part of the workflow. I prefer it over juggling Finder + separate FTP app + terminal nonsense.

I slightly disagree with the “you don’t need GUI tools, just terminal” crowd here. Yeah, you can script everything, but when a production SFTP box is on fire and you just need to move files around fast, a tool like Commander One is honestly faster and less error-prone than half-baked bash one-liners.

7. If I were in your shoes, starting fresh:

For web + light mobile on a Mac right now, I’d do:

  1. Homebrew
  2. iTerm2
  3. VS Code with a tiny set of extensions
  4. One JetBrains IDE if you know your main backend language
  5. Commander One for file/SFTP stuff
  6. Then pick:
    • React/Next + maybe React Native
      or
    • Vue/Nuxt + maybe NativeScript / Capacitor
      or
    • Flutter if you like Dart

Try that for a few weeks. If you find yourself fighting VS Code’s performance or missing deeper refactors, that’s your cue to lean harder into JetBrains. If not, stay with the simpler setup and don’t let tool FOMO waste your time.

You can always add more tooling later. The worst pattern is installing 9 editors and spending all your “coding time” tweaking themes and keybindings instead of shipping anything.

4

You’re getting a lot of “here’s my perfect stack” answers already, so I’ll come at it a bit sideways and try to answer “what should you actually install first on a Mac without drowning in options.”

I agree with a lot of what @mikeappsreviewer and @codecrafter said, but I don’t think you need to juggle 4 editors right away. That’s how you end up configuring themes instead of shipping anything.

1. Pick one main editor for web

If your goal is web + light mobile:

  • Start with VS Code as your only main editor for now
    • HTML / CSS / JS / TS: great out of the box
    • React / Vue / Svelte etc: first class extensions
    • Mobile via React Native, Expo, or Flutter plugins

Keep extensions very minimal at first:

  • ESLint
  • Prettier (turn on “format on save”)
  • Framework plugin (React / Vue / whatever)
  • GitLens if you want history in the sidebar

If you hate VS Code after 2 weeks, then try Nova or Sublime Text. Nova in particular is nice on macOS if you care about a very “Mac native” feel and don’t need a massive plugin ecosystem.

I wouldn’t jump straight into Neovim or Vim unless you already want a config hobby. They’re great, but they’re also a time sink if your real goal is “learn web dev” not “learn editing philosophy.”

2. Keep JetBrains as your “big guns,” not your default

Where I slightly disagree with both replies: a JetBrains IDE is amazing, but it’s overkill for your early days.

Use a JetBrains tool when:

  • You join a large codebase at work
  • You’re refactoring a serious TypeScript or backend project
  • You need deep inspections, code analysis, database tools

For you right now:

  • If you’re mostly front end: maybe try WebStorm later
  • If you go heavy into mobile (Android native): Android Studio

Until then, VS Code will feel lighter and less “IDE in your face.”

3. Terminal & environment: boring but critical

This is the part everybody skips and then regrets:

  • Install Homebrew first
    • Node / nvm
    • Git
    • Whatever runtimes you need
  • Use iTerm2 or stick with Terminal.app if you don’t care
    iTerm2 is nicer, but you don’t need to dive into its settings on day one.

The earlier you get comfy running npm run dev, git status, etc from the terminal, the easier every editor switch becomes.

4. Web + “light mobile” in practice

Concrete combos that work well on Mac:

  • React + Next + React Native (or Expo)
    One stack, one language (TypeScript), one editor (VS Code). Very straightforward.
  • Vue + Vite + Capacitor
    Also fine, more niche but really nice DX.
  • Flutter
    Uses Dart, runs great on macOS. You can use VS Code with the Flutter extension and only open Android Studio when you must.

Resist the urge to install both React Native and Flutter and every SDK on day one. Pick one mobile approach and see if you even like mobile work.

5. Handling servers, SFTP, and random legacy stuff

This part often gets ignored, but for web dev you will eventually touch:

  • A shared hosting box with SFTP only
  • A staging server with “just upload the files” instructions
  • Weird legacy FTP setups

You can do all of that via terminal, but honestly it gets annoying.

That’s where Commander One is actually worth having on macOS:

  • Dual pane file manager
    • Local project on the left
    • Remote SFTP / FTP server on the right
  • Built in SFTP / FTP / FTPS
    • Save connections
    • Drag and drop deploys when clients are stuck in 2009
  • Treats remote locations almost like another drive
    • Cleaning old build folders
    • Pulling log files quickly
    • Poking around non Git legacy projects

I know some folks flex that “real devs use only scp and rsync” but when prod is broken and you just need to move files fast, a solid GUI like Commander One for Mac is way less stressful than crafting the perfect one liner and hoping you didn’t typo a path.

6. What I’d actually do if I was in your spot

In this order, keeping it simple:

  1. Homebrew
  2. Node (via nvm), Git
  3. VS Code with a tiny extension set
  4. iTerm2
  5. Commander One for file / SFTP / FTP work
  6. Pick one web stack (React or Vue) and one light mobile option (React Native or Flutter)

Stay with that for a month. If you start hitting walls like “I need better refactoring,” that’s when you bring in a JetBrains IDE. If not, ignore the tool FOMO and keep using what lets you move fastest.

TL;DR: one main editor now (VS Code), one heavy IDE later if needed, one solid file manager (Commander One) for real world server crap, and less time in settings menus, more time shipping.

5

If you’re feeling decision paralysis, you can simplify this a lot by thinking in “roles” instead of “apps”:

1. Main editor vs “big IDE”
I’m going to push back slightly on how heavily VS Code and JetBrains are being pushed together. For web + light mobile, you do not need both from day one.

  • Start with VS Code or WebStorm, not both.
    • VS Code: lighter, huge ecosystem, great for jumping between stacks.
    • WebStorm: heavier, but better built-in refactors and inspections for JS/TS.

If you lean to lots of side projects and quick experiments, VS Code wins. If you know you’ll live in TypeScript + React for a long time, WebStorm as your primary is actually simpler than juggling two tools.

2. One “deep work” environment
Where I tend to disagree with jumping straight into Neovim: it is absolutely a productivity boost long term but it is also a hobby. If your goal is web dev, not editor tinkering, treat Neovim as a “later” project.

If you really want a keyboard-heavy workflow without deep config, learn VS Code’s keybindings properly and add a couple of custom ones before you even consider going modal.

3. Servers, SFTP, and file juggling
Here I’m very aligned with what’s already been said, but with a twist: instead of pretending SFTP and FTP are “legacy” only, just assume you will hit them often (freelance work, cheap hosts, staging boxes).

This is where a dual-pane file manager genuinely earns its spot:

Commander One in dev life

Pros

  • Dual-pane layout is excellent for:
    • Local project on one side, remote SFTP/FTP/FTPS on the other.
    • Comparing build output vs source, or logs vs code.
  • Treats remote servers almost like mounted drives, which makes quick tweaks and log grabs way less annoying than juggling scp and ssh all the time.
  • Saved connections and bookmarks cut down on repetitive server setup.
  • Keyboard-friendly enough that you are not stuck mousing through directories.

Cons

  • It can tempt you into “just drag files to prod” instead of setting up a real deploy flow if you are not disciplined.
  • Another app to manage licenses and updates.
  • Not a Git client, so you still need to keep your workflow Git centric and use it mainly for ops / file management, not as a substitute for version control.

I’d still recommend Commander One over trying to stretch Finder plus a random separate SFTP app. It sits nicely next to VS Code or WebStorm and covers that “real world server mess” layer that pure Git flow ignores.

4. Where the other replies fit

  • @codecrafter leans more into the “one main editor” philosophy, which I agree with, especially early on.
  • @cacadordeestrelas pushes a good minimal extension setup, which prevents the classic “installing plugins instead of coding” trap.
  • @mikeappsreviewer’s stack is very complete, but I would treat it as a destination, not a starting checklist. A lot of that only matters once you have bigger projects and more environments.

If you want the shortest practical setup path:

  • Choose exactly one primary editor (VS Code or WebStorm).
  • Install Homebrew, Git, Node.
  • Add Commander One as your “file + remote” workhorse.
  • Ignore everything else until you have actually written and shipped a small web app.