StackPractices
intermediate Por Mathias Paulenko

Guía Completa de Diseño Responsive para Móviles

Construye layouts que funcionan en cualquier pantalla: breakpoints mobile-first, Grid, Flexbox, container queries, tipografía fluida e imágenes responsive.

Introducción

Un layout que se ve perfecto en tu monitor de 1440px puede romperse apenas alguien lo abre en un teléfono de 375px: las columnas colapsan en tiras ilegibles, las tablas empujan toda la página hacia el costado y los tamaños de fuente pensados para desktop obligan a hacer zoom con los dedos. El diseño responsive es la disciplina de hacer que una sola base de código funcione en todo ese rango, y el CSS moderno por fin permite resolver casi todo sin una sola línea de JavaScript.

Esta guía trata sobre la estrategia: cómo elegir breakpoints, cuándo usar Grid vs. Flexbox vs. container queries, cómo escalar la tipografía de forma fluida y cómo manejar las piezas que suelen romperse primero — imágenes, tablas y la altura del viewport. Si buscas la mecánica profunda de Grid y Flexbox, la Guía Completa de CSS Grid y Flexbox los cubre propiedad por propiedad; aquí nos enfocamos en usarlos para construir layouts que sobrevivan a cualquier pantalla.

Estrategia Mobile-First

Mobile-first significa que tus estilos base apuntan a la pantalla más pequeña y mejoras hacia arriba con media queries min-width. La alternativa — estilizar para desktop y luego sobreescribir hacia abajo con max-width — produce más CSS, overrides más difíciles de razonar y layouts que se rompen en los breakpoints que olvidaste probar.

/* Estilos base — mobile first */
.card {
  padding: 1rem;
  font-size: 0.875rem;
}

/* Tablet y superior */
@media (min-width: 768px) {
  .card {
    padding: 1.5rem;
    font-size: 1rem;
  }
}

/* Desktop y superior */
@media (min-width: 1024px) {
  .card {
    padding: 2rem;
    font-size: 1.125rem;
  }
}

Fíjate que la versión móvil necesita menos código: contenido apilado, elementos a ancho completo y un tamaño base legible. Las pantallas más grandes solo agregan lo que necesitan. Ese es el argumento económico de mobile-first: la pantalla pequeña recibe el CSS más simple y la complejidad crece solo donde hay espacio para ella.

Cómo elegir breakpoints

No necesitas un breakpoint por cada dispositivo del mercado — agregalo cuando el layout realmente deja de funcionar: líneas demasiado largas para leer, un grid que aprieta sus celdas, espacio en blanco que se convierte en un cañón. Un conjunto pragmático que cubre la mayoría de los proyectos:

BreakpointDispositivo típicoQué suele cambiar
base (0–639px)TeléfonosUna columna, nav apilada, tamaño base
640pxTeléfonos grandes, tablets chicasGrids de dos columnas, espaciado más denso
768pxTabletsAparece el sidebar, la nav pasa a horizontal
1024pxLaptopsLayout multi-columna completo, ancho máximo de contenido
1280px+DesktopsOpcional: gutters más anchos, topes de tipografía mayores

Estos números siguen la convención de Tailwind (sm 640, md 768, lg 1024, xl 1280), que vale la pena adoptar incluso sin Tailwind porque le da a todo el equipo un vocabulario compartido. Lo que importa es la consistencia: cinco breakpoints que de verdad mantienes valen más que doce que solo existen en una hoja de estilos que nadie abre.

Dos breakpoints que la gente olvida: los teléfonos en landscape (~568–812px de alto), donde un hero de 100vh se come toda la pantalla, y los monitores muy anchos (>1600px), donde un max-width sin tope convierte los párrafos en líneas de 200 caracteres.

Cómo Elegir la Herramienta de Layout Correcta

El error responsive más común es usar una media query cuando CSS puede resolver el problema de forma intrínseca. La decisión se reduce a qué debería reaccionar:

flowchart diagram: ¿Qué debería reaccionar al tamaño?
SituaciónHerramientaPor qué
Header, sidebar, grid general de la páginaMedia queriesEl layout de página depende del viewport, no de un contenedor
Card usada en el sidebar Y en la columna principalContainer queriesMismo componente, distinto ancho disponible
Grid de cards o productosrepeat(auto-fit, minmax())No hace falta breakpoint: llena el espacio que exista
Tamaño de fuente, padding, espaciado de seccionesclamp()Escalado suave, sin saltos de breakpoint
Mostrar u ocultar secciones enterasMedia queriesCambio estructural ligado al tamaño de pantalla

