My experience using LLMs in day-to-day work and how they are changing programming.
A necessary introduction
In recent months, the noise around "programming with AI" and "the end of programmers" has multiplied.\
What's curious is that most of these claims come from people who don't program. It's like to say "we don't need lawyers anymore" having knowledge of how a trial works: it wouldn't make sense or have any rigor.
What is clear is that AIs already act as super accelerators in technical work. What many thought would arrive in one or two years is already happening today. And far from being something to fear, what senior profiles need to do is adopt them now and learn how to integrate them into daily work.
In my case, I code much less than before because my role is now more about management and strategy. However, when I do program, the change has been radical: I'm faster, more efficient, I focus on complex parts and delegate the repetitive work to AI. Form validation, wiring, scaffolding, utility generation... all the things that used to consume time are now solved in seconds.
AI does not eliminate the need for a senior developer. It reconfigures the role: less time writing mechanical lines of code and more time applying judgment, designing architectures, and ensuring quality.
My setup and how I work with LLMs
Before getting into backlogs and code, I start with a key file in my projects: **Agents.md**.
The Agents.md file
This document contains the rules and practices I want the AI to always follow when working with me. It's my "contract" with the machine.\
I base it on previous versions I've tested, but I always update it with the help of AIs like ChatGPT.
Some of the practices I include there:
Don't add comments to the code. The code should be self-explanatory.
Write at least one small test for each new block of code.
Always check against the backlog before closing a task.
Update documentation (README, agents.md) whenever something relevant changes.
Keep style, dependencies, and patterns consistent.
Thanks to this file, every project starts with a solid foundation and with clear expectations of how the AI should work with me.
Backlogs and specification
Afterwards, I use AI to work on backlogs. First I think them through and draft them myself, because that's where human input adds the most value. Then I run them through AIs like ChatGPT or CheckInAI to polish: making them clearer, more consistent, and easier for everyone to understand. This saves a lot of time lost in misinterpretations.
Programming with AI
On the technical side, my setup is simple:
I use a lightweight editor, such as VS Code, without excessive configuration.
I always keep an assistant AI agent running (for example, GitHub Copilot).
This has taken me from coding 100% of the time to coding barely 1--3% in small projects.
When I tackle large tasks with these AIs, it's not as simple as saying "create this infrastructure" and being done. I work with AI as if it were another person: I question what it suggests, give feedback, ask for changes, and push for improvements until I get the result I want. Although they're still not very good at complex refactoring, I do encourage them to refactor very specific small parts. That constant interaction is what makes the difference.
How I distribute tasks by size
Large and small.\
Here AI is very useful:
Large → infrastructure, initial structures, module skeletons.
Small → minor design changes, visual tweaks, button or icon modifications.\
In both cases, I clearly define the task and closely supervise the result.
Medium.\
This is where AI shines the most today.\
I use agents like Codex or Devin AI, which work synchronously and are often described as "junior developers." In my experience, they handle these tasks very well:
Creating a new page based on another.
Adding a simple editor with data import/export.
Maintaining consistent design with the rest of the system.
The most relevant advantage is that I can use these AIs not only while sitting at my computer, but also by leaving them tasks in the background.
I assign a task, go to a meeting, and when I return the branch is ready for review.
I can even leave something running overnight and check it fresh the next morning.
This has brought a profound change in how I manage my time: it allows me to progress in parallel without extending my workdays or accumulating pending tasks.
How I think this will evolve
Although I've said several times that I don't think AIs will replace us, I do believe their evolution will broaden the spectrum of medium tasks.
We can already see that what used to be complex (like validating a form or setting up an importer/exporter) is now considered a "medium" task. And I think this trend will continue:
Very small tasks (especially in Frontend and design) will still need people with great aesthetic sensitivity and user experience skills.
Very large tasks (in Backend, Frontend, QA, data, architectures...) will still require human teams capable of making decisions, integrating systems, and handling growing complexity.
But the range of medium tasks will expand more and more. What we currently see as "difficult" will become "medium," and that's where AIs will play a bigger role.
This means there will be less repetitive or routine programming work, and more human focus on tasks that truly define quality, experience, and the long-term vision of a project.
And if you're not senior?
If you're a junior developer (or don't know how to program at all), the message is different.\
First of all: don't get carried away by the hype. The internet is full of messages whose only goal is your clicks or your money.
What I do consider essential is learning the technical foundations. Just like in math not everyone solves integrals, but everyone knows how to add, subtract, or solve a simple equation, in programming you should learn the basics: logic, data structures, simple patterns.
Today it's much easier to learn than 10 years ago: you have AIs that teach, compare approaches, and correct mistakes. But it's also harder, because technology has become much broader and more complex. That will be one of the biggest challenges in the coming years: learning enough to be productive without getting lost in the flood of tools.
There's also a deeper issue: without junior developers, there will be no seniors in 10 years. AIs are reducing many of the entry-level tasks that used to serve as training. That was the school where future seniors were formed. If it disappears, how will we train the next generation of professionals?
Companies will need to solve this challenge. Training, mentoring, and creating real practice spaces will be key. Because AI can accelerate, but it cannot replace the learning curve that turns someone into a complete professional.
What I think about all this
If you're senior, you should already be using AI in your day-to-day work. Not doing so means missing out on an accelerator that's already here.
If you're junior (or just starting out), learn the fundamentals first and use AI to practice and understand better, not to skip steps.
The future poses a huge challenge: how to train the next generation of developers in a context where entry-level tasks are increasingly automated.
The answer will not be choosing between humans or machines, but learning how to integrate both worlds to keep building together.
Top comments (1)
Spanish version: linkedin.com/pulse/hola-programado...