Todo equipo frontend enfrenta eventualmente el mismo problema: los componentes se multiplican, las convenciones de nombres se diluyen, y lo que comenzó como un código limpio se convierte en un mosaico de soluciones únicas. Atomic Design resuelve esto dando a tu arquitectura de componentes una estructura clara y repetible, inspirada en la química. En lugar de adivinar dónde pertenece un nuevo componente, sigues una jerarquía que escala desde un simple botón hasta una aplicación completa.
No estamos diseñando páginas, estamos diseñando sistemas de componentes.
¿Qué es Atomic Design?
Brad Frost introdujo Atomic Design en 2013 como un modelo mental para construir interfaces de usuario. La idea central es simple: así como la materia en la naturaleza está compuesta por átomos que se combinan en moléculas y luego en organismos complejos, las interfaces de usuario pueden descomponerse en cinco niveles jerárquicos.
Los cinco niveles son Átomos, Moléculas, Organismos, Templates y Páginas. Cada nivel se construye sobre el anterior. La regla crítica: las dependencias solo fluyen hacia abajo — los átomos no importan nada, las moléculas importan solo átomos, los organismos importan moléculas, y así sucesivamente. Esta única restricción elimina las dependencias circulares y hace que cada componente sea predecible.
Los cinco niveles explicados
Los elementos UI más pequeños con significado. Botones, inputs, labels, encabezados, iconos, badges, imágenes y enlaces. No pueden descomponerse más sin perder su propósito. Piensa en ellos como la tabla periódica de tu sistema de diseño. Los átomos son autónomos — reciben todos los datos vía props y se estilan con design tokens.
Pequeños grupos de átomos que trabajan juntos como unidad funcional. Una SearchBar (Input + Button), un FormField (Label + Input + Error), un NavLink (Link + Icon), una Card (Imagen + Encabezado + Texto). La prueba clave: ¿este grupo sirve a un propósito único y claro? Si es así, es una molécula.
Secciones complejas y autónomas de una página. Un Header (Logo + Nav + SearchBar + Selector de Idioma), una sección Hero, un Footer, un formulario de contacto, una BlogSidebar, una tabla de precios. Los organismos son el primer nivel que se siente como una verdadera "sección" de un sitio web. Gestionan el layout y la coordinación de sus hijos.
Los templates definen la estructura de la página — dónde van los organismos y cómo fluye el layout. En Astro, los templates corresponden a archivos de layout (BaseLayout, BlogLayout). Las páginas son templates llenos de contenido real — los archivos de ruta en src/pages/ que los usuarios ven. Las páginas manejan la obtención de datos y los pasan a layouts y organismos.
Átomos en la práctica
Los átomos deben ser autónomos. Reciben todos los datos a través de props y nunca obtienen datos ni importan otros componentes. Se estilan usando design tokens (CSS custom properties), nunca valores hardcodeados.
---
interface Props {
variant?: 'primary' | 'secondary' | 'ghost';
size?: 'sm' | 'md' | 'lg';
disabled?: boolean;
}
const { variant = 'primary', size = 'md', disabled = false } = Astro.props;
---
<button
class:list={['btn', `btn--${variant}`, `btn--${size}`]}
disabled={disabled}
>
<slot />
</button> ---
interface Props {
type?: 'text' | 'email' | 'search' | 'password';
name: string;
placeholder?: string;
required?: boolean;
}
const { type = 'text', name, placeholder, required = false } = Astro.props;
---
<input
type={type}
name={name}
placeholder={placeholder}
required={required}
class="input"
/> ---
interface Props {
level?: 1 | 2 | 3 | 4 | 5 | 6;
size?: 'sm' | 'md' | 'lg' | 'xl' | '2xl';
}
const { level = 2, size = 'lg' } = Astro.props;
const Tag = `h${level}`;
---
<Tag class:list={['heading', `heading--${size}`]}>
<slot />
</Tag> Moléculas: El pegamento funcional
Las moléculas combinan dos o más átomos en una unidad funcional. La distinción clave: una molécula hace algo que sus átomos individuales no pueden hacer solos.
SearchBar = Átomo Input + Átomo Button. Juntos crean un formulario de búsqueda que acepta y envía consultas. Individualmente, el input solo recoge texto y el botón solo dispara una acción — ninguno busca nada solo. La molécula los conecta con un elemento <form>, role="search" y el atributo action adecuado.
FormField = Átomo Label + Átomo Input + Átomo mensaje de error. La molécula conecta el label al input vía atributos for/id, muestra errores de validación debajo del input y gestiona los estados visuales (válido, inválido, deshabilitado). Es la molécula más común en cualquier aplicación.
Card = Átomo Image + Átomo Heading + Átomo Text + Átomo Link opcional. Una unidad de previsualización de contenido para listados de blog, elementos de portfolio, miembros del equipo y productos. La molécula maneja el layout (vertical u horizontal), efectos hover y comportamiento de clic (toda la card clicable vs. solo el link).
La prueba de la molécula
Pregúntate: “¿Este grupo de átomos sirve a un propósito único y claro?” Si la respuesta es sí, es una molécula. Si sirve a múltiples propósitos o contiene otras moléculas, probablemente sea un organismo.
| Componente | ¿Molécula? | Por qué Recommended |
|---|---|---|
| SearchBar (Input + Button) | ✓ Sí | Un propósito: buscar |
| FormField (Label + Input + Error) | ✓ Sí | Un propósito: capturar un campo |
| NavLink (Link + Icon) | ✓ Sí | Un propósito: navegar |
| Header (Logo + Nav + Búsqueda) | ✗ No | Múltiples propósitos → Organismo |
| Footer (Nav + Contacto + Social) | ✗ No | Múltiples propósitos → Organismo |
Organismos: Secciones reales de página
Los organismos son el primer nivel que se siente como una “sección” de una página. Son componentes complejos y autónomos hechos de moléculas y átomos.
Los organismos gestionan cómo se organizan sus hijos — grid, flex, stack. Poseen las relaciones espaciales.
Reciben datos vía props desde el nivel de página y pasan las piezas correctas a cada molécula hija.
Cuando el estado de un hijo afecta a otro (ej., selección de pestaña muestra diferente contenido), el organismo lo orquesta.
Estructura de carpetas en Astro
Configurando Atomic Design
- Crear la jerarquía
Crea las carpetas: src/components/atoms/, molecules/, organisms/ y seo/. Añade src/layouts/ para templates y src/pages/ para páginas.
- Construir átomos primero
Comienza con Button, Input, Heading, Icon, Badge, Image y Link. Se usan en todas partes y deben ser sólidos antes de construir hacia arriba.
- Componer moléculas
Combina átomos en SearchBar, FormField, NavLink, Card y Breadcrumbs. Cada molécula importa solo de atoms/.
- Ensamblar organismos
Construye Header, Footer, Hero, ContactForm y BlogSidebar a partir de moléculas. Cada organismo importa de molecules/ (y ocasionalmente atoms/).
- Definir layouts
Crea BaseLayout.astro y BlogLayout.astro en src/layouts/. Estos componen organismos en estructuras de página completas con slots para contenido dinámico.
src/
├── components/
│ ├── atoms/ → Button, Input, Heading, Icon, Badge, Image, Link
│ ├── molecules/ → SearchBar, FormField, NavLink, Card, Breadcrumbs
│ ├── organisms/ → Header, Footer, Hero, ContactForm, BlogSidebar
│ └── seo/ → SEO.astro, Componentes de Schema
├── layouts/ → BaseLayout, BlogLayout (= Templates)
├── pages/ → index.astro, blog/[slug].astro (= Páginas)
├── styles/
│ ├── global.css
│ └── tokens/ → colors.css, typography.css, spacing.css
├── lib/ → utils.ts, constants.ts
└── types/ → Definiciones TypeScript
La regla de oro
Cada átomo necesita: interfaces de props adecuadas, markup accesible, cobertura completa de estados (hover, focus, active, disabled, error) e integración con design tokens. Un átomo mal diseñado propaga sus problemas por todas partes.
Evolución de un proyecto
Design tokens definidos. Átomos centrales construidos: Button, Input, Heading, Icon, Image, Link. Estilos globales y tipografía establecidos.
Moléculas ensambladas: SearchBar, FormField, Card, NavLink, Breadcrumbs. Primeros organismos iniciados: Header, Footer.
Organismos completados: Hero, ContactForm, BlogSidebar, PricingTable. Layouts base creados con grid responsivo.
Todas las páginas construidas componiendo componentes existentes. Nuevas páginas toman horas en lugar de días. Sistema de diseño completamente operativo.
Errores comunes
Frequently Asked Questions
Es tentador pero lleva a organismos monolíticos que son difíciles de probar, reutilizar y modificar. Tómate el tiempo para identificar las moléculas dentro de tu organismo. Un Header no es un gran componente — contiene una molécula NavLink, una molécula SearchBar y una molécula LanguageSwitcher.
No. Un simple <span> con una clase no es un átomo — es solo HTML. Los átomos representan decisiones de diseño significativas y reutilizables. Si te encuentras creando TextSmall, TextMedium, TextLarge, usa un solo átomo Text con un prop de tamaño.
Está bien. Atomic Design es un modelo mental, no una regla estricta. Un organismo Hero podría usar un átomo Heading directamente — no hay una molécula significativa entre ellos. Sé pragmático con la jerarquía.
Perfectamente. Los átomos y moléculas son estáticos por defecto (cero JS). Cuando necesitas interactividad, envuelves un componente React o Vue como island dentro de un organismo Astro. La jerarquía de Atomic Design permanece igual — la island es simplemente un átomo o molécula interactivo.
Por qué Atomic Design gana
Después de aplicar Atomic Design en más de 30 proyectos en producción, estos son los beneficios que emergen consistentemente. Si quieres ver cómo se implementa en la práctica con más de 45 componentes reales, consulta el artículo Atomic Design en la práctica.
Los nuevos desarrolladores entienden la arquitectura en horas, no semanas. La estructura de carpetas les dice exactamente dónde vive cada componente.
Cada página usa los mismos bloques de construcción, eliminando la deriva visual. Un Button, una Card, un Header — en todas partes.
Los átomos se prueban aislados, las moléculas con átomos mockeados, los organismos con moléculas mockeadas. Cada nivel tiene un límite de prueba claro.
Componentes pequeños y enfocados permiten tree-shaking e hidratación selectiva en Astro. Solo las islands interactivas envían JavaScript.
Añadir un nuevo tipo de página significa componer componentes existentes, no construir desde cero. El sistema crece sin aumentar la complejidad.
Diseñadores y desarrolladores comparten el mismo vocabulario y jerarquía. Una molécula en Figma es una molécula en el código.