Si no estás seguro de si conviene Grid o Flexbox para un layout dado, la guía de CSS Modern Layout los compara patrón por patrón. Para el resto de esta guía, lo que importa es el ángulo responsive de cada uno.

CSS Grid para Layouts Responsive

Grid brilla para estructura de página en dos dimensiones. Para trabajo responsive en realidad necesitas dos patrones — el resto es mecánica que cubre la guía dedicada.

El grid auto-fit

Este es el patrón responsive que más uso. Crea tantas columnas como quepan y deja que las cards se estiren para llenar la fila — cero media queries:

.auto-grid {
  display: grid;
  gap: 1rem;
  grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
}

Ajusta minmax() al ancho mínimo en que tu card sigue siendo legible. 280px funciona para cards de texto; las cards con mucha imagen suelen necesitar 320px. Si una card nunca debería quedar sola en una fila, cambia auto-fit por auto-fill: mantiene los tracks vacíos, así los items conservan su tamaño en vez de estirarse de forma incómoda.

El grid clásico con breakpoints

Cuando quieres control explícito — exactamente 2 columnas en tablets, 3 en desktop:

.grid {
  display: grid;
  gap: 1rem;
  grid-template-columns: 1fr;
}

@media (min-width: 640px) {
  .grid {
    grid-template-columns: repeat(2, 1fr);
  }
}

@media (min-width: 1024px) {
  .grid {
    grid-template-columns: repeat(3, 1fr);
  }
}

Usa esto cuando la cantidad de columnas es una decisión de diseño, no una función del espacio disponible. Las páginas de marketing y los dashboards suelen querer conteos explícitos; las galerías de cards y los listados suelen querer auto-fit.

Reordenar regiones con grid areas

grid-template-areas permite reordenar regiones enteras de la página en un breakpoint sin tocar el HTML — pon main antes que nav en móvil para que el contenido vaya primero:

.layout {
  display: grid;
  grid-template-areas:
    "header header header"
    "nav    main   aside"
    "footer footer footer";
  grid-template-columns: 200px 1fr 250px;
  min-height: 100vh;
}

@media (max-width: 768px) {
  .layout {
    grid-template-areas:
      "header"
      "main"
      "nav"
      "aside"
      "footer";
    grid-template-columns: 1fr;
  }
}

Este ejemplo usa max-width a propósito: apilar todo por debajo de 768px es más simple como una única excepción que como tres bloques min-width. Mobile-first es una guía, no una religión — la regla es elegir la dirección que necesita menos declaraciones.

Patrones de Flexbox

Flexbox maneja layouts unidimensionales: filas y columnas de cosas. Tres patrones cubren la mayoría de las necesidades responsive.

.center {
  display: flex;
  align-items: center;
  justify-content: center;
  min-height: 100vh;
}
body {
  display: flex;
  flex-direction: column;
  min-height: 100vh;
}

main {
  flex: 1;
}

El patrón sticky footer mantiene el footer abajo en páginas cortas sin empujarlo fuera de la pantalla en las largas: flex: 1 en main absorbe el espacio sobrante.

.nav {
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: 1rem;
  padding: 0 1.5rem;
}

.nav-links {
  display: flex;
  gap: 1.5rem;
}

@media (max-width: 768px) {
  .nav-links {
    display: none;
  }
}

Dos advertencias. Primero, display: none también saca los enlaces del alcance del teclado y de los lectores de pantalla: acompáñalo de un botón de menú visible que los revele, o acabas de hacer tu sitio innavegable en teléfonos. Segundo, prefiere el elemento <details> o un botón disclosure en lugar del hack del checkbox de CSS puro; el hack funciona, pero rompe la gestión del foco y no aporta semántica de accesibilidad.

La trampa del overflow: min-width: 0

Los hijos de un flex se niegan a encoger por debajo del tamaño de su contenido por defecto. Una card con una URL larga o un bloque <pre> va a romper el layout en pantallas angostas sin importar cuántos breakpoints escribas. La solución es una línea:

.card {
  display: flex;
  flex-direction: column;
  gap: 0.75rem;
}

.card-content {
  flex: 1;
  min-width: 0; /* permite al hijo encoger por debajo de su contenido */
}

