I didn't expect a window manager to change how I work. I figured it would shuffle some rectangles around. Instead I stopped noticing windows at all, and honestly, that turned out to be the whole point.

So this is the setup I landed on, why I think it's the best one you can run on a Mac right now, and the thinking behind each choice. It's opinionated, and that's on purpose. "Best" is a claim, and I'd rather defend a claim than hand you a safe little list.

The problem nobody admits they have

macOS treats windows like loose paper on a desk. Beautiful, expensive desk, and you spend the day shuffling paper. Cmd+Tab cycles apps but not windows. Mission Control fans everything out and makes you aim with a trackpad. Stage Manager hides what you wanted and shows what you didn't. The thread running through all of it: each one asks you to make a decision, with your hand, right now.

That's the real cost. Not the seconds spent dragging a window, but the attention spent deciding where it goes. A good window manager doesn't make the dragging faster. It deletes the decision.

The thesis: determinism beats flexibility

Here's the belief the whole thing rests on. A window layout you can predict is worth more than one you can perfect.

Flexible systems (drag anywhere, resize anything) sound better and feel worse, because every session you rebuild your layout from scratch and it comes out a little different each time. Your brain never gets to cache it. A deterministic system trades a bit of theoretical perfection for something better: the same keystroke always does the same thing, so after a week your hands know the layout better than your eyes do.

That's why I run a tiling window manager (AeroSpace, if you want the specific tool), and why I set it up the way I do. Everything below comes from that one idea.

1. The keyboard is the interface, not a shortcut to it

Most "keyboard shortcuts" are just accelerators, a faster path to something you could also do with the mouse. In a tiling setup the keyboard is the only path, and that constraint is the feature.

With no fallback to dragging, you have to design a small vocabulary: focus, move, resize, fullscreen. Four verbs. I bind them to the home row (h/j/k/l for direction, Vim-style) so my hands never travel. Arranging windows ends up costing about what typing a word costs. Near zero, and unconscious.

The deeper win is that because the input is uniform, I think in intent ("put this beside that") instead of mechanics ("grab the title bar, drag to the 47% mark, release"). The mechanics just disappear.

2. Tile by default, accordion when it's crowded

A blank workspace should fill itself. Open one window, it takes the screen. Open a second, the screen splits. No placement, no overlap, no decision. This is the 90% case and it should take zero thought.

But tiling has a failure mode everyone hits and few admit: past three or four windows, each slice gets too thin to use. The honest fix isn't "tile harder," it's to switch layouts. Accordion mode stacks windows with a small offset so you see the edges of the others and flip through them like a card deck. One keystroke toggles between the two.

The idea is to match the layout to the window count, and make switching cheap enough that you do it without thinking. Tiling and accordion aren't rival philosophies, they're two tools for two densities.

3. One app, one home, forever

This is the rule that did the most for me, and it's almost embarrassingly simple: every app gets a permanent, named home, and the name is the app.

Slack always lives in one place. The browser always lives in another. They don't move, they don't shuffle, and I don't decide where they go each launch. A rule drops them in place the moment they open. Going to an app and going to its location become the same action.

Here's why that matters more than it sounds. It turns "find my Slack window" (a search problem you solve with your eyes and trackpad) into "go to Slack" (a memory problem you solve with one key). Search is slow and breaks your train of thought. Recall is instant and doesn't. You do this hundreds of times a day, and the difference adds up into something you can actually feel.

I key each workspace to the first letter of the app, a small mnemonic so I never have to remember a number. "Where's Slack? Wherever S is." The mapping documents itself.

Wiring it up: giving your own apps a home

The theory's nice, but the part people actually want is "how do I make my apps do this?" In AeroSpace it's two steps.

Step 1: find the app's ID. Open the app, then run:

aerospace list-apps

You'll get a table of every running app and its bundle ID, which is the stable identifier AeroSpace matches on (not the window title, which changes all the time):

app-id                          app-name
dev.warp.Warp-Stable            Warp
com.google.Chrome               Google Chrome
com.tinyspeck.slackmacgap       Slack

Step 2: add an on-window-detected rule. In your aerospace.toml, each rule says "when a window from this app shows up, send it home." This is what turns "one app, one home" from a habit you maintain into something that just happens:

[[on-window-detected]]
    if.app-id = 'dev.warp.Warp-Stable'        # Warp terminal
    run = 'move-node-to-workspace W'

[[on-window-detected]]
    if.app-id = 'com.tinyspeck.slackmacgap'   # Slack
    run = 'move-node-to-workspace S'

Reload the config (alt-shift-; then r, or aerospace reload-config) and the rule fires the instant the app opens. You never place that window by hand again. It scales to as many apps as you want to pin: run list-apps, copy the ID, point it at a letter workspace. Keep the workspace letter matched to the app's first letter and the config stays readable. Six months later you can skim it top to bottom and know exactly where everything lives.

4. The mouse follows my attention

Small touch, big payoff. When I jump focus to a window, the cursor quietly slides to the center of it, and on multiple monitors it follows me across screens.

It isn't about laziness. A tiling keyboard workflow creates a subtle disconnect: your attention teleports instantly (one keystroke and you're looking at another app), but normally your cursor stays behind. So the one time you do need to click something, you're hunting for a pointer three windows away. Mouse-follows-focus closes that gap, and keyboard and mouse finally agree on where "here" is.

What I deliberately left out

A good setup is defined as much by what it refuses to do. No window animations, which are just latency dressed up as polish. No floating-by-default, because floating is an escape hatch for the rare app that genuinely needs it (a settings dialog, a media player), not a way of life. And no over-binding: four verbs and a workspace alphabet cover everything. The temptation with these tools is to keep adding keys until the config becomes a second job. Resist it. The best binding is the one you never have to look up.

Why this is the best

Not because it's the most powerful. You can find setups with more features. It's the best because of what it does to your attention budget.

Every window operation here is either automatic (tiling, app placement, mouse-follow) or a single predictable keystroke (focus, move, switch). No aiming, no hunting, no deciding. The system is boring in the best possible way. It always does the same thing, so it fades out of conscious thought and what's left is the work.

That's the bar I'd hold any window manager to. Not "what can it do?" but "how often does it make me stop and think about windows?" Here, after the first week, the answer is almost never, and once you've felt that, the default macOS shuffle is genuinely hard to go back to.

If you've ever closed your laptop a little annoyed at how much of the day you spent fighting your own screen, this is the fix. Pick a tiling manager, commit to determinism over flexibility, give your apps permanent homes, and let the keyboard do the work. Give it a week. You'll know by then.

Where to start: the video that got me into this is AeroSpace on macOS, a solid walkthrough for getting the tool installed and running before you tune it the way I describe above.