Análisis completo del proceso de entrevistas de Anthropic para ingenieros de software en 2026: 5 rondas, LRU cache, diseño de sistemas de inferencia LLM, web crawler concurrente y por qué su bar técnico es más alto que el de Google o Meta.
Jesús Blanco
Autor
Hay una ironía que circula entre developers desde principios de 2026: Anthropic dice públicamente que la IA ya está resolviendo buena parte de la programación, pero si intentas entrar a trabajar ahí como ingeniero, te espera uno de los procesos de entrevistas más exigentes de toda la industria tecnológica. Más duro que Google. Más específico que Meta. Y con problemas que mezclan algoritmos clásicos con los desafíos de infraestructura que enfrenta una empresa que entrena y sirve modelos de lenguaje masivos todos los días.
Este artículo analiza en detalle cómo funciona ese proceso, qué problemas reales piden, qué buscan más allá del código correcto, y qué diferencia a los candidatos que pasan del enorme porcentaje que no lo logra.
Si estás preparando entrevistas técnicas en general, también pueden interesarte nuestras guías de entrevistas React 2026, TypeScript y Next.js.
Anthropic fue fundada en 2021 por ex empleados de OpenAI que querían construir IA con un enfoque distinto: más énfasis en seguridad, interpretabilidad y control. Eso no es solo marketing: la empresa afirma que aproximadamente la mitad de su personal técnico viene de fuera del campo de machine learning, lo que significa que contratan ingenieros de sistemas, de infraestructura y de software general con la misma seriedad que a investigadores de IA.
El proceso de entrevistas refleja esa cultura. No buscan la solución más elegante algorítmicamente sino código que funcione, razonamiento claro y claridad sobre los tradeoffs. Si un loop simple resuelve el problema, eso es mejor que una solución sobre-diseñada. Pero al mismo tiempo, cuando el problema requiere eficiencia real, esperan que la sepas implementar, no solo que la menciones.
El proceso tarda en promedio 19 días de inicio a fin, aunque candidatos para roles más especializados reportan procesos de hasta 4 semanas. La decisión de contratación requiere consenso de todos los entrevistadores, y en casos donde no hay acuerdo, el hiring manager tiene la última palabra.
El primer filtro real es una evaluación asíncrona en CodeSignal con 90 minutos para dos problemas. Anthropic usa LLMs para detectar código diseñado específicamente para pasar tests en lugar de resolver el problema genuinamente, así que no tiene sentido intentar trucos.
La evaluación consiste en una especificación general y un evaluador de caja negra. Hay cuatro niveles y la especificación se vuelve más compleja en cada uno. Tu código debe pasar todos los tests de un nivel para avanzar al siguiente.
Los dos problemas más documentados para el rol de infraestructura son estos:
Problema A: Caché LRU (Least Recently Used)
El reto es implementar una política de desalojo de caché donde, al llenarse la capacidad, se elimina el elemento que lleva más tiempo sin usarse. Una solución que funcione no es suficiente: esperan complejidad O(1) tanto para acceso como para eliminación.
La solución correcta combina un hashmap con una lista doblemente enlazada. El hashmap da acceso en tiempo constante a cualquier elemento por su clave. La lista doblemente enlazada mantiene el orden de uso y permite mover el elemento accedido al frente o eliminar el del final en O(1) sin recorrer toda la estructura.
class NodoLRU:
def __init__(self, clave, valor):
self.clave = clave
self.valor = valor
self.anterior = None
self.siguiente = None
class CacheLRU:
def __init__(self, capacidad: int):
self.capacidad = capacidad
self.mapa = {}
# Nodos centinela para simplificar el manejo de bordes
self.cabeza = NodoLRU(0, 0) # más reciente
self.cola = NodoLRU(0, 0) # menos reciente
self.cabeza.siguiente = self.cola
self.cola.anterior = self.cabeza
def get(self, clave: int) -> int:
if clave in self.mapa:
nodo = self.mapa[clave]
self._mover_al_frente(nodo)
return nodo.valor
return -1
def put(self, clave: int, valor: int) -> None:
if clave in self.mapa:
nodo = self.mapa[clave]
nodo.valor = valor
self._mover_al_frente(nodo)
else:
if len(self.mapa) >= self.capacidad:
# Eliminar el menos recientemente usado
lru = self.cola.anterior
self._eliminar(lru)
del self.mapa[lru.clave]
nodo = NodoLRU(clave, valor)
self.mapa[clave] = nodo
self._insertar_al_frente(nodo)
def _mover_al_frente(self, nodo):
self._eliminar(nodo)
self._insertar_al_frente(nodo)
def _eliminar(self, nodo):
nodo.anterior.siguiente = nodo.siguiente
nodo.siguiente.anterior = nodo.anterior
def _insertar_al_frente(self, nodo):
nodo.siguiente = self.cabeza.siguiente
nodo.anterior = self.cabeza
self.cabeza.siguiente.anterior = nodo
self.cabeza.siguiente = nodo
Lo que el entrevistador observa no es solo si el código es correcto, sino si explicas por qué la lista doblemente enlazada y no solo un array ordenado, y si manejas bien los casos borde: cache de capacidad 1, intentar acceder a una clave que no existe, sobreescribir una clave existente.
Problema B: Sistema de gestión de tareas con dependencias
El segundo problema es más complejo conceptualmente. Se pide un sistema que maneje tareas con prioridades, dependencias entre ellas (si B depende de A, A debe completarse antes) y cancelaciones en cascada (si cancelas A, todas las tareas que dependen de A también se cancelan).
La solución espera que modeles el problema como un Grafo Dirigido Acíclico (DAG). El ordenamiento topológico determina el orden correcto de ejecución, una cola de prioridad gestiona qué tarea ejecutar a continuación, y una búsqueda en profundidad (DFS) propaga las cancelaciones por todos los nodos dependientes.
Lo interesante de este problema es que combina tres estructuras de datos distintas con una lógica de negocio real. No es un LeetCode genérico: es un problema que cualquier sistema de orquestación de tareas en producción necesita resolver.
Esta ronda evalúa si puedes construir software que interactúe con el mundo real bajo restricciones concretas. El problema más documentado es un web crawler.
El reto: dado una URL inicial, explorar el contenido web hasta una profundidad máxima, evitar visitar la misma URL dos veces y no sobrecargar los servidores destino.
La solución esperada usa BFS para explorar por niveles de profundidad, un conjunto de URLs visitadas para evitar ciclos, y semáforos para limitar la concurrencia. El último punto es donde la mayoría de candidatos falla: no basta con hacer las peticiones concurrentes, hay que limitarlas activamente.
import asyncio
import aiohttp
from collections import deque
from urllib.parse import urljoin, urlparse
async def crawl(url_inicial: str, profundidad_max: int, max_concurrente: int = 10):
visitadas = set()
cola = deque([(url_inicial, 0)])
semaforo = asyncio.Semaphore(max_concurrente)
resultados = {}
async def fetch(session, url, profundidad):
if url in visitadas or profundidad > profundidad_max:
return
visitadas.add(url)
async with semaforo:
try:
async with session.get(url, timeout=aiohttp.ClientTimeout(total=10)) as resp:
html = await resp.text()
resultados[url] = {'status': resp.status, 'profundidad': profundidad}
# Extraer enlaces y agregar a la cola
# (parseo de HTML simplificado para el ejemplo)
enlaces = extraer_enlaces(html, url)
for enlace in enlaces:
if enlace not in visitadas:
cola.append((enlace, profundidad + 1))
except Exception as e:
resultados[url] = {'error': str(e)}
async with aiohttp.ClientSession() as session:
tareas = []
while cola:
url, profundidad = cola.popleft()
tarea = asyncio.create_task(fetch(session, url, profundidad))
tareas.append(tarea)
await asyncio.gather(*tareas)
return resultados
Lo que diferencia una respuesta buena de una excelente en esta ronda: manejar los timeouts, considerar qué pasa con URLs que redirigen, y poder hablar sobre cómo escalarías esto si necesitas crawlear millones de páginas en lugar de cientos.
Esta es la ronda más específica de Anthropic y la que más diferencia este proceso del de otras empresas. El problema: diseñar una API de inferencia para servir modelos de lenguaje grande a escala.
No es un ejercicio abstracto. Es literalmente el tipo de sistema que Anthropic construye y opera todos los días para servir a Claude. Y lo saben los candidatos que llegan bien preparados.
Los cuatro desafíos que el diseño debe resolver:
Cargas variables. Una petición puede pedir 10 tokens o 10,000. Si las procesas en el mismo batch, las cortas esperan a las largas y las largas no aprovechan bien la GPU. La solución es una cola con prioridades que agrupe peticiones de longitud similar para procesarlas en paralelo sin desperdiciar capacidad.
Batching eficiente de GPU. Las GPUs son más eficientes procesando múltiples peticiones en paralelo que una a la vez. Pero si esperas demasiado para armar un batch completo, introduces latencia. El diseño debe balancear tamaño del batch con tiempo de espera máximo, con parámetros configurables según el SLA de cada tipo de cliente.
KV Cache. Cuando un modelo procesa texto, calcula representaciones intermedias (key-value pairs) para cada token. Si el mismo prefijo aparece en múltiples peticiones (por ejemplo, el mismo system prompt para miles de usuarios), recalcular esas representaciones cada vez es un desperdicio enorme de GPU. El KV Cache almacena esas representaciones y las reutiliza, reduciendo dramáticamente el costo de inferencia para peticiones con prefijos compartidos.
Streaming. Los usuarios no quieren esperar a que el modelo genere 2,000 tokens para ver la respuesta. Quieren verla aparecer token a token. Eso requiere conexiones de larga duración (Server-Sent Events o WebSockets) y una arquitectura que transmita cada token conforme se genera en lugar de acumularlos.
En una entrevista documentada, se pidió diseñar un sistema de búsqueda distribuido para 1,000 millones de documentos y 1 millón de consultas por segundo, manejando sharding, caché y escalado de inferencia LLM. El nivel de profundidad esperado es el de un ingeniero senior que ha trabajado con sistemas distribuidos en producción, no el de alguien que solo los conoce por libros.
Esta ronda es la más inusual y la que más sorprende a candidatos que vienen de prepararse solo con LeetCode. El problema documentado: convertir la salida de un sampling profiler en una línea de tiempo visual de ejecución de funciones.
Un sampling profiler toma muestras periódicas del call stack de un programa. Cada muestra es una foto del estado de la pila de llamadas en ese momento exacto. Lo que el profiler no registra directamente es cuándo empezó y cuándo terminó cada función.
Para reconstruir esa información, el candidato debe comparar muestras consecutivas de la pila. El punto donde dos pilas consecutivas divergen indica qué funciones terminaron entre una muestra y la siguiente, y qué funciones nuevas comenzaron. Con esa lógica aplicada a todo el dataset de muestras, puedes reconstruir una línea de tiempo completa de la ejecución.
El problema evalúa comprensión de cómo funciona el software a nivel de sistema operativo, no solo a nivel de algoritmos. Es el tipo de problema que resuelves cuando depuras problemas de rendimiento en producción, que es exactamente lo que hacen los ingenieros de infraestructura de Anthropic.
La última ronda es menos técnica pero igualmente eliminatoria. El foco principal es AI safety, un tema central para Anthropic, y preguntas conductuales sobre experiencias pasadas.
Las preguntas documentadas por candidatos incluyen situaciones donde tuviste que priorizar seguridad sobre velocidad o rendimiento, cómo manejas desacuerdos técnicos con el equipo, y qué piensas sobre los riesgos más urgentes del desarrollo de IA avanzada.
Anthropic espera que los candidatos demuestren no solo habilidades técnicas sino reflexión profunda sobre las implicaciones éticas y las consecuencias a largo plazo de su trabajo. No es suficiente con respuestas genéricas sobre "hacer el bien". Esperan candidatos que hayan pensado en estos temas con seriedad y que puedan articular sus posiciones con claridad.
Varios candidatos que han hecho entrevistas tanto en empresas FAANG como en Anthropic describen diferencias concretas.
Los problemas de Anthropic tienden a ser más prácticos que los típicos de LeetCode. Aunque son algorítmicos, están conectados con problemas reales que la empresa enfrenta. El web crawler, el sistema de inferencia de LLMs, el profiler: son problemas que cualquier ingeniero de Anthropic podría encontrarse en su trabajo real.
Anthropic no da ofertas con fecha de vencimiento inmediata y son pacientes durante el proceso. Eso contrasta con empresas que presionan a los candidatos para que decidan en 24 o 48 horas.
La compensación refleja el nivel del proceso. Una oferta documentada de Staff Engineer en Anthropic totaliza alrededor de $920,000 USD en compensación anual. Para ingenieros senior el rango varía según experiencia y nivel, pero es consistentemente más alto que el promedio del sector.
Lo que no funciona bien según varios candidatos es la comunicación post-proceso. El proceso de team-matching puede extenderse más de tres semanas con poca comunicación, y algunos candidatos que pasaron todas las rondas técnicas fueron rechazados porque no encontraron un equipo que necesitara su perfil específico en ese momento.
El perfil que Anthropic busca es específico. Necesitas tres cosas funcionando al mismo tiempo: dominio sólido de algoritmos y estructuras de datos clásicas, experiencia real con sistemas distribuidos y de infraestructura, y reflexión genuina sobre AI safety que vaya más allá de las respuestas de manual.
Para los algoritmos: LRU cache, topological sort, BFS con concurrencia y semáforos son temas que aparecen repetidamente. No basta con conocerlos: debes poder implementarlos en Python limpiamente bajo presión de tiempo.
Para el diseño de sistemas: estudia cómo funcionan los sistemas de inferencia de LLMs, qué es el KV Cache, cómo funciona el batching en GPUs y qué tradeoffs implica el streaming de tokens. Si puedes explicar cómo Claude genera una respuesta a nivel de infraestructura, estás en el rango correcto de profundidad.
Para el cultural fit: lee los papers públicos de Anthropic, especialmente los relacionados con Constitutional AI y AI safety. Forma una opinión propia sobre los riesgos del desarrollo de IA y prepárate para defenderla con argumentos concretos, no con frases vacías.
El proceso completo dura entre 3 y 4 semanas y está muy bien pensado según la mayoría de candidatos que lo completaron, independientemente del resultado. La preparación adecuada lleva al menos el mismo tiempo.
Resolvemos las dudas específicas sobre este tema.