Si un layout responsive desborda “al azar” en teléfonos y no encuentras el culpable de ancho fijo, casi siempre es esto.

Container Queries

Las media queries responden “¿qué ancho tiene el viewport?” Las container queries responden “¿cuánto espacio tiene este componente?” Esa diferencia importa apenas un componente vive en más de un contexto: una card que es full-width en móvil, half-width en un sidebar y third-width en un grid.

/* Definir un contexto de contención */
.card-container {
  container-type: inline-size;
  container-name: card;
}

/* Consultar el tamaño del contenedor */
@container card (min-width: 400px) {
  .card {
    display: grid;
    grid-template-columns: 120px 1fr;
    gap: 1.5rem;
  }
}

Dale al contenedor de la card 400px o más y pasa a layout horizontal, haga lo que haga el viewport. Pon la misma card en un sidebar angosto y vuelve a apilada por sí sola. Esto es lo que hace a las container queries la herramienta correcta para design systems: el componente lleva su propio comportamiento responsive en vez de depender de breakpoints de página que no saben dónde va a terminar ubicado.

Unidades de container query

Junto a @container tienes unidades relativas al contenedor, no al viewport: cqw (1% del ancho del contenedor) y cqi (1% del inline size). Permiten internos de componente realmente fluidos:

.sidebar {
  /* escala con el ancho del propio sidebar, no de la pantalla */
  font-size: clamp(0.875rem, 3cqw, 1.25rem);
  padding: 2cqi;
}

Las container queries tienen soporte en todos los navegadores actuales (baseline desde 2023). Si todavía necesitas un fallback para navegadores viejos, entrega primero una versión razonable con media query min-width y deja que @container la mejore — la misma lógica de mejora progresiva que mobile-first. Consulta la referencia de container queries en MDN para la sintaxis completa, incluidas las style() queries.

Tipografía y Espaciado Fluidos

Los breakpoints generan saltos visibles: texto cómodo a 767px que de repente queda gigante a 768px. clamp() elimina el salto interpolando entre un mínimo y un máximo con un valor preferido relativo al viewport:

h1 {
  /* nunca menos de 1.5rem, nunca más de 3.5rem, ~5vw en el medio */
  font-size: clamp(1.5rem, 5vw, 3.5rem);
}

p {
  font-size: clamp(1rem, 2.5vw, 1.125rem);
}

La fórmula detrás del valor preferido: elige el ancho de viewport donde quieres que el mínimo deje de aplicar y el ancho donde entra el máximo; el valor del medio es min + (max − min) × (100vw − minVw) / (maxVw − minVw). En la práctica, valores en vw entre 2.5vw y 6vw cubren la mayoría de los casos — solo verifica los extremos para que el valor preferido caiga realmente entre los topes en los anchos de tu diseño.

El mismo truco funciona para el espaciado, que es donde el diseño fluido más rinde. Padding de sección que respira en desktop pero no desperdicia la pantalla del teléfono:

.section {
  padding: clamp(1rem, 5vw, 4rem);
  margin-bottom: clamp(1.5rem, 4vw, 3rem);
}

Aplica clamp() al ritmo vertical (padding de secciones, márgenes de encabezados) antes de usarlo en el cuerpo de texto: el texto por debajo de ~1.25rem rara vez gana con el escalado, y un término vw demasiado entusiasta puede bajarlo de los 16px que los usuarios esperan. La página de clamp() en MDN tiene todos los detalles de los parámetros.

Imágenes Responsive

Las imágenes causan dos problemas responsive distintos — descargan demasiados datos para pantallas pequeñas y mueven el layout cuando no se conocen sus dimensiones — y cada uno pide un arreglo distinto.

srcset y sizes: cambio de resolución

<img
  src="image-800.jpg"
  srcset="image-400.jpg 400w, image-800.jpg 800w, image-1200.jpg 1200w, image-1600.jpg 1600w"
  sizes="(max-width: 600px) 100vw, (max-width: 1200px) 50vw, 33vw"
  alt="Descripción"
  width="800"
  height="600"
  loading="lazy"
  decoding="async"
/>

Con srcset listas qué archivos existen y sus anchos reales; con sizes declaras qué ancho va a ocupar la imagen en cada viewport — y esa es la parte que la gente suele hacer mal. Juntas las dos y el navegador descarga el archivo más chico que siga viéndose nítido. Deja sizes fuera o escríbelo mal y asume 100vw, así que una miniatura de 300px termina descargando el archivo de 1600px. Escribe sizes a partir de tu layout real, no de la imagen: un grid de tres columnas es aproximadamente 33vw en desktop, no 100vw.

