Dejar una herramienta que amabas no siempre es una decisión técnica. A veces es una decisión emocional.
Hay algo incómodo en admitirlo: me enamoré de una herramienta.
No de una persona, no de una idea abstracta, sino de un sistema. De una forma de trabajar. De una sensación muy específica: abrir Claude Code, usar Opus, pedir algo complicado y ver cómo todo fluía.
Durante un buen tiempo sentí que había encontrado “la buena”.
La herramienta que entendía mi forma de pensar. La que me ayudaba a programar más rápido. La que convertía ideas medio revueltas en soluciones reales. La que hacía que el desarrollo se sintiera menos pesado y más creativo.
Y claro, cuando algo te funciona así, pagas.
Yo llegué a pagar el nivel x20 de la suscripción. Y no lo pagaba a fuerzas ni con coraje. Lo pagaba convencido. Sentía que valía la pena porque Claude Code, cuando estaba en su mejor momento, era una locura.
Al principio no había fricción.
Claude Code respondía bien, Opus parecía entender el contexto, los planes salían sólidos, los cambios tenían sentido y el flujo de trabajo era casi adictivo.
No se sentía como usar una herramienta. Se sentía como colaborar con algo que realmente entendía lo que estabas intentando construir.
Y ahí está lo peligroso de estas tecnologías: cuando funcionan bien, uno deja de verlas como herramientas. Empiezan a sentirse como una extensión de tu propio pensamiento.
Te acostumbras rápido.
Te acostumbras a que resuelvan. Te acostumbras a que anticipen. Te acostumbras a que te acompañen en el desarrollo. Te acostumbras a ese pequeño golpe de dopamina cuando algo complejo sale bien en minutos.
Y cuando eso pasa, la herramienta deja de ser solo una herramienta. Se vuelve parte de tu rutina. Parte de tu forma de trabajar. Parte de tu confianza.
Luego algo cambió.
No fue de golpe. No fue que un día Claude Code dejara de servir por completo. Eso habría sido más fácil de identificar.
Fue más sutil.
Una respuesta rara por aquí. Un plan incompleto por allá. Un cambio que no respetaba lo que ya se había hablado. Una instrucción que había que repetir. Una conversación que antes fluía y ahora empezaba a atorarse.
Al principio lo justificas.
“Seguro el modelo anda saturado.”
“Tal vez fui ambiguo.”
“Quizá el contexto ya estaba muy largo.”
“Puede que hoy no sea buen día.”
Pero después deja de sentirse como un accidente y empieza a sentirse como un patrón.
Lo que antes salía en una o dos vueltas ahora necesitaba tres, cuatro o cinco. Lo que antes resolvía con seguridad ahora lo dudaba. Lo que antes parecía entender de inmediato ahora había que explicarlo una y otra vez.
Y lo más frustrante era que mi forma de usarlo no había cambiado.
Mismos proyectos. Mismo estilo de prompting. Misma forma de trabajar. Misma confianza en la herramienta.
Pero cada vez la suscripción me duraba menos.
Aquí es donde tengo que ser muy claro: no puedo probarlo.
No tengo evidencia técnica suficiente para afirmar que esto sea intencional. No puedo decir que alguien se sentó a diseñar el sistema para hacerlo peor a propósito.
Pero sí puedo hablar de lo que sentí como usuario.
Y lo que sentí fue esto: Claude Code empezó a fallar de una forma demasiado conveniente.
Conveniente para consumir más tokens. Conveniente para hacerme repetir instrucciones. Conveniente para alargar tareas que antes resolvía más rápido. Conveniente para empujarme, casi sin decirlo, hacia niveles más caros.
La sensación era rara.
No era una herramienta completamente inútil. De hecho, ese era parte del problema. Todavía tenía momentos brillantes. Todavía podía hacer cosas muy buenas. Todavía aparecía de vez en cuando ese Opus que me había fascinado.
Pero esos momentos eran cada vez menos constantes.
Y cuando una herramienta te da suficiente valor como para no soltarla, pero suficiente frustración como para hacerte pagar más, entras en una dinámica bien peligrosa.
Una mezcla de dependencia y enojo.
La amas cuando funciona. La odias cuando se atora. Y pagas más esperando que vuelva a ser como antes.
Suena exagerado, pero así se sentía.
Como una relación tóxica.
El problema no era únicamente pagar más.
Si una herramienta cuesta mucho pero entrega mucho, perfecto. No tengo problema con pagar software bueno. Al contrario: cuando algo me ahorra tiempo, me ayuda a trabajar mejor y me da resultados consistentes, lo pago con gusto.
El problema aparece cuando el costo sube y la confianza baja.
Porque ahí ya no estás pagando solo con dinero.
Pagas con tiempo. Pagas con paciencia. Pagas con energía mental. Pagas con interrupciones en tu flujo de trabajo. Pagas con esa sensación horrible de no saber si el problema eres tú o la herramienta.
Y para alguien que usa estas herramientas para programar, esa confianza importa muchísimo.
Cuando estás en medio de un refactor, de una arquitectura, de un bug difícil o de una decisión técnica delicada, necesitas que la herramienta sea consistente. No perfecta, porque ninguna lo es. Pero sí predecible.
Claude Code empezó a dejar de sentirse predecible para mí.
Y cuando una herramienta deja de inspirarte confianza, aunque siga siendo poderosa, algo ya se rompió.
Dejar Claude Code no fue una decisión fría.
No fue una comparativa en Excel. No fue una tabla de precios. No fue simplemente “esta opción cuesta menos”.
Fue más emocional que eso.
Lo dejé cuando todavía me gustaba. Cuando todavía tenía cierto cariño por la herramienta. Cuando todavía recordaba lo bien que se sentía usar Opus en sus mejores días.
Pero justo por eso tenía que dejarlo.
Porque en algún punto entendí que ya no estaba pagando por productividad. Estaba pagando por nostalgia.
Por la esperanza de que volviera a ser como antes.
Y no volvió.
Así que un día simplemente dije: hasta aquí.
Lo curioso es lo que pasa después de dejar una herramienta así.
Primero da miedo.
Tienes tu flujo armado. Tus comandos. Tus hábitos. Tus atajos mentales. Ya sabes cómo pedir las cosas, cómo estructurar las conversaciones, cómo aprovechar sus fortalezas y cómo esquivar sus defectos.
Cambiar de stack se siente como romper una rutina muy bien aprendida.
Pero después empiezas a probar otras opciones y te das cuenta de algo importante:
No era magia.
Era contexto. Era implementación. Era experiencia de uso. Era un ecosistema.
Y ahí fue donde entró Ollama Cloud.
Ollama Cloud me sorprendió muchísimo.
La relación calidad-precio me parece extraordinaria. De verdad, no hay comparación con lo que sentía que estaba pagando antes.
Lo que más me gusta no es solo que tenga muchos modelos. Es la libertad que te da para probar, cambiar, comparar y ajustar sin sentir que estás casado con una sola inteligencia.
Puedes brincar entre modelos de forma sencilla. Puedes experimentar. Puedes encontrar qué modelo sirve mejor para cada tipo de tarea. Y eso, para desarrollo de software, vale muchísimo.
Además, la cantidad de implementaciones soportadas oficialmente me parece una ventaja enorme: Claude Code, OpenCode, OpenClaw, Hermes y otras formas de integrarlo al flujo diario.
Eso cambia completamente la relación con la herramienta.
Ya no estás atrapado en una sola interfaz. Ya no dependes de una sola experiencia cerrada. Ya no tienes que aguantar una implementación que te frustra solo porque el modelo de fondo alguna vez te gustó.
Con Ollama Cloud siento que tengo flexibilidad.
Y esa flexibilidad, después de venir de una relación tan desgastante con Claude Code, se siente como aire fresco.
Hoy es una suscripción que planeo mantener por mucho tiempo. No por costumbre, sino porque siento que el valor está ahí. Porque cada peso tiene más sentido. Porque me permite probar, moverme y decidir.
Por otro lado, también empecé a usar ChatGPT con OpenCode.
Y aquí sí tengo que decirlo directo: la mancuerna me ha funcionado increíble.
Para proyectos más complejos, GPT 5.4 y 5.5 me han dado resultados muy sólidos. Pero lo que realmente me sorprendió fue cómo se comportan junto con OpenCode.
La experiencia se siente más estable. Más ordenada. Más útil.
El modo plan de OpenCode, por ejemplo, realmente funciona. Y eso para mí es clave.
No se sale del modo plan a media conversación sin razón aparente. No empieza a ejecutar cosas cuando todavía estás pensando la estrategia. No rompe el flujo de planificación. Hace lo que esperas que haga: ayudarte a pensar antes de tocar el código.
Eso parece básico, pero en la práctica hace una diferencia enorme.
Porque programar con IA no se trata solo de que escriba código rápido. Se trata de que te ayude a tomar mejores decisiones. De que puedas discutir arquitectura, evaluar riesgos, dividir tareas, anticipar errores y luego sí, ejecutar.
Con ChatGPT + OpenCode volví a sentir algo que había perdido:
flujo.
No ese flujo ansioso de “ojalá no se acaben los tokens”. No ese flujo lleno de repeticiones. No esa sensación de estar peleando con la herramienta.
Un flujo más limpio.
Pedir. Planear. Ajustar. Ejecutar. Revisar.
Así debería sentirse el vibe coding cuando está bien implementado.
La lección más importante de todo esto no es que Claude Code sea malo.
Sería injusto decirlo así.
Claude Code me dio momentos buenísimos. Opus, en sus mejores días, era impresionante. Me ayudó a trabajar, a pensar, a construir y a descubrir nuevas formas de programar con inteligencia artificial.
Pero también me enseñó algo más importante:
No conviene depender demasiado de una sola herramienta.
Por muy buena que sea. Por muy cómoda que se sienta. Por mucho que te haya funcionado antes.
Porque cuando una herramienta falla y todo tu flujo depende de ella, no solo pierdes productividad. Pierdes ritmo. Pierdes confianza. Pierdes motivación.
Y recuperar eso cuesta.
También aprendí que la herramienta más cara no siempre es la mejor para ti. A veces solo es la que mejor logró meterse en tu rutina.
Y esa diferencia importa.
Hoy mi forma de ver estas tecnologías cambió.
Ya no busco “la herramienta definitiva”. Ya no quiero casarme con un solo modelo. Ya no quiero depender de una sola interfaz. Ya no quiero pagar por nostalgia.
Prefiero un ecosistema.
Prefiero tener opciones. Prefiero poder cambiar. Prefiero usar Ollama Cloud para experimentar con modelos y mantener flexibilidad. Prefiero usar ChatGPT + OpenCode cuando necesito potencia, planeación y consistencia.
Prefiero tener el control de mi flujo en lugar de sentir que mi flujo depende del humor de una herramienta.
Porque al final eso son: herramientas.
Muy avanzadas, sí. Muy útiles, también. A veces impresionantes. Pero herramientas.
Y cuando una herramienta empieza a costarte más de lo que te aporta, hay que tener la claridad de soltarla.
Aunque antes la hayas amado.
No odio Claude Code.
De hecho, parte de mí le tiene cariño a esa etapa. Fue una herramienta que me enseñó mucho y que durante un tiempo cambió mi forma de trabajar.
Pero también fue una relación que se desgastó.
Primero por pequeñas inconsistencias. Luego por frustración. Después por costo. Y finalmente por pérdida de confianza.
Tal vez nunca sepa si aquello que sentí era una mala implementación, una estrategia de consumo, una degradación real o simplemente una combinación de límites técnicos y expectativas demasiado altas.
Pero tampoco necesito saberlo con certeza para tomar una decisión.
Me bastó con entender cómo me hacía sentir trabajar así.
Y trabajar con una herramienta de IA no debería sentirse como estar rogándole a algo que antes te entendía perfecto.
Hoy estoy más cómodo con mi stack actual. Ollama Cloud me da libertad y una relación calidad-precio muy difícil de ignorar. ChatGPT con OpenCode me da potencia, estructura y una experiencia de desarrollo que sí disfruto.
Y eso, para mí, vale más que seguir pagando por una relación que ya solo me estaba generando coraje.
Al final, no se trata de encontrar la inteligencia artificial perfecta.
Se trata de no olvidar quién debe tener el control.
La herramienta no eres tú. La suscripción no eres tú. El modelo no eres tú.
Úsalos mientras te sirvan.
Y cuando dejen de hacerlo, aunque duela un poquito, cambia de rumbo.
