DEV Community: Gabriel Porras

Claude Code me hace mejor dev (y tengo los datos) 🧠⚙️

Gabriel Porras — Mon, 09 Feb 2026 16:58:20 +0000

“Lately I have seen you take a more active role in PR review and really investigating, catching and detailing issues that come up. This is a big help to the team in my opinion.”

Eso me lo dijo un tech lead después de las semanas en que más he usado IA para escribir código. No menos: más. Y cuando corrí /insights, el comando que analiza tu historial de sesiones en Claude Code y genera un reporte de patrones, fricciones y métricas, entendí por qué.

Disclaimer rápido: no tengo relación con Anthropic. Uso estas herramientas porque me funcionan, y lo comparto porque los datos me parecen útiles para otros devs.

Esto no es “dejar de programar”: es otra etapa del oficio 🧬

El desarrollo siempre ha sido una cadena de abstracciones: cada salto nos quitó tecleo, no responsabilidad. Los agentes parecen ser el siguiente salto: menos escribir, más decidir y mantener.

Mi setup 🧩

Pasé de usar ChatGPT para dudas puntuales a integrar Claude Code como herramienta diaria.

Claude Code (Sonnet 4.5) en terminal: implementaciones completas, multi-archivo, iteración con feedback.
JetBrains AI (con Sonnet 4.5): dudas puntuales en el IDE, PR reviews, prompts específicos.

No me interesa lo que algunos llaman vibe coding: construir muy rápido con IA e iterar hasta que funcione, sin necesariamente profundizar en el porqué técnico de cada decisión. A mí me interesa desarrollo asistido con control: que el agente acelere, pero yo mantengo la dirección. Todo lo que se mergea pasa por mi revisión línea por línea. Si algo se rompe, el responsable soy yo.

Los números: qué dice `/insights` sobre mi uso real 📊

Ejecuté /insights dentro de Claude Code y me devolvió un reporte que cubre solo mi actividad desde la terminal en las dos últimas semanas. Ojo: llevo meses usando la herramienta; este reporte captura solo ese periodo.

445 mensajes en 12 días (≈ 37.1 msgs/día)
+5,867 / −3,088 líneas en 61 archivos
Un patrón dominante: Iterative Refinement en 13 sesiones

Las dos categorías principales de lo que le pedí empatan: Feature implementation (17) y Bug fix (17), seguidas de UI refinement (8), clasificación de comentarios de PR (7) y redacción de respuestas a code review (7).

No lo uso solo para “generar código”. Lo uso para recorrer el ciclo completo: desde implementación inicial hasta responder code reviews.

Dónde se rompe el flujo (y ahí está lo bueno) 🧯

La parte más útil del reporte no fue lo que hice bien. Fue esto:

Buggy Code (13): primeros intentos con type mismatches, props mal usados, errores lógicos.
Wrong Approach (9): construir desde cero cuando el codebase ya tenía el patrón que debía seguir.
Otros: cambios demasiado agresivos, imprecisiones menores.

Sí: los primeros intentos suelen tener errores. Pero el aprendizaje fue claro: mis problemas con el agente no se arreglan usándolo menos, sino dándole mejor contexto.

Cuando el contexto es vago, el agente adivina. Cuando el contexto incluye los tipos correctos y el patrón existente del codebase, converge rápido.

El patrón que me describió mejor de lo que yo lo habría escrito 🪞

/insights identificó mi flujo dominante: delego implementaciones ambiciosas (multi-archivo) y luego piloteo iteraciones hasta aterrizarlas. Los primeros borradores con errores no son un bloqueo; son el costo esperado de ir rápido… siempre que yo esté guiando el rumbo.

Es el mismo enfoque que usaría con un dev junior talentoso: pido un primer borrador ambicioso sabiendo que va a necesitar ajustes, y lo guío con contexto y reglas del repo.

Lo que refuerzo: lo que funciona según el reporte ✅

Tres patrones que quiero mantener:

1) Code reviews con criterio. Distingo bugs reales de comentarios no accionables y respondo con objeciones fundamentadas cuando toca. El agente ayuda a ordenar y redactar, pero la decisión de qué aceptar y qué rechazar es mía.

