Video summary

Best tech stack for web dev (with AI) in 2026?

Main summary

Key takeaways

Technology

Summary: Best Web Dev Tech Stack (with AI) for 2026 — Key Takeaways

The speaker argues that AI changes how you write code, but does not remove the need to choose a good web tech stack. Even with AI-assisted “vibe coding,” stack choice still matters because you’re responsible for trade-offs like cost, scalability, security, maintainability, and developer understanding of the resulting code.

Core Thesis: Tech Stack Choices Still Matter (Even with AI)

AI reduces effort in:

  • generating boilerplate/wiring
  • exploring unfamiliar tech and UI code (e.g., SVG)
  • speeding up implementation

But stack decisions still affect:

  • cost + scaling (some options become expensive quickly)
  • maintenance + security (dependency health, frequent patching)
  • understandability + governance (you must review and steer AI output)
  • deployment constraints (hosting affects which runtimes/databases fit)
  • ecosystem + documentation (AI can read docs/blogs, but weaker ecosystems may require more steering)

What Changes Due to AI (vs. Pre-AI)

1) Syntax/Ergonomics Matter Less

  • “How much I like the syntax” matters less when AI writes most code.
  • Code quality/readability still matters—they don’t want generated code to “look like garbage.”
  • For real products, you still need to understand AI-generated code.

2) Ecosystem/Library Abundance Matters Less for Frameworks/Libraries

  • The advantage of “tons of libraries for everything” is weaker because AI makes it feasible to implement missing pieces yourself.
  • Supply-chain concerns push them toward fewer dependencies.

3) Maintenance + Dependency Trust Becomes More Important

  • Frequent updates help security/performance, but supply-chain attacks make blind dependency usage risky.
  • They warn about aggressively updated libraries that may be “vibe-coded AI slop.”
  • Trust matters: major framework teams (e.g., React/Vue/Angular) are treated as more reliable.

Framework Selection: Principles, Not Framework Wars

The speaker avoids deep React vs Angular vs Vue comparisons and focuses on what matters when choosing frameworks.

Front-End Frameworks

  • React / Angular / Vue: browser-based UI frameworks for interactive apps.

Meta/Full-Stack Frameworks (Server + Interactive Client)

They explain that meta frameworks help build full-stack apps where:

  • the server stores user data in a central DB
  • the client provides interactive UI

Examples mentioned:

  • Next.js (called AI’s “favorite”)
  • TanStack Start
  • Remix (noted as changing direction; earlier React-based)
  • “React Router” confusion acknowledged (two modes: “framework mode” vs “data mode”)

Key guidance:

  • AI may prefer React/Next.js, but you can still use AI with other stacks if you provide correct documentation and steer it.
  • Comfort and understanding should guide your choice.

Runtime and Backend Options (JavaScript Ecosystem Focus)

The talk primarily focuses on TypeScript/JavaScript, while also covering server runtimes.

Runtimes

  • Node.js
  • Bun (personal favorite for speed and built-in features)
  • Deno

Bun vs Node (Reasoning)

  • Bun: fast; includes conveniences (including a built-in SQLite client), reducing extra dependencies.
  • Node: also includes features people allegedly don’t know about (including TypeScript support and SQLite via imports like “node-sqlite”).
  • No absolute “winner”—it’s framed as trade-offs.

Backend Frameworks (and Whether You Need One)

Server frameworks mentioned:

  • Express
  • Hono (praised)
  • Elysia
  • Fastify

Main point: modern runtimes often include enough HTTP/routing primitives that you might build without a large framework.

AI + Unfamiliar Frameworks/Libraries: How to Make It Work

To help AI handle lesser-known tools, they recommend:

  • point the agent to official documentation
  • provide entry pages/links
  • ask it to extract specific concepts, then implement accordingly
  • review the generated code
  • when mistakes happen, update/fix “skills” or prompts and re-run

Example: TanStack Start + “Skills”

The approach:

  • read TanStack Start docs
  • gather critical concepts (e.g., server functions)
  • produce a reusable “skill”
  • copy it across projects and update it over time
  • the developer still reviews/steers output to remove defensive helper bloat and get cleaner code

Authentication: DIY vs Managed Services

Practical security trade-off:

  • Email/password: doable, but still needs care
  • OAuth/OpenID Connect/Multiple providers: usually safer using a library or managed provider

Authentication Approaches Mentioned

  • “better auth” (go-to library)
    • supports email/password, OAuth providers, 2FA/passkeys, orgs/teams, API keys, admin features
    • supports enterprise protocols like OpenID Connect/SCIM
  • Managed options:
    • Clerk (and “WorkOS” mentioned)

Trade-offs emphasized:

  • managed services reduce security responsibility for you, but you pay and may give up some control over user data.

Databases and Hosting: Constraints Drive Stack Decisions

