The way I am working in 2026

I have more than twenty-five years of engineering experience, and I have never felt as empowered as I do now with AI.

The way agents work today is a blessing. I do not believe AI will replace us, but I do believe it will expand what we can do. It gives us the ability to achieve things that were not realistic before, at least not with the same speed, precision, and confidence.

At my company, I often give talks about how to use AI. One comparison I use is modern CNC machining.

Before CNC machines, engineers worked with lathes and more manual processes. Now, with CNC, we can create complex parts with extreme precision, and we can program the machine to do exactly what we need. That is how I see AI today. It is not magic. It is a tool that helps us work with more precision, more efficiency, and more creativity.

The AI tools I use today

These are the tools I currently use:

• ChatGPT Plus. It costs me around $20 a month.
• Claude Code. It costs me around $200 a month.
• GitHub Copilot, which I still use from the pre-ChatGPT era. It costs me around $10 a month.
• Codex. It comes with my ChatGPT Plus account.
• My own local AI setup, which I am still building. I want to run models locally, but I am still in the early stages.

My engineering workflow

In the past, because of time constraints, I rarely spent more than a day doing proper research before starting a project. I relied on my own experience and on advice from friends or colleagues. Most of the research happened while I was already building. That worked, but it was slow. Many problems appeared along the way. Now I start every project with deep research. Before I write the first line of code, I want a functional document that explains the entire project: the requirements, the expected outcomes, and the main decisions that need to be made.

I usually spend around five days on this, when it comes to a full project, and a day or two when it comes to a feature. I do not like missing details. I question the AI about every part of the project until I feel I understand what needs to be done. I also read a lot of official documentation before committing to a solution. For product and business research, I like using ChatGPT's Advanced Research tool. For technical research, I usually use normal ChatGPT because it lets me have a more detailed back-and-forth about the technical side of the project.

Planning the architecture

Once the initial research is done, I start another round of research: where to begin, which technologies to use, and how to structure the code.

For this, I still use ChatGPT with a high-reasoning model. I ask for recommendations, best practices, architecture options, code snippets, and debugging advice. I use it to discuss the design of the application in depth.

The output is usually a detailed plan in Markdown. That plan includes:

• The technologies I will use.
• The structure of the codebase.
• The main phases of the project.
• The order in which the work should be done.
• The reasoning behind the most important decisions.

This plan usually takes around three days to create. I prefer to spend more time here and start with a solid foundation. The plan is also designed to be executed in phases, so I can focus on one part of the project at a time and keep the quality high.

Setting up the project

When the plan is ready, I create the Git repositories and set up the development environment. I use AI agents to automate part of this process. They can create the folder structure, initialize the repository, and install the required dependencies. This saves time, but it also helps make sure the project starts with the right structure. This setup usually takes around a day. I want everything configured properly before coding begins. The agents I currently use for this are Claude Code, Codex, and Copilot. Yes, I pay for all three. But I do not start any serious coding task until I have a complete .agents/ folder with detailed instructions.

Tooling matters

Tooling is the second most important thing I do in a project. I want every project to be easy to set up, check, test, and deploy. Over the years, I have created many Makefiles. They are simple, practical, and very useful. I use the same pattern across my projects, and the best part is that AI agents can use those commands too.

One thing I have learned is that agents often overcomplicate terminal commands. They use Unix commands with too many flags, install packages that are not needed, or spend too much time solving simple problems. Some tasks can be done with a basic Bash command, but for some reason, agents often want to use Python.

I also do not want to remind the AI all the time to respect Clean Architecture principles. Even when the rules are written down, agents can still make mistakes. So now I use a make architecture command to check if the generated code respects the architecture rules defined in the .agents/ folder.

This is an example of the output:

Architecture validation report
Checked files: 990
Violations: 0

Rule summary:
- enforce-layer-dependency-direction: 0
- enforce-env-loader-boundary: 0
- enforce-domain-framework-purity: 0
- enforce-application-framework-independence: 0
- enforce-repository-specificity: 0

No architecture violations found.
➜  project-backend git:(refactor/academia)

Mastering Makefiles is definitely a useful skill. Thanks to AI, I have also improved my knowledge of Unix commands, flags, and configuration files. These small details make projects move much faster.

One of my Makefile commands copies the content of multiple files into a single output. This is useful when I want to paste code into ChatGPT for review. Since I build the prompts and plans in ChatGPT, I can provide the project tree and the output of a command like this:

make copy-paste FILES="..."

That gives the AI enough context to review the code properly and give useful feedback. I never blindly trust that an agent followed the plan correctly. I always review the output. But when the setup is good, the fixes I need to make are usually small.

The .agents/ folder

Before coding, I spend time setting up the .agents/ folder. This is crucial for me.

My first experiments with agents, back in 2023, produced terrible results because my prompts were not detailed enough. I ended up spending more time fixing the agent's code manually than reviewing what it had generated.

Now I use the .agents/ folder to describe the project rules in detail:

• The architecture.
• The technologies to use.
• The coding style.
• The boundaries between layers.
• The rules the agent must follow.

This gives the agents a clear understanding of what is expected. The output becomes much more accurate and much better aligned with the project.

This process usually takes around two days. It may sound like a lot, but it saves time (and money) later. Not everything that shines is gold, so sometimes I still need to review and update those rules during the project. But having them from the beginning makes the development process much smoother.

My typical project workflow

This is how I usually work on a project now:

• I start a new chat in the specialized GPT I created for that project.
• I provide the functional document and the project plan, including the technologies, codebase structure, and timeline.
• I generate a prompt for the agent to execute one part of the plan.
• I make the prompt detailed. I include the necessary context, instructions, requirements, and constraints. I do not want agents to be creative.
• I go to my Zed editor and start Claude, Copilot, or Codex CLI.
• I ask the agent to execute the prompt.
• I use Sonnet 4.6 with Claude and GPT-5.5 for the rest. The main reason is token usage. Claude tends to burn more tokens, so I use it for the most complex tasks and use the others for more straightforward work.
• Communication with the agents is minimal. They tell me when they are done. No summaries, no recaps, no explanations, no planning mode. Just execution.
• I review all changes in Git.
• I go back to GPT, paste the changed files, and ask for a code review.
• Sometimes I use /skills to ask for specific code reviews.
• If AI suggests valid improvements, I make the changes manually in the codebase or I let the AI to build a prompt to mend the work.
• I test, check and compare results.

This workflow is working very well for me.

Some people rely on agents for everything: planning, execution, and review. I split the work. ChatGPT handles planning and review. Claude, Copilot, and Codex handle execution. This saves money, gives me more control, and helps me avoid AI bias. So far, the results have been consistent, fast, and high quality. Sometimes I do not even need coding agents. ChatGPT alone is enough to complete the task.

The best part is learning

The most positive part of this workflow is learning.

My head is full of new knowledge. I have learned deep concepts across many of the languages I work with: Golang, Rust, C, C++, Python, JavaScript, TypeScript, and others.

When I do not understand something, I ask. If the explanation is not enough, I keep going. I challenge the AI on the topic. I force it to research. Sometimes I even ask it to write a small test to check whether a concept is clear, performant, and efficient.

Now I feel that no programming language is really a problem for me. I can start new projects in new languages and understand most of the concepts without depending completely on AI. I can apply new ideas, question existing patterns, and challenge the current state of a language.

That is the biggest change for me in 2026.