2) Iteración completa dentro del mismo flujo. Implementación → feedback → fixes → tests. Un dato que me gustó: 86 usos de TodoWrite. Con agentes, el plan también es parte del trabajo.

3) Decisiones guiadas por patrones existentes. Prefiero consistencia del codebase a “ideas nuevas” que suben el costo de mantenimiento. Cuando una propuesta se salía de las convenciones, hice la llamada de reiniciar usando el patrón existente como referencia.

Takeaways que voy a institucionalizar (y medir) 📌

De las fricciones, el reporte sugiere reglas que voy a codificar en CLAUDE.md… Aquí van dos ejemplos:

Pattern-first: antes de implementar una feature, buscar si hay un patrón existente en el codebase y usarlo como referencia.
Types-first: antes de proponer fixes en TypeScript, leer tipos e interfaces relevantes. Cero “adivinar shapes”.

El reporte también sugiere crear skills (comandos reutilizables para flujos repetibles). Por ejemplo, uno para responder code reviews: listar comentarios, clasificar por tipo, proponer fix mínimo, redactar respuesta y verificar build.

Responsabilidad: la parte que no se delega 🧱

Hay una diferencia entre usar agentes y dejar de pensar. Un amigo que es administrador —no dev— construye apps rapidísimo con herramientas de IA. Es impresionante, y su objetivo es que las apps funcionen. El mío es que además sean mantenibles y defendibles.

La herramienta se puede caer (hasta servicios grandes como AWS se caen). Si se cae, yo tengo que poder entrar al repo, entender lo que está pasando y resolver —especialmente en lo que yo mismo metí en mis PRs. El código lo puede escribir cualquier herramienta. Lo que no puede escribir es el criterio para decidir qué código debería existir y cuál no. La IA puede escribir. El ownership no.

Si quieres probar esto sin volverte dependiente 🧪

Si estás en la misma transición, lo único que sí recomendaría (a nivel general) es esto:

Trata la IA como compañero, no como autopilot. Acelera la ejecución, pero tú decides el rumbo.
Invierte en contexto. Los tipos correctos y los patrones del repo valen más que un prompt elaborado.
Después de 2–4 semanas (y si usas Claude Code), ejecuta /insights. No para “validarte”, sino para encontrar fricciones repetidas (y corregir hábitos).
Si estás empezando, a mí me sirvió un punto de partida estructurado: el curso gratuito AI-Assisted Programming by Nebius x JetBrains (lo dejo en créditos).

Qué sigue 🧭

No creo que usar agentes mate el desarrollo. Creo que desplaza dónde está el trabajo valioso: menos tecleo, más criterio, más revisión, más decisiones defendibles.

Mi próximo paso es medir si los ajustes (especialmente pattern-first y types-first) reducen las instancias de buggy code y wrong approach en el siguiente ciclo de /insights. Si los datos mejoran, lo comparto. Si no, también. Para mí, tener feedback con datos sobre mi workflow es oro.

Créditos 🙌

Curso que me metió en esto: AI-Assisted Programming by Nebius x JetBrains
Herramienta en terminal: Claude Code
En mi IDE (WebStorm): JetBrains AI
Foto por Daniil Komov en Unsplash

Claude Code is making me a better dev (and I have the data) 🧠⚙️

Gabriel Porras — Mon, 09 Feb 2026 16:35:38 +0000

“Lately I have seen you take a more active role in PR review and really investigating, catching and detailing issues that come up. This is a big help to the team in my opinion.”

A tech lead told me that after the weeks where I used AI the most to write code. Not less—more. And when I ran /insights—the command that analyzes your Claude Code session history and generates a report on patterns, frictions, and metrics—I understood why.

Quick disclaimer: I’m not affiliated with Anthropic. I use these tools because they work for me, and I’m sharing this because the data might be useful to other devs.

This isn’t “stopping programming”: it’s another stage of the craft 🧬

Software development has always been a chain of abstractions: each leap reduced keystrokes, not responsibility. Agents seem to be the next leap: less typing, more deciding and maintaining.

My setup 🧩

