My AI Stack

I wrote this as a short but comprehensive overview of how I run my current software development stack. It's mainly to share with people who ask what I'm using, but I hope it's helpful to others as well.

Before we start: as always, this is my personal take, and it won't suit everyone or every kind of project. It's mainly for people similar to me and the projects I work on, so here's where I stand:

• My main focus is delivering value to people through software products.
• I believe building software products should be uncompromisingly about speed and quality combined.
• I'm a minimalist. I put a lot of work into cutting things out of my stack, even when they were serving a purpose.
• I'm incredibly lazy, so I want to automate away as much of my job as possible.
• I resist process, bureaucracy, governance and rules. That's not to say I don't have any, but only when the situation truly requires it.
• I try to stay open-minded. I believe I'm probably wrong about half of everything I know right now, and I'll probably be wrong about the other half within the next year.
• I don't hold onto things out of ego or the sunk cost fallacy. Code is just code, and it should be thrown out once it has served its purpose.
• AI is a massive change, and what's holding most people back is their imagination, along with the brick walls in their heads telling them they can't change things they've done for a long time. Creativity and imagination are what differentiate engineers in the workplace right now.

These are just my biases; they're neither right nor wrong. If you're nodding along to all of these, my approach could be a good fit. If you think I'm a crazy person, you'll probably want to make some changes to it.

What AI likes

• The ability to test whatever is important:
  • builds
  • type checks
  • browser testing
• Speed. The faster it can run, build and test, the faster it can fix things.
• Tools that reduce the problem space, e.g. Convex (see below). This is really key.
  • "The best thing to do with a problem is not to solve it, but to dissolve it." The less Claude has to think about while building, the more effort it can put into the smaller scope it does have to build.

The stack

LLM: Claude Opus 5.5

Opus 5.5 seems to be Fable-level quality for a fraction of the cost. I've gone back down to two Max subscriptions, and I'm now able to fit my product work in one and my side projects in the other.

ChatGPT is more like the neckbeard engineer: it goes super deep to make sure it doesn't miss a single detail in the code, asks lots of questions and second-guesses itself all the time. I don't have time for that.

Claude models match my style. They don't ask for too much input; they just have a crack, do a pretty good job and cover all the important stuff.

Frontend: TanStack Start

I stick with React since it's tried and tested.

The problem with Next.js is that the dev server isn't robust. When agents start hammering the code and HMR keeps updating, the dev server starts chewing up memory and crashing your computer. Builds are also super slow and take lots of memory. Next.js was great before AI started 10x-ing the amount of code being written per minute.

TanStack Start has several advantages:

• The dev server is super quick and has a low memory footprint, which is great for AI testing its work locally.
• The typing is more comprehensive than in Next.js, which is great for making sure nothing has been missed.
• Unlike Next.js, it can build into a purely frontend SPA, lowering your Vercel costs dramatically.

Backend: Convex

This is an unusual choice for me. I normally go for something tried and tested that's been used by millions of people for decades, like PostgreSQL. However, the benefits of Convex outweigh the cost of not having something super battle-hardened.

I started using Convex at the beginning of 2025 and have never looked back. It's optimal for AI agents writing backend code. And yes, occasionally there's a rough edge, but nothing that can't be fixed easily.

Here are the benefits of Convex:

• No schema migrations. The schema is defined and then synced automatically.
• Types flow automatically (without duplication) from schema → backend functions → frontend functions, guaranteeing you get a type error if anything doesn't line up.
• Agents LOVE writing Convex because of the guarantees you get from the mutation/query/action structure.
• Convex replaces about 8 tools your agents no longer have to install, learn, coordinate and maintain:
  • no schema migrations
  • no separate query language, i.e. SQL
  • no routing layer
  • no parsing/type checking of arguments
  • no frontend tool for fetching
  • no caching tool (it happens automatically)
  • no Docker containers to run inside
  • and probably a few more I can't even remember anymore
• Convex removes problems your agents no longer have to worry about:
  • the primary one being no manual transactions! Every mutation runs as a transaction automatically, so there are generally no race conditions when writing to the DB.

Obviously, you don't experience these benefits; your agents do. And you won't notice them on a small application, only on larger ones. While other projects are debugging gnarly race conditions in Postgres, my agents are focused purely on business logic and rarely get into the weeds of technical issues.

Auth: Clerk

'Nuff said.

Deployment

• GitHub Actions for building, testing and deploying
• Vercel for the frontend
• Convex for the backend
• Resend for emails

Monitoring

• Axiom for logs
• Sentry for traces
• Fullstory for videos of user journeys

Task tracker

I've tried Beads and a few others, but I preferred to build my own so I have full control over it. I think having a separate task tracker is actually better than keeping tasks in Git, because it works across machines and doesn't have to be synced with commits.

Other than building your own, I'd probably recommend something like Notion or Trello (via their CLIs): something unstructured that the agents can mould, and that lets them search the way they want to.

Linear honestly seems too narrow. I asked my agents, and they didn't want to go with Linear.

GitHub Issues would probably be good, but I didn't look into it.

Tips for Claude

• "Save in CLAUDE.md that we should have a memory/ folder and always look for relevant info in there. Whenever you come across something that would be useful for a future agent, save it in the memory/ folder."
• "Save in CLAUDE.md that before shipping a feature, we should always test it in a browser, using playwright-cli to drive the browser."
• "Use the task tracker to record the issues you're working on and mark their status (Todo, WIP, Merged, Verified). When you plan, put the plan into the task. Prefer creating one mega-task over many small tasks, and prefer putting everything in one branch/PR rather than splitting it up."
• "Save in CLAUDE.md that it's OK to delete and rework existing code when we learn something new. No sunk cost fallacy: a big problem usually deserves a big rework."

Putting it all together

Now that the stack is chosen, simply ask Claude to set it all up for you. Then ask Claude to build a feature. If you've done it right, your next prompt should be "ship it!"

Automating everything

The next level of abstraction is having your own box that automates everything for you. Here's how to set one up and what it can do for you.

Setting up

• Don't bother with a Mac mini; just grab your old laptop.
• Wipe it and install a fresh OS.
• Sign up for a new Gmail account (or equivalent). Don't put any of your personal accounts on it if you can avoid it.
• Use that Gmail account to create a new GitHub account and any other accounts you need.
• Install Claude.
• Get Claude to set up the rest.
• Use Discord as the place where tasks, issues and alerts come in. The box picks them up, works on them and updates Discord when it's finished.

What it can do for you

• Send all exceptions from prod to it, and have Claude fix them and push to prod.
• Run weekly cron jobs that review Axiom, Sentry and Fullstory and fix everything that's identified as needing fixing.
• Run cron jobs that refactor the code on a regular basis.
• Run cron jobs that look at all your production tools and work out how to cost-optimise them.
• Let your product managers email the box to build features (see my other post for the guardrails to put around this).