Solo development has gotten a lot easier in the AI era, but the development environment is still a pain. That is something I've been thinking about a lot lately.
Ever since I started using AI, I've been touching multiple projects at the same time more often.
I'm building web app A, and also web app B, writing a CLI, and poking at an API server a bit. Things I would have narrowed down to just one before, I now push forward in parallel.
Some people probably use worktrees to develop several features of a single application in parallel, but I mostly work on multiple applications.
Even things I'd have dropped with a "well, it's a hassle, never mind" in the past, I can now get to at least a working state by consulting AI. The hurdle to roughly sketching a design, doing a first implementation, and running it locally has dropped considerably.
What gets in the way here isn't writing code, but the environment for running many things at once.
Until now, one or two projects were manageable at best. Start Docker, start the dev server, shut it all down when you're done. That wasn't a big problem.
Once you start touching several projects in parallel, things change.
This web app has a DB running, another API server is up, and there's this other app too. In a monorepo, four React apps are running at once.
In that state, it gets hard to tell what is running on your local machine.
I often work with Next.js and React, and everything ends up on port 3000, so I lose track of which app is running on which port.
Docker containers multiply, terminal tabs multiply, and environment variables differ per project.
Writing code has become easier than before, but the hassle of running multiple projects at the same time hasn't changed much.
If anything, because AI lets me build more things, there are more occasions when I spin up multiple dev environments at once, and that bothers me more than it used to.
Frontend alone is fine, but once API servers, DBs, and Docker get involved, the local environment gets pretty heavy.
At first it doesn't bother me, but the more projects there are, the more painful it becomes.
I build more with AI, but I still need somewhere to run it
With AI, the cost of writing code has dropped a lot, and touching multiple projects at once has become possible.
But in the end, you still need to do things like
pnpm install
pnpm dev
pnpm test
docker compose up
If you use a DB, you need to start it; if you use an external API, you need to stand up a mock server. A web app needs a dev server running.
Even when AI writes the code, it doesn't take care of the whole runtime environment nicely for you.
Rather, as AI has increased the number of projects I touch, managing the development environment has become more conspicuous than before.
In the past I could focus on a single project, so I didn't have to worry much about the local environment.
But now, touching multiple projects in parallel is becoming normal, at least for me.
I work on web service A, verify something for web service B, and write an API server, all at once.
Then putting everything on my main Mac gradually becomes exhausting.
You don't have to run everything on the Mac
I like the Mac itself. I've been an Apple believer for over 10 years.
As a place to write code, I want to keep using the Mac as is.
But I do wonder whether I need to cram the environment for running apps onto the Mac as well.
Maybe the place where I write code and the place where I run it can be separate.
I have some unused PCs at home, and when https://vscode.dev/ came out, I thought about developing from an iPad and considered trying it. But in the end it became a hassle and I gave up.
Back then, even with personal projects, I was touching only two or three at a time, so it wasn't that painful.
But now that I can build an unlimited number of applications, I routinely build things on a whim, for no particular reason.
The picture I have is to keep writing code on the Mac as before while standing up servers in a separate environment. Put simply, I just want a staging environment of my own with hot reload.
Open the editor, use AI coding tools, do Git operations, think about design.
Meanwhile, actually running the app is left to Windows/WSL or another Linux machine.
Mac
- Editor
- AI coding tools
- Git operations
- Design and research
- Checking in the browser
↓ File sync
Windows / WSL / Linux
- Running the app
- Docker
- DB
- Tests
- Dev server
That's the setup.
I don't want to move completely to a cloud IDE. It costs money, too.
There are directions like VS Code Remote SSH or GitHub Codespaces, but what I'm thinking of is a somewhat looser setup.
Edit on the Mac as usual, and just separate where things run.
It's kind of half remote development.
Where I write: Mac
Where I run: Windows / WSL / Linux
What connects: SSH + file sync
This distance feels about right for me right now.
Why Windows/WSL?
It doesn't have to be Windows/WSL. A Linux server would do, so would a Mac mini, or any spare PC.
It's just that I have a Windows machine and an old 2014 Mac mini on hand, and I'm wondering if I can use them as the execution environment.
Rather than Windows itself, I actually imagine using WSL.
Run Node and Docker on WSL, and SSH in from the Mac.
Sync files edited on the Mac to the WSL side, and start the dev server over there.
For things I need to check in a browser, make them accessible from the Mac side.
That way, I can keep the Mac as my main workplace while offloading only the execution environment to Windows/WSL.
Since I can use machines I already have, it's more casual than keeping a cloud environment up all the time.
Of course things like Codespaces are convenient, but many projects aren't worth moving there every time.
For something I just want to try out, creating a cloud environment, worrying about billing, and getting the configuration in order is a bit heavy.
Then using the Windows or Linux machine at home as the execution environment seems better, since I can treat it roughly.
It's not a big deal if it breaks, and I can just rebuild it if needed.
As an environment where I let AI coding agents touch things, it's also reassuring to have it somewhat separated from my main Mac.
What I expect
What I expect from this setup is that I can keep my main Mac as clean as possible.
Of course, I'll still install minimal development tools on the Mac.
Git, an editor, AI coding tools, a browser, and a terminal are necessary.
I'll install only that much, and push the per-project runtime environments out as much as possible.
DB, Docker, dev servers, running tests: I move those to the Windows/WSL side.
Then the Mac can stay pleasant to use as a place to write code.
Another thing I expect is that it becomes easier to separate environments per project.
That kind of clean separation becomes easier to make.
The problem is file sync
When you actually try it, the biggest problem is file sync.
I write code on the Mac.
That change is reflected on the Windows/WSL side.
The dev server running on Windows/WSL detects the change and hot reloads.
If this doesn't work comfortably, I'll probably stop using it quickly.
I think what matters most in a development environment is, in the end, having no stress.
If updates are even slightly slow, if sync sometimes fails, or if hot reload doesn't work, the desire to use it disappears at once.
Candidates include rsync, Syncthing, Mutagen, SSHFS, and VS Code Remote SSH.
rsync is simple and easy to understand, but to sync continuously you need a mechanism that watches for file changes and runs rsync.
One-off syncs are easy, but if you'll use it throughout development, it takes some work.
Syncthing looks quite good in terms of continuous sync.
But for development use, you need to think carefully about how to handle node_modules, build artifacts, cache files, and so on.
It's painful if things you don't want synced get synced, and equally if things you need don't get synced.
Mutagen also seems close to this use case.
It handles local-to-remote file sync nicely, so it looks like a good fit for separating dev environments.
How well it fits my use, I can't tell without actually trying it.
SSHFS looks simple at first glance, but I suspect I'd get stuck on file watching and performance when using it as a dev environment.
Frontend dev servers in particular depend on file watching, so if that's unstable it's a problem.
I think using VS Code Remote SSH would solve most problems.
But that moves the whole editor to the remote side.
What I want to do this time is edit on the Mac as usual and offload only execution to another machine.
So VS Code Remote SSH is sufficient, but it also feels a bit different from what I want.
Whether hot reload works is what matters
The most important thing in this setup is that hot reload works naturally.
Save on the Mac. Files are synced to the Windows/WSL side. The dev server over there detects the change. The browser refreshes.
If this flow doesn't run without friction, I can't use it day to day.
Conversely, if this part works comfortably, it should become quite practical.
Even if the sync mechanism is somewhat rough, it's good enough if changes are reflected immediately upon saving.
I don't want to build a perfect distributed dev environment from the start.
For my use, if files written on the Mac get synced nicely to the Windows/WSL side and the dev server reacts properly, that alone would help a lot.
I want a sync tool of my own
Thinking about all this, I've started to think I might as well build a small sync tool for myself.
For example, write a config file per project.
project: my-app
local:
path: ~/src/my-app
remote:
host: windows
path: /home/me/src/my-app
ignore:
- node_modules
- .next
- dist
- .git
- coverage
Then, when I start it with something like
devsync start
it watches for changes on the Mac side and sends only the necessary files to the remote side.
Sync everything first, then sync only the diffs afterward.
Exclude things like node_modules, dist, .next, and coverage.
Changes are reflected as soon as I save.
That's about all I want at first.
It doesn't need to be a proper tool from the start.
It's enough if it works in my environment and doesn't cause me trouble.
Eventually, it would be handy if it could do things like
devsync shell
devsync run pnpm dev
devsync run pnpm test
devsync status
But building that far from the beginning would be a lot of work, so I think sync alone is fine to start with.
I can leave the file transfer part to rsync, or just write the watcher myself.
In short: save on the Mac and it's reflected on the Windows/WSL side.
Even that alone has a lot of uses.
The AI-era dev environment may change a bit
Since I started using AI, I feel the bottleneck in development has shifted a little.
Before, writing code itself was the hard part. Design, implement, write tests, verify behavior...
Time went into deciding on an implementation approach, researching libraries, writing the detailed code, and fixing errors.
It's still hard, of course, but I can now get a lot of help from AI.
On the other hand, the hassle of the execution environment hasn't changed much.
If anything, as my code-writing speed has gone up, the hassle of the execution environment has become more noticeable. Even if AI writes the code, the app has to run somewhere. Tests have to run somewhere too.
A DB is needed, Docker is needed, external API settings are needed.
Thinking about it that way, I feel that from now on it will matter not only "how to write code" but also "where to run it safely."
Especially if you let AI coding agents touch a lot of things, separating the main PC from the execution environment seems meaningful.
Having AI run commands. Having AI run tests. Having AI edit files.
If you're doing those things, it would be easier to have a separate machine, a container, or a WSL environment set up rather than letting it mess directly with your main Mac.
Summary
AI has made solo development much easier.
But the hassle of the development environment hasn't changed much.
If anything, because I can build more things, the problem of a cluttered local environment bothers me more than before.
So lately I want to try a setup where I write code on the Mac and run it on Windows/WSL or another Linux machine.
The Mac is where I use the editor and AI coding tools.
The execution environment goes to another machine.
File sync connects the two.
The issues are file sync and hot reload, but if those go well, it should be quite usable.
At first, a small sync tool of my own is enough.
Save on the Mac, get it reflected on the Windows/WSL side, and have the dev server running over there.
That's all I need to start.
For the AI-era dev environment, rather than cramming everything onto one machine, it may be just right to separate where you write code from where you run it a bit.