flowchart diagram: Viewport 375px, DPR 2

picture: dirección de arte

srcset elige resoluciones de la misma imagen. Cuando lo que tiene que cambiar es el recorte — un paisaje ancho en desktop vs. un cuadrado en móvil — usa picture:

<picture>
  <source media="(max-width: 600px)" srcset="mobile.avif" type="image/avif" />
  <source media="(max-width: 1200px)" srcset="tablet.avif" type="image/avif" />
  <img src="desktop.jpg" alt="Descripción" width="1600" height="900" />
</picture>

Pon primero los formatos modernos (avif, luego webp) y deja el <img> como fallback: los navegadores eligen el primer <source> que soportan, así que el orden importa. El <img> también es donde viven alt, las dimensiones y los atributos de carga; los <source> solo intercambian el archivo.

Evitar el layout shift

Declara siempre las dimensiones: atributos width/height en el <img> o aspect-ratio en CSS. El navegador reserva la caja antes de que llegue el archivo, lo que elimina el salto de CLS:

.image-container {
  aspect-ratio: 16 / 9;
  overflow: hidden;
}

.image-container img {
  width: 100%;
  height: 100%;
  object-fit: cover;
}

Para la imagen LCP concreta (normalmente el hero), haz lo contrario de lazy: loading="eager" más fetchpriority="high". Hacer lazy-load del hero es una regresión de LCP auto-infligida clásica en móvil. Más detalles en la guía de imágenes responsive de MDN.

Tablas y Datos Responsive

Las tablas son la causa número uno de overflow horizontal en móvil. Dos estrategias cubren casi todos los casos.

El scroll horizontal es la más simple: envuelve la tabla y deja que haga scroll dentro del wrapper, así la página nunca desborda:

.table-wrapper {
  overflow-x: auto;
  -webkit-overflow-scrolling: touch;
}

Úsala para datos genuinamente tabulares — matrices de precios, tablas comparativas, logs — donde las columnas deben mantenerse alineadas. El min-width de la tabla controla cuándo aparece el scroll.

La transformación a cards convierte cada fila en una card apilada en pantallas pequeñas, repitiendo el encabezado como etiqueta vía data-label:

@media (max-width: 640px) {
  table, thead, tbody, th, td, tr {
    display: block;
  }

  thead {
    display: none;
  }

  tr {
    margin-bottom: 1rem;
    border: 1px solid #e2e8f0;
    border-radius: 0.5rem;
    padding: 0.75rem;
  }

  td {
    display: flex;
    justify-content: space-between;
  }

  td::before {
    content: attr(data-label);
    font-weight: 600;
  }
}

Esto necesita data-label en cada <td> del markup. Se lee mucho mejor en teléfonos para datos tipo entidad (listas de usuarios, facturas, configuraciones), pero es la elección equivocada para comparaciones densas donde escanear entre columnas es el punto: una tabla de precios de 20 columnas debería hacer scroll, no apilarse.

Unidades de Viewport y Áreas Seguras

100vh en móvil no es 100vh. El chrome del navegador — barra de direcciones, toolbars — aparece y desaparece al hacer scroll, y el vh clásico toma un valor que no coincide con ninguno de los dos estados. El resultado: heroes con contenido tapado por la barra de direcciones o un hueco abajo. Las unidades dinámicas de viewport lo arreglan:

  • dvh sigue la altura visible actual — se redimensiona cuando el chrome aparece o desaparece.
  • svh es la altura de viewport más pequeña — garantizada completamente visible.
  • lvh es la más grande — la altura con el chrome completamente oculto.
.hero {
  /* siempre completamente visible, aun con la barra de direcciones */
  min-height: 100svh;
}

.drawer {
  /* sigue al viewport vivo para que el drawer nunca quede cortado */
  max-height: 100dvh;
}

Usa svh para todo lo que nunca deba quedar cubierto (heroes, diálogos full-screen) y dvh para elementos que deban seguir al viewport en vivo (drawers pegajosos, hojas de chat). El vh plano sigue sirviendo como fallback: los navegadores que no conocen svh/dvh ignoran la declaración, así que declara vh primero.

Los dispositivos con notch agregan una arruga más. Los iPhones en landscape pueden superponer tus sidebars fijos sobre la zona de sensores. env(safe-area-inset-*) devuelve los márgenes inseguros:

