My AI journey: from ChatGPT in 2023 to the creative chaos of 2026

When I opened ChatGPT for the first time, back in 2023, I had no idea I was starting to switch professions without switching job titles.

I stayed a "dev." But what it means to be a dev changed completely over the next three years.

This post is the map of that transition: the tools, the leaps, and — more importantly — what was missing in each one that pushed me toward the next.

2023 — ChatGPT: the first "this changes everything"

In the beginning it was just a text box. I'd paste an error, ask for a regex, drop in a snippet of docs to translate.

Useful, but a disconnected oracle: it couldn't see my code, my project, or my terminal. I was the human copy-paste machine in the middle.

Even so, it was immediately clear the bar had moved. The question stopped being "can I build this?" and became "how fast can I build this?".

Around the same time I started using Grok and Gemini as parallel chats — less for code, more for research, comparing answers, and getting out of the bubble of a single model.

2022–2024 — GitHub Copilot: AI living inside the editor

Before Cursor, my in-editor AI was GitHub Copilot — and I rode it for about two years. It moved the assistant out of the browser tab and into VS Code: ghost-text autocomplete that finished the line, the function, the obvious next block while I typed.

That alone killed a lot of the copy-paste back-and-forth with ChatGPT. But Copilot's window was narrow: it mostly saw the open file and a bit of nearby context. It was a brilliant autocomplete, not something that understood the project.

Mid-2024 — Cursor: the whole repository as context

The jump to Cursor is what shattered the copy-paste ceiling for good.

Suddenly the AI could see the entire repository. And the exact moment I got how powerful that was happened on the Switch Care project: migrating components and the UI library in a React Native app.

That kind of migration is usually an archaeological nightmare — you burn days just mapping what exists, who uses what, where each component is coupled. With Cursor, we mapped fast and migrated fast. What would have been a multi-week task force became a matter of days.

That's when it really clicked: AI isn't supercharged autocomplete. It's a context lever.

And it wasn't only my own enthusiasm pushing me. Back in 2024 I heard a boss say, on a project, that anyone who didn't use AI to be 20x more productive would be out of the market. At the time it sounded like pure hyperbole. Looking back, the direction was right even if the number was a slogan: the bar for what a single person is expected to ship had moved, and there was no going back.

January 2026 — Claude Code: from editor to agent

Cursor taught me to code with AI inside the editor. Claude Code taught me to code by delegating to AI.

The difference is subtle on paper and brutal in practice. I stopped piloting every line and started describing goals — letting the agent run commands, read files, open PRs — and reviewing the result like someone reviewing another person's work, not someone typing it all out.

It was the first time the terminal became the primary interface again. Going back to the terminal after years of GUIs was strangely liberating.

February 2026 — Pi.dev: betting on more than one model

Right after came Pi.dev, and with it the habit of running the same task across more than one agent.

The lesson here wasn't about a specific tool — it was about no longer being monogamous with a single agent. Different models have different temperaments: one is better at refactoring, another at exploring, another at writing from scratch. Running tasks across more than one and comparing became routine.

April 2026 — Conductor: many agents at once

Conductor changed the unit of work. It's no longer "me + one agent." It's me orchestrating several agents in parallel, each in its own isolated workspace, attacking different fronts of the same problem.

The feeling shifts from "programmer" to tech lead of a team that never sleeps. The bottleneck is no longer typing code — it's deciding what's worth doing and reviewing well what comes back.

August 2025 — multimodal enters the scene

Alongside this coding evolution, from August 2025 onward multimodal became part of the work, not a garnish.

I started genuinely generating image and video — Nano Banana, Veo, Luma, ComfyUI for local pipelines. Post covers, thumbnails, visual prototypes, social assets: things that used to depend on third parties or hours in an editor now ship in minutes.

Generating is the easy part. The real work moved to art direction — knowing what to ask for, what to reject, and which version is actually good.

2026 — the year of building the best workflow

And here we reach the present, which is a glorious mess.

Today my core is Claude Code + Codex, running Opus and GPT-5.5 — with the habit of always reaching for the best model first. But I'm still building the workflow that's perfect for me, and 2026 is the year to explore deep: harness, orchestration, skills, Hermes, OpenClaw, and whatever shows up next. Test a lot of things, but always shipping something of value along the way.

What changed is even the nature of what I test. As a full-stack dev, my concern was trying out frameworks and libraries. Now it's agents, tools, models — cloud, local, VPS, all at once. It's a different board.

Because that's what 2026 is about: the year of building the best development flow of my life.

The "VS Code + a thousand extensions" style did its job, but it's behind us now — and, thank God, let's evolve. The tools keep consolidating, and the foundation is finally solid enough that we can stop patching and start redesigning.

The emotional cost (that nobody puts on the roadmap)

I won't romanticize it: bring on the anti-anxiety meds for this much change.

Tool fatigue is real. Every week there's a new agent, a new model, a new paradigm. It's easy to feel perpetually behind, perpetually re-learning, perpetually migrating.

But the alternative — stopping — is worse. So the choice is to adapt, win, and live through this change. Not as a victim of the tide, but as someone learning to surf it.

And there's the counterweight I can't lose sight of: the very thing that brings anxiety is what makes it exciting. But easy does it. Life outside the machine matters more — family, my kid, people. In the end, it's technology to solve people's lives, not technology to solve technology.

What I take from this journey

• The tool matters less than the posture. At every leap, what really changed was where I put my attention: less typing, more direction.
• Context is the lever. ChatGPT with no context → Copilot inside the editor → Cursor with the whole repository → agents with a terminal and PRs. The whole evolutionary line is about giving AI more context.
• Don't marry a tool. Use several, compare, let the best one win for your case.
• Art direction and review are the new core skills. Generating became a commodity; judging well did not.

From 2023 to 2026, I didn't change careers. But the person who opened that first chat and the one orchestrating a team of agents today are, in practice, two different professionals.

And the best part? The journey is only just beginning.