I went from using ChatGPT for quick questions to integrating Claude Code into my daily workflow.

Claude Code (Sonnet 4.5) in the terminal: full implementations, multi-file work, iterative refinement with feedback.
JetBrains AI (with Sonnet 4.5): focused questions in the IDE, PR reviews, specific prompts.

I’m not into what some people call vibe coding: building very fast with AI and iterating until it works, without necessarily digging into the technical “why” behind each decision. I’m into controlled, AI-assisted development: the agent accelerates execution, but I steer. Everything that gets merged goes through my line-by-line review. If something breaks, I’m responsible.

The numbers: what `/insights` says about my real usage 📊

I ran /insights inside Claude Code and got a report covering only my terminal activity over the last two weeks. Note: I’ve been using the tool for months—this report captures just that period.

445 messages in 12 days (≈ 37.1 msgs/day)
+5,867 / −3,088 lines across 61 files
A dominant pattern: Iterative Refinement across 13 sessions

The top two categories of what I asked for were tied: Feature implementation (17) and Bug fix (17), followed by UI refinement (8), PR comment classification (7), and code review response drafting (7).

I don’t use it only to “generate code.” I use it to complete the whole loop—from initial implementation to addressing review feedback.

Where the flow breaks (and that’s the good part) 🧯

The most useful part of the report wasn’t what I did well. It was this:

Buggy Code (13): early attempts with type mismatches, wrong props, logic mistakes.
Wrong Approach (9): building from scratch when the codebase already had the right pattern to follow.
Others: overly aggressive changes, minor inaccuracies.

Yes—first attempts often have errors. But the key learning was clear: my problems with an agent aren’t solved by using it less, but by giving it better context.

When context is vague, the agent guesses. When context includes the right types and the existing codebase pattern, it converges fast.

The pattern that described my workflow better than I could 🪞

/insights captured my dominant flow: I delegate ambitious multi-file implementations, then actively steer through iterations until it lands. Buggy first drafts aren’t a blocker; they’re the expected cost of moving fast—as long as I’m guiding the direction.

It’s the same approach I’d take with a talented junior dev: ask for an ambitious first draft knowing it will need refinement, then guide it with context and repo rules.

What I want to reinforce (according to the report) ✅

Three patterns I want to keep:

1) Code reviews with judgment. I separate real bugs from non-actionable comments and push back when needed with grounded reasoning. The agent helps organize and draft, but the decision of what to accept or reject is mine.

2) End-to-end iteration in one flow. Implementation → feedback → fixes → tests. A detail I liked: 86 uses of TodoWrite. With agents, planning is part of the work.

3) Pattern-driven decisions. I prefer consistency with the codebase over “new ideas” that increase maintenance cost. When a proposal diverged from conventions, I restarted using the existing pattern as the reference.

Takeaways I’ll institutionalize (and measure) 📌

From the frictions, the report suggests rules I’ll encode in CLAUDE.md… Here are two examples:

Pattern-first: before implementing a feature, look for an existing pattern in the codebase and use it as the reference.
Types-first: before proposing TypeScript fixes, read the relevant types and interfaces. No “guessing shapes.”

The report also suggests creating skills (reusable commands for repetitive flows). For example, one for code review responses: list comments, classify them, propose minimal fixes, draft replies, and verify the build.

Responsibility: the part you can’t delegate 🧱

There’s a difference between using agents and turning your brain off. A friend of mine—an administrator, not a dev—builds apps insanely fast with AI tools. It’s impressive, and his goal is for the apps to work. Mine is for them to also be maintainable and defensible: understand them, debug them, and keep them running when something breaks.

Tools can go down (even big services like AWS go down). If the tool goes down, I still need to open the repo, understand what’s happening, and fix it—especially for the changes I shipped in my PRs. Any tool can produce code. It can’t produce the judgment to decide what code should exist—and what shouldn’t. AI can write. Ownership can’t.

If you want to try this without becoming dependent 🧪

If you’re in the same transition, the only general advice I’d give is:

Treat AI as a teammate, not autopilot. It accelerates execution, but you choose the direction.
Invest in context. Correct types and repo patterns matter more than a fancy prompt.
After 2–4 weeks (and if you use Claude Code), run /insights. Not to “validate yourself,” but to spot repeated frictions (and fix habits).
If you’re getting started, a structured starting point helped me a lot: the free AI-Assisted Programming by Nebius x JetBrains course (linked below).

What’s next 🧭

I don’t think agents “kill” development. I think they shift where the valuable work lives: less typing, more judgment, more review, more defensible technical decisions.

My next step is to measure whether the changes (especially pattern-first and types-first) reduce buggy code and wrong approach in my next /insights cycle. If the data improves, I’ll share it. If it doesn’t, I’ll share that too. For me, having data-driven feedback on my workflow is gold.

Credits 🙌

The course that got me into this: AI-Assisted Programming by Nebius x JetBrains
Terminal tool: Claude Code
In my IDE (WebStorm): JetBrains AI
Photo by Daniil Komov on Unsplash

Programming is not coding

Gabriel Porras — Fri, 29 Mar 2024 23:31:45 +0000

Programming is not coding. In the real world, programming is 80% reading code, 20% writing code (15% editing code, and 5% writing new code).

By @dragosnedelcu

Photo by Florian Olivo on Unsplash

The world of Awesome CSS Frameworks

Gabriel Porras — Wed, 12 Jan 2022 02:40:26 +0000

In February 2018 I joined Dev.to 😎 and also I found the amazing Awesome CSS Frameworks. I was in love with all the world that existed apart Boostrap.

I forked that repo and I created my own extensive list, with my style and organized in a way I can search easily the new CSS Framework I'd like to meet.

That way born Gabo's Awesome CSS Frameworks and UI Libraries.

After 4 years maintaining this repo I want to share some info may be interested for Web & React Developers (⭐s from January 2022):

If you need a CSS Framework/Framework

This TOP 5 are very good candidates to work with:

Bootstrap - 155K⭐
Tailwind CSS - 51K⭐
Bulma - 45K⭐
Materialize - 39K⭐
Foundation - 29K⭐

If you are into React

Then the TOP 5 Libs is:

Ant Design - 77K⭐
Material-UI - 74K⭐
Chakra UI - 23K⭐
react virtualized - 23K⭐
React-Bootstrap - 20K⭐ (Oh yeah! Bootstrap is a TOP 5 here too)

Super Star repos with no recent updates

Interesting all the stars with no recent updates:

Semantic UI - 50K⭐ - Last update: October 2018
normalize.css - 46K⭐ - Last update: November 2018
Material Design Lite - 32K⭐ - Last update: June 2017
Skeleton - 18K⭐ - Last update: December 2014 (Wow! Since 2014!)

Do you need a Base/Reset

If I ignore the normalize.css 46K⭐ (because no recent updates), then you can go with:

Pure - 22K⭐
Shoelace.css - 6K⭐
sanitize.css - 4.7K⭐

What if you need a light one

Well, in this case I can recommend you:

Spectre.css - 11K⭐ - ~10KB gzipped
Milligram - 9.6K⭐ - 2kb gzipped!
Water.css - 6.7K⭐ - 3.27 kb
BassCSS - 5.7K⭐ - 2.13 KB

Do you need to create HTML emails

No problem. There are frameworks for you too:

MJML - 13K⭐
Foundation for Emails 2 - Formerly Ink - 7.6K⭐

If you need a unique and special design

You can go with these special frameworks:

NES.css - 18K⭐ - Your web like a NES-style (8bit-like)
98.css - 6.3K⭐ - Like an old Windows
Doodle CSS - 631⭐ - A simple hand drawn theme

From Big companies

Finally, in the Design Systems era, I want to show you the ones from well known companies:

Fluent UI - 13K⭐ by Microsoft
Evergreen - 11K⭐ by Segment
Primer - 11K⭐ by GitHub
Clarity Design System - 6.4K⭐ by VMWare
Carbon Design System - 5.1K⭐ by IBM

A lot of repos to take a look, no?
And these are just a few. In my list you can check a lot of CSS Frameworks and UI Libraries.

Did I miss one? Just comment it so I can fix it.

Cover Photo by Maik Jonietz on Unsplash