This article is a personal account. It doesn't aim to establish a universal method, but to document a shift in how I work with AI agents.
For several months now, I've been using AI agents daily to build my projects.
Over the past few months, I've seen MCP (a protocol connecting an agent to external tools/data), skills, loops, autonomous agents, third-party plugins arrive...
I integrated them gradually into my way of working.
And yet, a few days ago, something clicked.
Not because a new feature was released.
Not because a new model came out.
Simply because I started assembling these building blocks differently.
Tools... each in its own role
At first, each tool had its place.
GitHub Projects was where I tracked progress.
Issues represented the tasks.
Over time, I also noticed that, in my experience, design discussions flowed more naturally on web platforms, while CLI agents excelled at execution.
Looking back, I think the tools simply reached a level of maturity that let me use them differently.
I moved naturally from one to the other.
But in my mind, they remained separate tools.
The shift
Then, while working on a new project, I wanted to try a different approach.
Instead of jumping straight to execution, I used the web platform (via its GitHub connector) to think through the project and generate the first Issues.
Those Issues then fed the Project, while the agents took over on implementation.
That's when something changed.
I realized I was spending more time watching the Project than waiting for the final result.
I was following the project's reasoning.
And above all, I could step in before it went too far in a direction that no longer suited me.
That happened, for instance, when the agent was about to build an admin interface.
Looking at the Project, I stopped.
Why build this interface at all?
A few minutes later, the answer became obvious.
It was meant... for me.
To operate the project.
But did I still need that interface?
Thinking it through, I realized I'd rather collaborate directly with the agent through an MCP than build an interface solely meant to administer the project.
The idea wasn't bad.
It just no longer fit the way I work.
A shared workspace
That's when it clicked.
I was no longer simply chatting with an LLM (the language model behind the agent).
I wasn't just delegating development to an agent either.
I felt like we were operating in the same workspace.
Conversations were for thinking things through.
Issues formalized decisions.
The Project gave an overview.
The agents executed.
And I could observe, arbitrate, redirect.
I no longer discovered the result once it was done.
What this shift changed
I don't know if this way of working is new.
It probably isn't.
Others have certainly had this realization before me.
But I notice that, until now, I was mostly looking at the tools themselves.
Today, I'm starting to look at how they connect to one another.
And that's not the same thing.
The GitHub connector was the trigger for this reflection.
But looking back, I don't think GitHub is really the point.
Tomorrow, it could be GitLab, Gitea, or any other platform offering the same level of integration.
What I take away from this is less about the tool than about the method.
I no longer interact with agents the same way.
I now feel like they work within the same environment as me.
That distinction may seem small.
To me, it profoundly changes how I approach building software.
I'm not presenting this as some universal truth.
It's simply the story of a shift.
The moment I realized the tools hadn't changed.
It was the way I assembled them that had evolved.
And I don't think I'll look at these tools the same way again.
For me, this shift is recent. And I have the feeling it's only the beginning.