There's a version of this article where we list twenty tools and call it a day. That's not useful. The honest answer is that two or three tools do ninety percent of the work, and the rest is taste. Here's what's actually open on our developers' machines right now.
We ship websites and web apps for a living. We've shipped them with AI assistance and we've shipped them without. The work is faster now. The bar is also higher, because everyone has the same tools and the differentiator has moved from speed to judgment.
Here's the actual stack, in the order we'd reintroduce it if everything got wiped tomorrow.
The IDE layer.
Cursor.
We replaced VS Code with Cursor across the team about eighteen months ago and never looked back. The inline edit (cmd-K) and the agent mode are the two features we use constantly. The autocomplete is good enough that we've started writing comments before the function as a way to prompt — not as documentation, as direction.
Claude Code.
For larger refactors, codebase-wide changes, or anything that requires reading more than a few files, we drive Claude Code from the terminal. It plans, executes, and asks before doing anything destructive. We use it for migrations, dependency upgrades, and the kind of grunt-work that used to eat a Friday afternoon.
GitHub Copilot.
Still installed. Still useful for tab-completion of the obvious. Lower priority than it was two years ago because the inline tools above are smarter, but the muscle memory is real and the price is fine.
The middleware nobody talks about.
Where AI-assisted development gets dangerous is when the code looks right but isn't. Three tools in our pipeline are non-negotiable specifically because they catch what the model can't.
- Strict TypeScript and a real ESLint config. Models will happily generate code that compiles in JavaScript and falls over in production. The compiler is your friend. Configure it like one.
- Playwright or Vitest with real coverage gates. AI is incredible at writing tests for code that already works. Make sure the tests run in CI and that coverage doesn't quietly slip when somebody accepts a generation.
- Sentry plus a logging layer that captures intent. When something breaks at 2am, you need to know what the user was trying to do, not just what threw. AI helps you triage faster — but only if you have the data.
The tools we use for specific moments.
v0 for the first sketch.
When a designer hands us a hard component — a complex table, an interactive scheduler, a file uploader with progress — we'll often ask v0 for a starting point. The output is rarely shippable. It is almost always educational about the right structural approach.
Supabase and Vercel CLIs with AI-aware schemas.
Both platforms have invested heavily in tooling that lets an AI agent reason about your project. The Supabase MCP server is a real productivity unlock for anyone whose database schema lives in Postgres. Use it.
Codeium / Tabnine in regulated environments.
When client policies don't allow code to leave their network, we deploy on-prem completion tools. Slower, less capable, still better than nothing. Worth knowing they exist if you work in finance, healthcare, or government.
The patterns that have changed how we work.
The biggest shift isn't a tool — it's how we structure the codebase to be legible to an AI agent. A few principles we've internalized:
- Smaller files, clearer names. A 2000-line component is hard for the model and hard for the human. Both benefit from boundaries.
- README.md and AGENTS.md in every meaningful directory. When the agent enters a folder, it should be able to orient itself in thirty seconds. So should a new hire.
- Tests as specification. A green test suite is the strongest signal you can give a coding agent that its change is safe. Invest in test infrastructure first.
- Commit early, commit often. AI agents make mistakes. So do humans. Atomic commits make both recoverable.
The takeaway.
Tools matter less than the system around them. We've watched teams with the entire AI stack ship slower than ours, because their codebase fights every tool they install. The work is to make the codebase a place where good agents — human and otherwise — can do good work.
AI didn't make us faster. AI made the gap between disciplined teams and undisciplined ones much, much wider.