<< Go back to Posts

Thoughts About Agents




Introduction

I have a background in Machine learning. Yey, I am not a deep learning expert.

I started being interested in LLMs in early 2024: I went to hugging face, downloaded some model that I could run on my computer, like LM Mini for embedding, and Phi-3 for Code generaztion.

In early 2025, I switched of team: I got full access to Openai APIs, and started playing with prompts, tools, and developped applications consummming these APIs.

Around may/june 2025, I started trying to developped a software agent, based on SWE initial agent. It worked for simple tasks, but I didn’t investigated much, as it was only a prototype.

In November 2025, I went to Github Universe Event, introducing me Agent for the first time (I knew about Agent concept, however, I didn’t know about the integration in Copilot).

From Completion to Agents

Discovery

In my company, all developpers have a github copilot licence. Not the most expensive, the one with completion and 300 premium requests.

I was very happy with chat completion, it helped me to write code with less typo, reusing the patterns I have developped so far. I didn’t use the agent mode. I was unaware of it. For me, it was just a “copilot chat” to ask questions, nothing more. Maybe when I got the licence, the Agent mode did not exist.

In November 2025, I went to the Github Universe Summit in Paris. There, we got some talks about “Agents will be your new teammates”, and some broken demo (thanks to the unreliable network of the room).

At the end of this day, my conclusion was two-fold:

  • ” Agent seems to be the new thing.”
  • “Still, agents are uncomplete: you can design a coding agent and a reviewer agent, but you cannot let them work alone”

In the same period, some developpers “hitted” the Github Copilot Premium request limit. It represented 1% of the developpers, so not that much. So, I give it a try, to test how “useful” it can be.

Playing with Agents

The first time I openned the Agent window, I was like “What can I ask ? I know what I need to do, but it is minor edit here and there, so it is difficult to specify that”.

After some trials, I found out how to ask and what to ask. The “what” comes with practice. The “how” is easier to get, it is more a question like “how to comply with the tool limitation”:

  • Always provide the context: This could be by writing your specs in a markdown file, or providing the class the agent needs to use in your script.
  • Be specific: About the libs, the expectation, the do and don’t

The World is Changing

From my sampling point of view, very few developpers already use agents, within Github copilot, Cursor, or Claude Code. They are still asking their question to ChatGPT (the free version), nothing more. They haven’t tested yet agents, and so are not willing to pay for a Claude Code subscription to more than $100.

From a rough estimate, I would say that only 5% of the developpers are using Agents for coding.

Coding with Agents is different:

  • We do not want coder anymore, i.e., people typing on their keyword one letter at a time that makes sense to the compiler or the interpreter at the end of the day. Agent code better than you, they are faster, make less typo, handle more exception.
  • We need software developper: people able to convert high level requirements (from PO or others) into coding directions. More an architect than a pure developper.
  • Software developper needs to developp “management skills”. No one is born manager. This means several things:
    • Learning how to ask / how to specify a task so that the outcome of the agent is predictable
    • Understanding what are the Agent capabilities (where they are good at or not, the level of abstraction they can handle alone)
    • Learning to delegate, i.e., even they know they can do the job alone, they should learn when to keep it for them and when to delegate the jon to Agents

Learning how to Replace Ourselves

Computer science grows in a way it goes from more abstract concepts:

  • We got assembly
  • We got compiler and C
  • We got garbage collector, with no need to handle memory
  • We got high level languages making the language easy to read, easy to write
  • We got libraries for anything, making easy to interact with bluetooth, LLMs, without the need to understand all the complexity (we still need a basic understanding of the process happening yet)

Now, we got LLMs and Agents. We need to figure out how to use.

This year, I was pretty happy to learn how to play with CI/CD. Thanks to that, I gained a lot of time. I also learned to adapt my code so it fits in a docker to be built by Jenkins. The tool did not adapt to me. But in the end, I gained a level of automation, that I will add in my home projects.

Software Developper will not Disappear

  • You can vibe code a tool easily with no coding knowledge at all. Yet, you still needs some knowledge to run the tool, integrate it, do additional configuration. We need people to make the bridge between code, network, database and other.
  • When the code base increase, you can still ask an agent to do the job. However, this will be more costly, as agent will need to read your files, and figure out what to do. Getting someone able to read the code, able to organize it, this person can point out to the agent which files it needs to look at, edit, so making it efficient
  • Without human guidance, agent will take decisions, that will make the final product better or not, more efficient or not. At some point, we need someone able to manage the ship, to guide it so it always stay safe from the rocks.

Yet, their number might decrease a bit.

This might be related to “bullshit jobs” at some point. Programming job with no extra value.

Github Copilot VS Claude Code

Pricing

First, there is a difference of Pricing.

  • GC is per request: The agent limits is action to 25 iterations. At the end, you need to put a new coin in the machine
  • CC is per token: The agent has no incentive to stop quickly. You pay for what you consummed (ok, you have “global subscription”, but you have some limit of tokens per 5 hours).

This single difference makes the way we work with both different.

  • With Copilot, I am more likely to add details about the file it should read, the files it should edit, the test it shouldn’t write, so I efficiently use the 25 iterations.
  • Claude Code is more autonomous: I give it a task, maybe a few pointers, and it will run until completion.

UI

Next difference is User Interface:

GC is integrated into VSCode:

Pro:

  • we see the code edits, we can accept or reject, we see precisely the edit that has been done
  • we can run multiple agents simultaneously

Cons:

  • The debrief of the agent is in a very small font. Difficult to read, so I never take a look at that.

Claude Code runs directly in the terminal:

Pro

  • We are involved in the choices, giving our comments to the agent so it is guided in the correct direction
  • We need to review the code changes, so we know what are the edit made

Cons

  • When an edit has been made, it is difficult to rollback, plus it may impact other files

>> You can subscribe to my mailing list here for a monthly update. <<