What It’s Like to Be a Web Developer in 2026
People keep asking if AI replaced developers. It didn’t. What it replaced is the excuse for not understanding your craft. Let me tell you what my actual workflow looks like now.
The Mental Model That Everything Else Depends On
AI is a tool. You are the architect.
If you don’t know what the DOM is, you can’t evaluate what the AI wrote. If you don’t understand change detection, you can’t tell when the generated Angular component is wrong. The gap between a developer who uses AI and a developer who understands AI output is exactly the gap between someone who knows their fundamentals and someone who doesn’t.
AI amplifies what you already are. That’s the double-edged part.
Claude Code: Not a Chatbot, a Collaborator
I work with Claude Code as a sub-agent system. The model doesn’t write code at me — it works with me inside a structured workflow. I define the architecture. I define the spec. Claude implements, I review and steer.
The key difference from “AI chatbot writes code” is agency. I know what I’m asking for and why. When Claude takes a wrong turn, I catch it because I understand what correct looks like.
# This is my actual terminal most of the day
claude code
That’s it. The intelligence is in the configuration, not the command.
MCP Servers: Giving the Agent Real Context
MCP (Model Context Protocol) is what makes modern AI tooling actually useful. Instead of describing your project to the AI in every message, MCP servers inject live context: your Notion docs, your database schema, your design files, your git history.
I run several MCPs in my stack:
- Engram — persistent memory across sessions. The agent remembers what we decided last week.
- Firebase — read/write access to the project database
- Playwright — browser automation for testing and visual verification
- Notion — pulls in project docs and specs automatically
- Pencil — reads and writes design files
The result: the agent knows the codebase, the history, the design, and the spec before I type a single word.
Skills: Encoding Best Practices Once, Using Them Always
Skills are reusable agent behaviors. Think of them as a codified senior developer opinion that gets injected into every relevant task.
When I’m building an Angular component, the angular-best-practices skill fires automatically. It tells the agent: use signals for state, standalone components only, no ViewChild when signals work, reactive forms over template-driven.
I wrote those rules once. They run on every Angular task, forever. Zero repetition. Zero “but you did it differently last time.”
The Gentle AI stack ships a full catalog of skills across Angular, Go, React, testing, SDD, and more. One install command and your agent is opinionated about your stack.
Context Window: The Most Misunderstood Constraint
The context window is how much the model can “see” at once. Most people hit its limit and get confused when the agent “forgets” what you talked about an hour ago.
The solution isn’t a bigger model — it’s memory architecture.
I use Engram (a persistent memory MCP) to save decisions, discoveries, and conventions as they happen. When a session starts, the agent loads the relevant memories first. When context fills up, the important stuff is already persisted. Nothing is lost.
Session 1: Decide on auth architecture → saved to Engram
Session 2: Agent loads auth decision from Engram before writing auth code
This is the difference between an agent that builds incrementally and one that reinvents the wheel every session.
RAG: Retrieval Augmented Generation
RAG is how you give an AI access to knowledge it wasn’t trained on — your private docs, your company’s code standards, the spec you wrote yesterday.
In practice: instead of stuffing an entire codebase into the context window, you store it in a searchable format (Engram, a vector DB, etc.) and retrieve only the relevant chunks when needed.
For development, this means: write the spec once, and the agent retrieves it automatically when implementing. Write the architecture decision once, and it’s always available without eating your context budget.
Fine-Tuning vs Prompting: When to Use Which
People reach for fine-tuning when they should use better prompting — and vice versa.
Use prompting (skills/system prompt) when:
- You want the model to follow specific conventions
- The behavior should adapt to context
- You’re working on your own projects or client work
Use fine-tuning when:
- You have thousands of examples of correct input/output pairs
- You need the model to internalize a very specific domain
- The behavior is fixed and doesn’t need to adapt
For 95% of development workflows, skills + RAG + structured prompting outperforms fine-tuning. Fine-tuning is expensive, slow to iterate on, and overkill for most use cases.
The Gentle AI Stack in Practice
The Gentle AI stack is what ties all of this together. One install command configures:
- 8 supported agents (Claude Code, Cursor, VS Code Copilot, etc.)
- Engram for persistent memory
- SDD (Spec-Driven Development) workflow: explore → propose → spec → design → tasks → apply → verify
- Skills catalog across multiple languages and frameworks
- Persona — a senior architect persona that teaches while it works
- Per-phase model routing — Opus for architecture decisions, Sonnet for implementation
The workflow isn’t “ask AI to write a feature.” It’s:
- Explore — agent reads the codebase and maps the problem
- Propose — architectural approach documented
- Spec — requirements written as Given/When/Then scenarios
- Design — file changes, interfaces, and decisions documented
- Tasks — concrete checklist
- Apply — implementation against the spec
- Verify — check that what was built matches what was specified
Every step is saved to Engram. Every session picks up exactly where the last one ended.
The Bottom Line
2026 development isn’t “prompt and pray.” It’s:
- Foundations still matter — more than ever
- AI amplifies your understanding, not replaces it
- Memory, skills, and structured workflows turn a chatbot into a system
- The developers winning right now understand their tools at both levels: the AI layer and the code underneath it
The tools changed. The craft didn’t. You still have to know what you’re building.
Cómo Es Ser Desarrollador Web en 2026
La gente sigue preguntando si la IA reemplazó a los desarrolladores. No lo hizo. Lo que reemplazó es la excusa para no entender tu oficio. Déjame contarte cómo se ve mi flujo de trabajo real ahora.
El Modelo Mental Del Que Todo Lo Demás Depende
La IA es una herramienta. Tú eres el arquitecto.
Si no sabes qué es el DOM, no puedes evaluar lo que escribió la IA. Si no entiendes change detection, no puedes detectar cuándo el componente Angular generado está mal. La brecha entre un desarrollador que usa IA y un desarrollador que entiende el output de la IA es exactamente la brecha entre alguien que conoce sus fundamentos y alguien que no.
La IA amplifica lo que ya eres. Esa es la parte de doble filo.
Claude Code: No un Chatbot, un Colaborador
Trabajo con Claude Code como un sistema de sub-agentes. El modelo no me escribe código — trabaja conmigo dentro de un flujo estructurado. Yo defino la arquitectura. Yo defino el spec. Claude implementa, yo reviso y dirijo.
La diferencia clave con “el chatbot de IA escribe código” es la agencia. Sé qué estoy pidiendo y por qué. Cuando Claude se equivoca de camino, lo detecto porque entiendo cómo se ve lo correcto.
# Esto es mi terminal real la mayor parte del día
claude code
Eso es todo. La inteligencia está en la configuración, no en el comando.
MCP Servers: Dándole Contexto Real al Agente
MCP (Model Context Protocol) es lo que hace que las herramientas de IA modernas sean realmente útiles. En vez de describir tu proyecto a la IA en cada mensaje, los servidores MCP inyectan contexto en vivo: tus docs de Notion, tu schema de base de datos, tus archivos de diseño, tu historial de git.
Uso varios MCPs en mi stack:
- Engram — memoria persistente entre sesiones. El agente recuerda qué decidimos la semana pasada.
- Firebase — acceso de lectura/escritura a la base de datos del proyecto
- Playwright — automatización del navegador para testing y verificación visual
- Notion — importa docs y specs del proyecto automáticamente
- Pencil — lee y escribe archivos de diseño
El resultado: el agente conoce el codebase, la historia, el diseño y el spec antes de que escriba una sola palabra.
Skills: Codificar Buenas Prácticas Una Vez, Usarlas Siempre
Los skills son comportamientos reutilizables del agente. Piénsalos como una opinión de desarrollador senior codificada que se inyecta en cada tarea relevante.
Cuando construyo un componente Angular, el skill angular-best-practices se activa automáticamente. Le dice al agente: usa signals para el estado, solo componentes standalone, no ViewChild cuando funcionan los signals, reactive forms en vez de template-driven.
Escribí esas reglas una vez. Corren en cada tarea Angular, para siempre. Cero repetición. Cero “pero lo hiciste diferente la última vez.”
El stack de Gentle AI viene con un catálogo completo de skills para Angular, Go, React, testing, SDD y más. Un comando de instalación y tu agente tiene opiniones sobre tu stack.
Context Window: El Constraint Más Malentendido
El context window es cuánto puede “ver” el modelo a la vez. La mayoría de la gente llega al límite y se confunde cuando el agente “olvida” lo que hablaron hace una hora.
La solución no es un modelo más grande — es arquitectura de memoria.
Uso Engram (un MCP de memoria persistente) para guardar decisiones, descubrimientos y convenciones a medida que ocurren. Cuando inicia una sesión, el agente carga los recuerdos relevantes primero. Cuando el contexto se llena, lo importante ya está persistido. No se pierde nada.
Sesión 1: Decidir arquitectura de auth → guardado en Engram
Sesión 2: Agente carga decisión de auth desde Engram antes de escribir código de auth
Esta es la diferencia entre un agente que construye incrementalmente y uno que reinventa la rueda en cada sesión.
RAG: Retrieval Augmented Generation
RAG es cómo le das a una IA acceso a conocimiento para el que no fue entrenada — tus docs privados, los estándares de código de tu empresa, el spec que escribiste ayer.
En la práctica: en vez de meter todo un codebase en el context window, lo guardas en un formato buscable (Engram, una vector DB, etc.) y recuperas solo los fragmentos relevantes cuando se necesitan.
Para desarrollo, esto significa: escribe el spec una vez, y el agente lo recupera automáticamente al implementar. Escribe la decisión de arquitectura una vez, y siempre está disponible sin consumir tu budget de contexto.
Fine-Tuning vs Prompting: Cuándo Usar Cada Uno
La gente llega al fine-tuning cuando debería usar mejor prompting — y viceversa.
Usa prompting (skills/system prompt) cuando:
- Quieres que el modelo siga convenciones específicas
- El comportamiento debe adaptarse al contexto
- Trabajas en tus proyectos o trabajo de cliente
Usa fine-tuning cuando:
- Tienes miles de pares de input/output correctos
- Necesitas que el modelo internalice un dominio muy específico
- El comportamiento es fijo y no necesita adaptarse
Para el 95% de los flujos de trabajo de desarrollo, skills + RAG + prompting estructurado supera al fine-tuning. El fine-tuning es caro, lento de iterar, y exagerado para la mayoría de los casos.
El Stack de Gentle AI en Práctica
El stack de Gentle AI es lo que une todo esto. Un comando de instalación configura:
- 8 agentes soportados (Claude Code, Cursor, VS Code Copilot, etc.)
- Engram para memoria persistente
- Flujo SDD (Spec-Driven Development): explore → propose → spec → design → tasks → apply → verify
- Catálogo de skills en múltiples lenguajes y frameworks
- Persona — una persona de arquitecto senior que enseña mientras trabaja
- Routing de modelo por fase — Opus para decisiones de arquitectura, Sonnet para implementación
El flujo no es “pedirle a la IA que escriba una feature.” Es:
- Explore — el agente lee el codebase y mapea el problema
- Propose — enfoque arquitectónico documentado
- Spec — requerimientos escritos como escenarios Given/When/Then
- Design — cambios de archivos, interfaces y decisiones documentadas
- Tasks — checklist concreto
- Apply — implementación contra el spec
- Verify — verificar que lo construido coincide con lo especificado
Cada paso se guarda en Engram. Cada sesión retoma exactamente donde terminó la anterior.
La Conclusión
El desarrollo en 2026 no es “prompting y rezar.” Es:
- Los fundamentos siguen importando — más que nunca
- La IA amplifica tu comprensión, no la reemplaza
- La memoria, los skills y los flujos estructurados convierten un chatbot en un sistema
- Los desarrolladores que ganan ahora entienden sus herramientas en ambos niveles: la capa de IA y el código debajo de ella
Las herramientas cambiaron. El oficio, no. Todavía tienes que saber qué estás construyendo.