Handcrafted Code in 2026?

Mar 14, 2026

Creating something with your own hands has a value that’s hard to explain. It’s very similar to what an artist feels when finishing a piece of work.

The Current Moment

It’s impossible not to talk about LLMs in an era where we have impressive tools like Claude Code, Antigravity, Cursor, and others like them.

In recent years, we’ve moved from models that merely generated code snippets to tools capable of reading, modifying, and navigating entire projects. Today, many of these agents can analyze files, suggest structural changes, and implement complete features.

In many cases, they cease to be mere assistants and begin to act almost like other developers within the project.

Given this, many fears and anxieties arise about where we, as developers, fit into this evolution and what the future of the profession will look like.

The Current Reality

Today, it’s hard to deny that LLMs can already perform tasks that have long been part of many developers’ daily work.

CRUDs, simple APIs, and relatively common integrations can be generated in minutes. Of course, there are important nuances, context, well-structured prompts, edge cases, and agent limitations, but that is not the focus of this article.

The main point is that much of the code that previously represented individual value for the developer can now be produced by tools at an impressive speed.

Perhaps the code itself is ceasing to be the main differentiator.

How this changes the developer’s work

This change isn’t necessarily negative.

For a long time, I struggled with productivity when it came to actually writing the code. In many situations, I already had a very clear abstraction in mind, but it took me a considerable amount of time to turn it into an implementation.

It wasn’t uncommon for a feature to be delayed due to a certain perfectionism: the attempt to implement exactly what I had imagined. I’ve already discussed this in the article Purism and Pragmatism.

With agents taking on a large part of the coding, my focus shifts to aligning the abstraction well and clearly communicating the intent, so that the model can implement what is necessary.

On the other hand, there is also a less comfortable side to this change. For those who enjoy the feeling of building something manually, delegating parts of the work to an agent may feel like a loss of control.

Still, I see this mainly as yet another adaptation to the tools emerging in the field.

A New Level of Abstraction

In fact, the history of programming has always been marked by new layers of abstraction.

Structures like if, for, and while emerged to prevent developers from having to deal directly with jump statements like goto. Later, frameworks emerged to prevent each team from having to reinvent common solutions.

Each new layer allowed developers to focus less on the mechanics and more on solving the problem.

AI agents seem to represent yet another step in this same direction.

They optimize a skill that not all programmers had: writing code quickly. As a result, the developer’s role tends to shift to higher levels of the system.

Rather than just writing code, we’ve started to focus on:

• understanding the problem
• architectural decisions
• technical trade-offs
• the behavior of the system as a whole

In other words, the work is becoming increasingly conceptual.

What to study in the age of AI?

If this interpretation is correct, an inevitable question arises: what’s worth studying now?

In my view, areas such as:

• software architecture
• system design
• understanding business rules
• technical decision-making

tend to become increasingly important.

This does not mean that fundamentals cease to be relevant. On the contrary: understanding code remains essential, including for evaluating what developers produce.

But looking at the big picture, the ability to think in terms of systems tends to become much more decisive than simply mastering framework X, library Y, or language Z.

A Caveat About the Hype

At the same time, it’s impossible to ignore the level of hype surrounding these tools today.

We’re constantly bombarded with content suggesting that AI agents will replace much of the work done by developers.

But there’s one aspect of this conversation that’s rarely discussed: how these tools are actually offered and used in practice.

When using software like Antigravity, for example, we usually have limited monthly quotas. Even when paying for Google AI Pro, I quickly hit the usage limit on some personal projects.

From that point on, there are basically two options left: wait a few hours to continue using it or pay for a more expensive plan.

In other words, using agents intensively can still be quite expensive.

Unless you’re willing to pay a few hundred reais a month, your ability to code manually will still be extremely useful when your quotas run out.

And that’s without considering that the real cost of these tools may become even more apparent in the future.

Is it still worth writing “handcrafted” code?

In my opinion, yes.

I’ve always enjoyed the feeling of building something from scratch. I remember back in college when I created a small interaction with a cannon using C++ and OpenGL. It was an extremely memorable experience.

More recently, I felt something similar while developing a mod for Hytale. Working directly with the game’s mechanics, experimenting with ideas, and tweaking system behavior was a clear reminder of why I love programming.

This kind of experience is hard to replicate when everything is delegated to an agent.

Creating something with your own hands has a value that’s hard to explain. It’s very similar to what an artist feels when finishing a piece of work.

That’s why, even if you use AI agents to boost productivity, it’s still worth setting aside some time to build things manually.

In addition to deepening your understanding, the experience of creating something on your own remains deeply rewarding.