Your AI Agent Picked the Wrong Stack — Here’s How to Audit It
Claude Code, Cursor, Copilot, Codex CLI, Windsurf, Aider — they can scaffold an entire project in minutes. But they have hidden biases. They default to what’s most common in their training data, not what’s best for your specific situation. This guide helps you question every choice.
1. Your Agent Has Opinions (And They Might Be Wrong)
AI coding agents are incredible productivity multipliers. Ask one to "build me a blog" and you’ll get a fully functional Next.js app with Prisma, PostgreSQL, Tailwind, and Vercel deployment — in under five minutes.
But here’s the problem: a blog doesn’t need any of that. Astro with a folder of markdown files would be 10x simpler, 10x faster, and cost $0 to host on Cloudflare Pages.
The agent didn’t pick Next.js because it analyzed your requirements. It picked Next.js because that combination appears thousands of times in its training data. It’s pattern-matching, not architecture.
The core problem
AI agents optimize for "works" not "right." A working app with the wrong stack is technical debt from day one. You need to audit what your agent chose — every time.
This post gives you a concrete framework: the 10 most common AI defaults, a 5-minute audit checklist, red flags to watch for, and links to our head-to-head comparisons so you can verify each choice.
2. The 10 Most Common AI Agent Defaults (And When They’re Wrong)
For each default, we show what agents typically pick, when it’s justified, when it’s not, and what to use instead.
Frontend: React / Next.js
Right when
SaaS apps, dashboards, highly dynamic UIs with complex state, teams already invested in the React ecosystem.
Wrong when
Content sites, blogs, marketing pages (use Astro). Simple interactive apps (use Svelte or Vue). Static sites that don’t need hydration.
Our comparison: Next.js vs Remix vs Astro · React vs Vue vs Svelte
Styling: Tailwind CSS
Right when
Almost always in 2026. Rapid prototyping, utility-first workflows, AI-generated UIs (agents love Tailwind because it’s inline and predictable).
Wrong when
Design systems with strict tokens and compile-time type safety. In that case consider Vanilla Extract or CSS Modules with a shared token file.
Our comparison: Tailwind vs CSS Modules vs Vanilla Extract
State Management: useState / useContext Everywhere
Right when
Simple apps with 2–3 pieces of state. Local component state. Prototypes where you’ll refactor later.
Wrong when
Complex state shared across many components. Frequent re-renders from context. Use Zustand (simple, tiny) or Jotai (atomic).
Our comparison: Zustand vs Redux vs Jotai
Database: PostgreSQL via Prisma
Right when
Relational data with complex queries. Production apps that need ACID. Teams that want managed Postgres (Supabase, Neon, RDS).
Wrong when
Simple key-value data (use Redis/KV). Document data (use MongoDB). Edge deployment (use SQLite/Turso). The agent rarely considers if you even need a database.
Our guide: Backend Stacks Visual Guide · Supabase vs Firebase
ORM: Prisma
Right when
Teams that want auto-generated types and migrations. Developer experience is the priority. You’re deploying to traditional Node.js servers.
Wrong when
Performance-critical queries (Prisma adds overhead). Edge runtimes (Prisma client is large). Use Drizzle ORM — it’s lighter, SQL-like, and edge-compatible.
Agent bias: Prisma dominates training data. Drizzle is the 2026 choice for new projects, but agents haven’t caught up.
Auth: NextAuth (Auth.js)
Right when
Simple social login in Next.js apps. You want free, self-hosted auth. Low user counts where you don’t need a management UI.
Wrong when
You need a user management dashboard (use Clerk). Enterprise SSO/SAML (use Auth0). Free at scale (use Supabase Auth).
Our comparison: Clerk vs Auth0 vs Supabase Auth
Hosting: Vercel
Right when
Next.js apps. Teams that value preview deployments and great DX. Projects where cost isn’t the primary concern.
Wrong when
High traffic on a budget (Cloudflare is 10x cheaper at scale). Static sites (Cloudflare Pages is free with unlimited bandwidth). Docker-based apps.
Our comparison: Vercel vs Cloudflare vs Netlify
Backend: Express.js
Right when
Simple REST APIs. Learning projects. You need the widest ecosystem of middleware. Legacy codebases already on Express.
Wrong when
New 2026 projects should use Hono (lighter, edge-native), Fastify (faster), or just Next.js API routes. Express is showing its age.
Agent bias: Express has the most training data of any Node.js framework. Agents pick it reflexively, not strategically.
Our guide: Backend Stacks Visual Guide
Testing: Jest
Right when
Legacy projects already using Jest. CJS-heavy codebases. You need a very mature ecosystem of matchers and plugins.
Wrong when
New projects. Vitest is faster, has native ESM support, is Vite-compatible, and is the 2026 standard. There is almost no reason to start a new project with Jest.
Agent bias: Jest appears in orders of magnitude more training data than Vitest. This is a pure recency gap — the agent is behind the industry.
Package Manager: npm
Right when
Default Node.js tooling. Widest compatibility. Single-package repos where speed isn’t critical.
Wrong when
Monorepos (use pnpm). Speed priority (use pnpm or bun). Disk space matters (pnpm’s content-addressable store saves gigabytes).
Agent bias: Nearly every agent defaults to npm install because it’s the most common command in training data. Always check if pnpm or bun would be better for your project.
3. The 5-Minute Stack Audit Checklist
Run through this after every AI-generated project. It takes five minutes and can save you weeks of refactoring.
4. Red Flags in AI-Generated Architecture
These anti-patterns show up constantly in AI-scaffolded projects. If you spot one, pause and rethink.
The Kitchen Sink
The agent installs 30+ dependencies for a simple app. If node_modules is bigger than your actual code, something is wrong. Every dependency is a security surface, a version conflict waiting to happen, and weight your users download.
The Premature Monolith
Building microservices for a prototype. Kubernetes for a side project. Event-driven architecture for an app with 10 users. Agents love to build "scalable" systems because that’s what appears in tutorials. Start with a monolith. Split when you have actual scale problems.
The Auth Overkill
Implementing OAuth, MFA, and role-based access control for an app that only you will use. Ask: who are the actual users? If it’s just you, a simple API key or even no auth at all is fine for now.
The Framework Mismatch
Next.js for a static marketing site. React for a blog. Angular for a prototype. The framework should match the use case, not the agent’s muscle memory.
The Stale Stack
Create React App (deprecated). Moment.js (use date-fns or native Intl). The request library (use fetch). Express when Hono or Fastify exist. These are signals your agent is generating 2021 code in 2026.
The Missing Error Handling
The agent builds the happy path beautifully — but there are no error boundaries, no 404 pages, no API error handling, no loading states, no retry logic. Production apps fail. Your code needs to handle that gracefully.
5. How to Tell Your Agent What You Actually Need
The quality of your stack depends on the quality of your prompt. Be specific about constraints. Here are the dimensions that matter:
Specify your scale
Instead of: "Build me a web app"
Try: "This will have ~100 users" or "This needs to handle 1M requests/day"
Specify your budget
Instead of: "Deploy it somewhere"
Try: "Use only free tiers" or "Budget is $200/month for infrastructure"
Specify constraints
Instead of: "Choose a good database"
Try: "Must deploy to Cloudflare Workers" or "Must use existing PostgreSQL instance" or "No external services — everything self-hosted"
Specify simplicity
Instead of: "Build it properly"
Try: "Use the simplest possible stack" or "Minimize dependencies — I want fewer than 10 packages" or "No ORM, raw SQL is fine"
Reference our guides
Instead of: "Use best practices"
Try: "Choose technologies appropriate for an MVP-stage project" or "Pick frameworks that work at the edge" or "Use the stack from Open TechStack’s Stack Combos"
6. Use Our Tools to Verify
Open TechStack has 280+ technologies across 8 guides, 11 comparisons, and a Stack Picker. Use them to cross-check every AI-generated choice.
Stack Picker
Answer 5 questions, get a recommended stack. Compare the result against what your agent built. If they disagree, investigate why.
Head-to-Head Comparisons
For every technology X your agent chose, check our X vs Y page. See trade-offs the agent didn’t mention: performance, cost, ecosystem, edge support.
Visual Guides
Deep-dive into Frontend, Backend, AI/ML, DevOps, and Mobile stacks with interactive filtering.
Stack Combos
Battle-tested full-stack recipes. See how technologies actually work together, instead of trusting an agent’s ad-hoc assembly.