The push toward async work

I've been doing a lot of building lately. Multiple-projects-at-once, hitting-that-obsession-flow-state kind of building. And in the process, I've started to notice a pattern emerging in how I work most effectively with AI coding tools.

It's a two-phased approach:

1. Work synchronously until the MVP has a real definition
2. Move all work asynchronously once the core of the project is in place

MVP work requires tight feedback loops

When I'm standing up a new project from scratch, I don't just fire off a prompt and walk away. I'm still forming thoughts and ideas about what this thing actually is, and I've noticed that the MVP comes out stronger if I stay tapped in and work within tighter feedback loops with my coding agent.

For those early stages, I want quick back-and-forth messages with the agent. I want to be in the loop — peppering messages, trying things, course-correcting. That can be while the code is being written or while we're working on a detailed plan. Either way, it takes a lot of my attention if it's going to start from a strong foundation.

What "MVP" really means here

To clarify, MVP in this case doesn't necessarily mean a working tool. It could mean a plan so well thought out that an agent can take it and build the first version of the product in one shot.

What I'm really referring to is the part of the process that requires tight feedback loops. Sometimes that's planning — and only planning — and then you can hand it off. Sometimes it's planning and writing code because the plan isn't fully baked and you need to learn more as you build. And sometimes you might just have the very beginnings of an idea, but what the heck, you're going to jump right in — and in that case, you want those feedback loops while the building is happening.

I've seen that needle move from project to project. The point at which you can confidently hand things off varies based on the complexity of the idea, how well you understand the tools, and how much discovery happens during the build.

Third-party integrations still need handholding

One thing I've noticed is that third-party integrations will rarely just work. They typically require a little hand-holding — credentials, setting up environment variables, and working through quirks in the API. It's getting much better, but it's one of the reasons I usually don't hand everything over to an agent up front.

This doesn't mean the agent has to build the entire MVP. But these integration pieces often require a bit of finagling that's easier to work through synchronously, and it's worth accounting for that when you're deciding when to make the switch.

Switching to async on a strong foundation

Once I get to a place where there's enough definition — enough confidence in what this thing actually is and how it works, including roughly the visual design, basic behaviors, and integrations — that's when I switch modes. That's when I want to work asynchronously.

The synchronous work is really about being thoughtful during the MVP stage, whatever that means to you. Once that's stable, much of the remaining work — small gaps, polish, and expansion — can be offloaded. You can let agents run in parallel while you move on to the next thing that requires your deeper attention.

Drive to get past the synchronous stage

The goal is to get to the point where you can work asynchronously. Because then you can be more effective. Then you can move on to the next thing that requires focus. Then you can let agents run with multiple complementary ideas in parallel.

At this point, I strongly recommend that you stay focused while getting an MVP stood up, even if that MVP is a detailed plan. The goal is to get past that point as quickly as you can, without sacrificing the quality of your thinking, so that you can scale yourself through asynchronous work.

I'm still experimenting with this, and the needle is moving rapidly. Tools are evolving, my agent is getting better at writing plans and translating them into code, and platforms like Netlify are delivering an agent experience that makes it easier to set up infrastructure and integrations seamlessly. These things will continue to get better, fast. I suspect my opinion on the right balance will change soon.

For now, stay focused as you work through your core idea, but continue to drive toward async work so you're always putting your human mind — the thing that can't be replaced — into where it can be of most value.