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

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:

User-generated content
- dynamic, stored in a DB
- core product functionality
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.

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

Key takeaways