.header {
  padding-left: max(1rem, env(safe-area-inset-left));
  padding-right: max(1rem, env(safe-area-inset-right));
}

Esto requiere viewport-fit=cover en el meta viewport para tener efecto — sin eso los insets siempre son 0.

Pruebas en Condiciones Reales

La emulación de dispositivos de DevTools es donde todos empiezan — Ctrl+Shift+M en Chrome/Firefox, el Responsive Design Mode de Safari — y sirve para bugs de layout. Lo que no te va a mostrar: rendimiento real de GPU, comportamiento táctil real, diferencias de renderizado de fuentes y el problema del chrome del navegador de la sección anterior.

La jerarquía de pruebas que detecta la mayoría de los bugs:

  1. Emulación en DevTools para layout, breakpoints e iteración rápida.
  2. Throttling de red (preset Slow 4G): los bugs responsive suelen ser en realidad bugs de rendimiento — una imagen hero de 2MB que nunca carga expone tu estado de layout-roto-sin-imagen.
  3. Un teléfono real en el mismo Wi-Fi: remote debugging de Chrome DevTools para Android, Web Inspector de Safari para iOS. Cinco minutos en un dispositivo real encuentran problemas que los emuladores nunca verán: tap targets demasiado chicos, menús que dependen del hover, scroll con tirones.
  4. Las pruebas de viewport automatizadas detectan regresiones casi gratis. Con Playwright, verificar que el layout no desborde en tus breakpoints son unas pocas líneas:
test('sin overflow horizontal en móvil', async ({ page }) => {
  await page.setViewportSize({ width: 375, height: 667 });
  await page.goto('/es/guides/');
  const overflow = await page.evaluate(
    () => document.documentElement.scrollWidth > document.documentElement.clientWidth
  );
  expect(overflow).toBe(false);
});

Para depuración visual del layout en sí, el clásico truco del outline sigue funcionando:

* {
  outline: 1px solid red;
}

Feo, temporal, y muestra al instante qué elemento está causando el overflow. Sácalo antes de commitear.

Auditar un Layout Existente

Cuando heredas una base de código que “casi funciona en móvil”, no la reescribas — audítala en este orden:

  1. Revisa primero el meta viewport. ¿Falta width=device-width, initial-scale=1 o está mal? Sin esa línea, el resto da igual.
  2. Caza anchos fijos. Busca en la hoja de estilos width: y min-width: en px — cada uno es sospechoso. Reemplázalos por %, fr, max-width o clamp() donde sea un contenedor.
  3. Revisa los culpables habituales de overflow: tablas sin .table-wrapper, bloques <pre> sin overflow-x: auto, URLs largas, hijos flex sin min-width: 0.
  4. Audita las imágenes: ¿tienen todas las dimensiones declaradas? ¿srcset/sizes por encima del fold y loading="lazy" solo por debajo?
  5. Revisa las media queries max-width. Si el código es desktop-first, no tienes que reescribirlo todo de una vez — pero cada feature nuevo debería ser mobile-first, y los bloques max-width se van convirtiendo a medida que los tocas.
  6. Prueba con el dedo la nav y los CTAs a 375px. Botones de menos de ~44×44px y enlaces a menos de ~8px entre sí fallan tanto para usuarios como para WCAG 2.5.5.
  7. Prueba con contenido real, no con lorem. Un layout que funciona con títulos de 12 caracteres se rompe con copy real. Ahí es donde los grids auto-fit se ganan su lugar: degradan con gracia en vez de romperse en un breakpoint.

La mayoría de las “reescrituras responsive” terminan siendo 10–20 arreglos puntuales encontrados con exactamente esta lista. Corréla antes de asumir que necesitas un rediseño.

Buenas Prácticas

  • Empezar mobile-first — los estilos base apuntan a la pantalla más pequeña y las media queries min-width mejoran hacia arriba.
  • Dejar que CSS haga el trabajo — los grids auto-fit, clamp() y las container queries eliminan breakpoints en vez de agregarlos.
  • Escribir sizes desde el layout, no desde la imagen — es el ancho renderizado, no el del archivo.
  • Declarar las dimensiones de las imágenes — los atributos width/height o aspect-ratio previenen el CLS.
  • Usar svh/dvh en lugar de vh para todo lo que el chrome del navegador pueda tapar.
  • Poner min-width: 0 en los hijos flex — es el arreglo de la mayoría de los overflow misteriosos.
  • Preferir gap sobre márgenes en flex y grid — espaciado que no colapsa ni se duplica en los bordes.
  • Probar en un teléfono real — los emuladores no capturan el tacto, la GPU ni el comportamiento del chrome del navegador.
  • Limitar el largo de línea — las pantallas anchas convierten los párrafos en ríos; max-width: ~70ch en contenedores de texto los mantiene legibles.
  • Mantener pocos breakpoints y consistentes — adoptar una escala compartida (como 640/768/1024/1280) en vez de valores ad-hoc.

