Every developer has a moment where the tools they use start to change how they think about the job itself. For me, that moment didn’t arrive all at once — it was a gradual shift that started with a simple autocomplete plugin and ended with me handing entire tasks off to an agent that can read, write, and run code on its own. This post is a look back at how that journey started.

Where it began: GitHub Copilot

Like a lot of developers, my first real contact with AI-assisted coding was GitHub Copilot. It slotted quietly into the editor and did one thing well: finish the line, or the function, I was already writing. No conversation, no context beyond the open file — just fast, often surprisingly accurate suggestions that saved a lot of typing.

At first I treated it the way most people do: a smarter autocomplete. Boilerplate got faster to write, repetitive patterns got shorter, and I stopped reaching for Stack Overflow quite so often for syntax I’d simply forgotten. It was useful, but it was still fundamentally a tool that waited for me to lead.

The shift: getting curious about what was actually happening

The more I used Copilot, the more I started wondering about the model behind it — what it could and couldn’t reason about, where it broke down, and why. Autocomplete is a narrow window into a much bigger capability, and it was obvious the underlying models could do more than finish a line of code if you gave them a way to.

That curiosity is what pulled me away from “AI as a plugin” and toward AI as something you actually talk to and direct — not just a suggestion engine sitting in the margin of the editor, but a collaborator you could hand a problem to and describe in plain language.

Moving to Claude Code

That’s what eventually brought me to Claude Code. The difference from Copilot wasn’t incremental, it was a change in kind. Instead of predicting the next few tokens in a file, it could:

  • Read across an entire codebase to understand context, not just the open file
  • Plan a multi-step change before touching anything
  • Execute commands, run tests, and check its own work
  • Iterate — see that something failed and fix it, without me re-prompting for every step

That’s the point where “AI assistance” turned into agentic programming for me. The unit of work stopped being a line or a function and became a task: “fix this bug,” “add this feature,” “refactor this module” — with the agent working through the steps, checking its own results, and looping back when something didn’t work.

What actually changed in how I work

A few concrete differences stood out once agentic coding became part of the daily workflow:

  1. From suggestion to delegation. With Copilot I was still driving every keystroke. With Claude Code I describe an outcome and review the result, closer to working with a very fast, very literal junior developer than typing with a smarter keyboard.
  2. Context matters more than syntax. The bottleneck isn’t “does the AI know the right function name” anymore — it’s whether it has enough context about the codebase, the intent, and the constraints to make good decisions.
  3. Verification becomes part of the loop. An agent that can run tests and read the output closes the loop itself. That’s a fundamentally different trust model than an autocomplete suggestion you eyeball before accepting.
  4. The interesting problems moved up a level. Less time spent on mechanical typing, more time spent on framing the problem well, reviewing the actual change, and deciding what “done” means.

Why this is just the start

Calling this “the start” of an AI journey rather than a conclusion is deliberate. Copilot showed what autocomplete-plus-AI looks like. Claude Code showed what happens once an AI can act, not just suggest. Both were stepping stones to a way of working that’s still very much evolving — and this blog is where I plan to keep tracking what changes next: new workflows, new failure modes, and the things agentic tools are still bad at.

This post is the marker for where that journey started. The posts that follow will dig into the specifics — what agentic programming looks like day to day, where it saves real time, and where it still needs a human paying close attention.