Hosting Constraint Examples

  • Using Vercel can make certain DB options like SQLite not work in the expected way.
  • You may need managed DB services:
    • PlanetScale (hosted Postgres)
    • AWS RDS/Aurora equivalents
    • Convex

SQLite Recommendation (with Trade-Offs)

They strongly like SQLite for many cases:

  • simple: “database is just a file”
  • easy backup: copy the file
  • no extra service to manage
  • good early-stage scaling (depends on workload/usage)
  • later migration is possible if you outgrow it

Alternative mentioned:

  • Turso: Rust-based “modern version of SQLite” / extended implementation

Key guidance:

  • managed services add convenience/scaling paths, but cost, dependency, and vendor risk increase
  • self-hosting provides control but increases responsibility

Deployment Options: Vercel/Netlify vs Cloudflare vs VPS

Vercel/Netlify

  • easy deployments
  • less configurable (trade-off)
  • may restrict database/runtime choices

Cloudflare

  • they like Cloudflare’s ecosystem and pricing model
  • Workers model: code runs per request and shuts down (good for cheap compute)
  • D1 referenced as a managed database option
  • downside: “build for Cloudflare,” runtime limitations (e.g., can’t use Bun; Cloudflare runtime differs)

VPS (EC2/Hetzner)

  • maximum control: install anything; run your DB locally (SQLite/Postgres in Docker)
  • downside: you manage security/configuration/Docker, etc.
  • tooling mentioned to reduce VPS complexity: Coolify / Dokploy

AI Coding Agents: Which Ones to Try

There isn’t a single “best” agent—tools evolve too quickly—so they recommend:

  • try multiple
  • learn features/settings
  • keep your workflow flexible and review generated output

Agents Mentioned

  • Pi (favorite: minimal core + extensibility; add extensions/skills)
  • Codex
  • Claude Code
  • “Claude/Models switching,” plus access via providers
    • OpenRouter
    • Vercel AI Gateway
    • Cloudflare AI Gateway
  • local OSS models aren’t yet strong enough for their coding use case (but can help with summarization)

Local Sandboxing / Approval (Emerging Topic)

They mention sandboxing as actively evolving, including examples like:

  • AWS Lambda micro VMs
  • Vercel-like sandbox tools

UI / Styling Recommendations

  • Prefer modern CSS first (browser capabilities have improved).
  • Tailwind is still useful for speed/iteration:
    • faster tweaks via class changes in markup
    • fewer steps searching through a CSS file

AI can also assist with CSS (kickstart via pseudo code/style systems).

Content Management: Static/Marketing vs Dynamic/User Content

They split content into two types:

  1. User-generated content

    • dynamic, stored in a DB
    • core product functionality

  2. Owner/marketing content

    • often static
    • can be markdown converted to HTML at build time

Astro for Marketing/Static Content

  • recommended especially for content-heavy sites
  • supports fast markdown-to-HTML processing
  • benefit: render at build time to reduce DB load

They also describe multi-framework architecture patterns:

  • main app on Next.js + Postgres
  • marketing site on Astro (domain.com)
  • login redirects between subdomains

CMS options mentioned:

  • headless CMS like Storyblok
  • WordPress as a full CMS with a built-in frontend

Course/Product Promotions Embedded in the Talk

The speaker references teaching courses and planning new ones, including:

  • upcoming/available courses on Pi and Bun
  • VPS Essentials (already mentioned)
  • systems design course planned
  • Docker course mentioned (recommended)
  • Cloudflare course mentioned as planned

Additional notes:

  • Udemy publishing continues (Udemy acquired by Coursera; deal finalized; unclear future for some course aspects)
  • some courses exclusive to Academind Pro

Key “How to Decide” Checklist (Implied)

  • Choose the stack based on trade-offs and constraints (cost, maintenance, hosting/runtime compatibility).
  • Prefer designs that support code review and understanding.
  • Use AI as a helper, but validate/review and correct “AI helper bloat.”
  • Reduce dependency risk by limiting libraries where feasible.
  • Plan deployment early—it influences DB/runtime possibilities.
  • For marketing content, prefer static generation (e.g., Astro/markdown patterns).

Main Speaker / Sources

  • Main speaker: Max (Academind / Academind Pro / Academind YouTube streams)
  • External products/tools referenced (not interviewed): React, Vue, Angular, Next.js, TanStack Start, Bun, Node.js, Deno, Express, Hono, Fastify, Vercel, Netlify, Cloudflare (Workers/D1/R2), AWS, Hetzner, Coolify/Dokploy, SQLite/Turso, PlanetScale, Convex, better auth, Clerk, WorkOS, Supabase, Astro, Tailwind, Storyblok, WordPress, Pi, Codex, Claude Code, OpenRouter, Vercel AI Gateway, Cloudflare AI Gateway, Polar (payments), Stripe.

Original video