Errores Comunes

  • Escribir todo con media queries max-width — el CSS desktop-first crece y se vuelve más difícil de sobreescribir.
  • Anchos fijos en píxeles en contenedores — se rompe en cualquier pantalla más angosta que el valor.
  • Ocultar la nav con display: none sin ofrecer alternativa — los usuarios de teclado también pierden el menú.
  • Falta de sizes en imágenes con srcset — el navegador asume 100vw y descarga 4 veces los píxeles necesarios.
  • Imágenes sin dimensiones — causan layout shift en cada carga.
  • Heroes de 100vh en móvil — la barra de direcciones tapa tu CTA; usa 100svh.
  • Lazy-loading en la imagen LCP — una regresión de LCP directa y auto-infligida.
  • Tabla sin wrapper overflow-x: auto — una tabla ancha empuja toda la página hacia el costado.
  • Hijos flex sin min-width: 0 — el contenido largo desborda en vez de encoger.
  • Media queries para responsive a nivel componente — la herramienta correcta son las container queries; los breakpoints de página no conocen el contexto del componente.
  • Un breakpoint por dispositivo — terminas persiguiendo un mercado en movimiento; corta donde el layout se rompe.

Ver también

Preguntas frecuentes

¿Debo usar container queries o media queries?

Usa media queries para layout a nivel página — header, sidebar, grid principal — porque esas decisiones realmente dependen del viewport. Usa container queries para responsive a nivel componente — cards, widgets, cualquier cosa reutilizada en contextos distintos — porque el componente debería reaccionar al espacio que recibe, no a la pantalla. Responden a preguntas distintas, así que la mayoría de los proyectos reales necesitan ambas.

¿Cuál es la diferencia entre auto-fit y auto-fill en CSS Grid?

Los dos llenan la fila con tantos tracks como quepan. La diferencia está en qué pasa con el espacio sobrante: auto-fit colapsa los tracks vacíos a cero para que los items existentes se estiren y llenen la fila, mientras auto-fill mantiene los tracks vacíos para que los items conserven su tamaño y dejen huecos. Elige auto-fit cuando los items deban crecer para llenar el espacio; auto-fill cuando un item solo no deba estirarse hasta convertirse en un banner gigante.

¿Cómo manejo el problema de la altura del viewport en móvil?

Los navegadores móviles muestran y ocultan la barra de direcciones al hacer scroll, lo que cambia lo que significa vh. Usa 100dvh para elementos que siguen al viewport en vivo o 100svh para cualquier cosa que deba estar siempre completamente visible. Deja primero una declaración con vh como fallback para navegadores viejos — la cascada se encarga del resto.

¿Cuántos breakpoints debería tener un sitio web?

Menos de los que crees. Un conjunto de trabajo común es 4–5 (como 640/768/1024/1280 más un tope ancho opcional), pero el número correcto es "cuántos lugares donde tu layout realmente se rompe". Cada breakpoint es código que mantener y un estado que probar — si auto-fit, clamp() o las container queries pueden absorber la variación, úsalos en su lugar.

¿Todavía hacen falta media queries con las container queries?

Sí. Las container queries conocen el ancho del componente, no el del viewport — no pueden responder preguntas de página como "¿hay lugar para un sidebar?" o "¿esto es un teléfono?". Tampoco pueden hacer prefers-color-scheme, prefers-reduced-motion ni estilos de impresión. Las media queries manejan el contexto de página; las container queries, el del componente.

¿Siguen siendo necesarias las media queries para prefers-reduced-motion y el modo oscuro?

Sí — y también cuentan como preocupaciones responsive. @media (prefers-color-scheme: dark) reacciona al tema del usuario, @media (prefers-reduced-motion: reduce) a sus necesidades de movimiento, y ninguna depende del tamaño de pantalla. La receta de modo oscuro cubre una implementación completa.