The stack has changed again

I wrote about my AI stack a few weeks ago and already half of it feels outdated. Cursor shipped 2.0 with multi-agent. Claude launched Opus 4.6 with agent teams. Lovable apparently generates 100,000 products per day now. Things move fast and your stack should move with them.

This is the exact setup I'd use if I was starting a solo project today, in February 2026. Not theoretical. Not aspirational. The actual tools I'd install, the actual subscriptions I'd pay for, and the actual workflow I'd follow. With costs, because pretending money doesn't matter is something only VCs do.

The coding layer: Cursor Pro ($20/month)

Cursor 2.0 is the editor. Not Copilot, not Windsurf, not VS Code with a bunch of extensions. Cursor.

The multi-agent feature is the reason. As a solo developer, your biggest constraint isn't skill, it's time. Being able to spin up multiple agents that work on different parts of your codebase simultaneously is like having a small team that works for $20/month. I've been using it to parallelise tasks that would have taken me a full day: "agent 1, refactor the authentication. Agent 2, write the tests. Agent 3, update the API documentation."

The Composer model in 2.0 is roughly 4x faster than before. Tasks complete in under 30 seconds. The native browser testing means I can see changes without context-switching to Chrome. For a solo developer where every minute counts, these speed improvements are significant.

If you're cost-constrained, Windsurf's SWE-1.5 model is free through March and it's genuinely good. Use March to evaluate, then decide. But if you can afford $20/month, Cursor is worth it.

The thinking layer: Claude Pro ($20/month)

Claude Opus 4.6 for thinking through problems, reviewing code, and writing anything that needs to sound like a human wrote it. Not for quick questions (I'll get to that). For deep work.

The agent teams feature has changed how I approach big tasks. Instead of working through a complex problem step by step, I describe the entire thing and let Opus 4.6 decompose it into parallel sub-tasks. It's not always perfect but it's reliably faster than doing everything sequentially.

The 200K context window (1M in beta) means I can feed it my entire codebase for a medium-sized project. "Here's my whole app. Find the bug that's causing users to get logged out randomly." It found a race condition in my session refresh logic that I'd been hunting for three days. Three days compressed to ten minutes. That's the kind of value that makes $20/month feel like theft.

For writing (documentation, blog posts, marketing copy, emails), Claude produces the most natural-sounding text. Less editing, less "make this sound less like AI" rework.

The MVP layer: Lovable (free tier to start, then $25/month)

Here's where the 2026 stack diverges from traditional approaches. Instead of building everything from scratch, I use Lovable for MVPs and prototypes.

The workflow: describe the app to Lovable, get a working full-stack web app in 15 minutes, deploy it, and then migrate the code into my own repo if the idea has legs. This lets me test ideas at a rate that would be impossible if I was building every prototype from scratch.

Lovable's free tier gives you enough to test the workflow. The paid tier at $25/month is worth it once you're using it regularly. The Supabase integration means your prototypes have real databases, real authentication, and real data persistence from the start. No more throwaway prototypes that you have to rebuild entirely when you decide to proceed.

For a solo developer, the ability to go from "I wonder if this would work" to "here's a live app, let me show you" in under an hour is genuinely transformative.

The backend: Supabase (free tier, then $25/month)

Supabase for the database, authentication, storage, and edge functions. As a solo developer, managing infrastructure is a waste of your limited time. Supabase handles all of it.

The free tier is generous enough for development and early users. The Pro tier at $25/month covers most solo projects comfortably. You get Postgres (with full SQL access, not some limited abstraction), built-in auth that handles email, OAuth, and magic links, file storage, and edge functions for server-side logic.

The alternative would be setting up and managing your own Postgres instance, writing auth from scratch (or integrating a third-party auth service), and deploying to a VPS. All doable. None of it a good use of a solo developer's time.

The deployment layer: Vercel (free tier, then $20/month)

Vercel for hosting and deployment. Push to git, it deploys. That's the whole workflow.

For a Next.js project (which is what I recommend for most solo web apps), Vercel is the path of least resistance. Zero configuration, automatic preview deployments for every branch, edge functions, and analytics. The free tier handles a surprising amount of traffic before you need to upgrade.

The $20/month Pro tier adds more bandwidth, longer function execution times, and team features you probably don't need as a solo developer but might want eventually.

The research layer: Perplexity Pro ($20/month)

Perplexity for any question that requires current information. Claude can't browse the internet. ChatGPT can, but Perplexity does it better.

When I'm evaluating a library, checking if an API still works, looking up current pricing for a service, or researching competitors, Perplexity gives me sourced answers in seconds. The citations mean I can verify everything, which matters when you're making technical decisions based on the answers.

$20/month for a search engine feels expensive until you realise you're replacing hours of googling, tab-opening, ad-dismissing, and result-sifting with a single query that gives you an actual answer.

The total damage

| Tool | Monthly Cost | |---|---| | Cursor Pro | $20 | | Claude Pro | $20 | | Lovable | $25 | | Supabase | $25 | | Vercel | $20 | | Perplexity Pro | $20 | | Total | $130/month |

One hundred and thirty dollars a month. About a hundred quid. That's your entire development infrastructure, AI assistance, database, hosting, and research tool. For context, a single junior developer costs twenty to thirty times that per month.

What's changed since last month

The previous stack article recommended Cursor, ChatGPT, and a more manual approach. Here's what shifted:

Cursor 1.x to 2.0: The multi-agent feature is the big change. It's not an incremental improvement. It fundamentally changes what a solo developer can accomplish in a day.

ChatGPT to Claude: Opus 4.6's agent teams and the 1M context beta tipped the balance. For deep coding and thinking work, Claude is now the clear choice. I still use ChatGPT occasionally for quick questions and internet-dependent queries, but it's no longer the primary tool.

Added Lovable: This is the new addition. Using Lovable for MVPs before building anything from scratch has saved me weeks of development time. It sounds lazy. It's actually strategic.

The workflow in practice

Monday morning. New feature idea. Open Lovable, describe it, get a working prototype in 15 minutes. Show it to a potential user. They like it. Open Cursor, import the generated code, start building the real version with multi-agent. Use Claude for architecture decisions and code review. Deploy to Vercel. Database on Supabase. Research any unknowns with Perplexity.

That's a solo developer moving at the speed of a small team. Not because the tools are doing the thinking for you, but because they're handling the tedium so you can focus on the decisions that actually matter.

The stack will change again. Something better will ship. That's fine. The point isn't to find the perfect permanent setup. It's to use the best tools available right now, and right now, this is it.