Every day a new AI appears — new models, new features, budget cuts here, fewer tokens there… and with that, a lot of people start wondering where all this is going. For juniors, they say there are no more job openings. For seniors, they say it won't be long before there aren't any either. Lots of "blah blah blah." These days, AI is the new JavaScript: every day a new library, "the best one," "the revolution."
But let's get into it.
The principle of AI is the same as frameworks. If you know programming logic, any other language has a smaller learning curve. This is the same territory. If you know the fundamentals, it doesn't matter whether you'll use Copilot, Codex, Claude, all of them together or separately — you can adapt.
In the previous article, I talked about how I felt the first time I used Copilot. And today, clearly, our way of working has changed. We're going through a technological evolution.
Every day we see an influencer claiming they haven't written a single line of code in months. And somehow, that creates a certain FOMO — especially for those just starting out.
And many think: "Does it even make sense for me to learn this, if AI does it for me?"
So, little grasshopper, I'm going to explain this with analogies, and I hope that by the end of this article you'll understand some AI fundamentals, step out of the hype, and start truly understanding this new world.
After reading, drop your insight in the comments. I really want your feedback. Enjoy.
Imagine a head chef.
She needs to serve 80 people. But there's a small detail: she doesn't know how to cook. She knows how to make instant noodles… and that's it. Bless her heart. haha.
So she hires a junior chef. And the first order comes in: a chocolate cake.
The junior asks:
— Does the cake have flour? Yes.
— Does it have eggs? Yes.
— Does it have chocolate? Yes.
— Does it have garlic? Yes.
— Does it bake at 400 degrees? Yes.
She fully trusts that junior. After all, he boils water like a pro… so baking a cake should be easy, right?
And that's exactly the point, little grasshopper: if you don't know how to do it, how are you going to run a kitchen you're responsible for?
That's why it's so important to know how to code, understand fundamentals, have seen many different coding contexts, and already fixed plenty of bugs before delegating anything to an AI.
AI doesn't replace understanding — it amplifies execution.
When you use AI without a foundation, you become that head chef: someone who approves everything without any criteria. You don't know what's right, what's wrong, what's efficient or dangerous. Because AI doesn't think. It predicts patterns.
Without a foundation, you become a hostage. With a foundation, you become a multiplier.
And in a scenario that changes every day, another question arises: what if the machines go down?
In the end, the question isn't whether AI will replace you. The question is: do you know how to work without it?
Because whoever understands what they're doing uses AI as a shortcut. Whoever doesn't… uses it as a crutch. And a crutch doesn't hold anyone up when the ground shifts.
If the challenge used to be knowing how to code, now it's something else: do you know how to orchestrate intelligence?
Because today it's no longer just about writing code. It's about coordinating agents, defining context, controlling execution, and knowing exactly what to delegate.
And that's where concepts like skills, agents, subagents, MCP, worktrees, hooks come in…
If these names sound complex, relax — at their core, they all solve the same problem: giving structure to something that, on its own, just improvises.
Back to the kitchen.
Now imagine that, in addition to the junior chef, she has an entire automated kitchen: robots that chop, bake, plate dishes, and even suggest recipes.
It sounds perfect… until you realize that someone still needs to: decide who does what, organize the order of tasks, and validate the final result.
That's exactly what we're doing today with AI.
Now this chef did things differently. She studied. She tested recipes at home. She failed dishes, burned others, adjusted seasonings. Over time, she stopped just following instructions and started understanding what she was doing. She built a repertoire.
And in the middle of that process, she realized that the chaos in the kitchen wasn't a lack of recipes. It was a lack of connection.
Each supplier, for example the flour supplier, brought something different.
Some flour already came with baking powder mixed in, another had higher protein content. Others absorbed more water.
Even following the same recipe, the result was never the same.
She realized that each flour supplier had its own protocol. The egg supplier, another one. The ordering system, yet another. And each tool with its own standard.
So she thought: what if I created a standardized ordering system? A single protocol where every part of the kitchen operated on the same standard. Suppliers, stations, tools, inventory — all integrated through the same system.
She called it MCP Delicious — no more translating between systems. The system already bridged everything.
And that's exactly what we technically call MCP.
The MCP, or Model Context Protocol, is the structure that organizes how AI operates. It allows AI to stop just responding… and start operating within a system. It can access real tools, retrieve data, interact with APIs, and execute tasks based on a defined flow.
In practice, as presented in the Copilot documentation, these connectors allow AI to integrate with external systems, real data, and real functionality — going far beyond text-based responses. Without it, AI responds with what it "thinks." With it, AI works with what it "accesses."
〔AGENTS〕
You already understand the kitchen. Now you need to understand who works in it.
The agent is the cook. Not the one who just executes orders — the one who makes decisions. It receives an objective, analyzes the context, chooses which tools to use and in what order, and executes. If something goes wrong along the way, it adjusts.
In practice: you say "prepare dinner for 30 people." The agent doesn't wait for you to list every step. It decides what to do, uses what's available, and delivers the result.
That's what sets an agent apart from a simple prompt: it doesn't respond. It operates.
〔SKILLS〕
To operate well, the agent needs abilities.
In our scenario: knowing how to make a sauce, how to chop an ingredient properly, how to bake a cake to perfection. These are reusable capabilities.
In AI, skills are specific abilities that combine instructions, context, and access to tools to solve tasks. But what does that mean in practice?
Starting from a prompt like "given a repository, analyze the commit history and identify performance bottlenecks." The agent doesn't need you to explain everything from scratch — it loads the skill that encapsulates the how: which tools to use, which context to load, which format to deliver. You define it once. The agent reuses it.
In GitHub Copilot, for example, you can configure custom instructions that work like skills: specific guidance on how the agent should behave in certain contexts, which tools it can trigger, and what response format to deliver. Because having every recipe in the world is useless… if nobody knows when to use each one.
〔SUBAGENTS〕
And when the kitchen grows, another need emerges. You can't have everyone working in the same space. It becomes chaos.
And here's a detail that seems obvious but isn't: a subagent isn't a different kind of entity. It's an agent. The difference lies in the role it plays and the specialty it develops.
That's where subagents come in — the specialists.
One handles desserts, another handles sauces, another handles finishing. Each one takes on a specific part of the process. They don't do everything. But they do one thing very well.
In practice: imagine you have a main agent responsible for deploying an application. It can trigger one subagent to run the tests, another to check for security vulnerabilities, and another to document the changes. Each subagent has its own scope and the main agent simply orchestrates the results.
In GitHub Copilot in agent mode, this is reflected in the ability to chain tasks: the main agent breaks a complex objective into subtasks and delegates them, waiting for results before proceeding. This increases output quality because each part is handled with focus, not with generality.
〔WORKTREE〕
And as the operation grows even further, you need organization.
The kitchen is no longer just one space. It starts having separate stations. Each one with its own context, its own prep, its own timing.
A dish can be created from scratch at one station while another is being finished at a different one — without interference.
That's worktree.
The concept comes from Git. git worktree is a feature that allows you to have multiple checkouts of the same repository in different directories at the same time. In practice: you can be fixing a critical bug on the hotfix branch while developing a new feature on feat/new-screen, without needing to stash anything, without switching branches, without the risk of mixing up context.
But real quick:
A branch is like a parallel line of work. You "copy" the project at a given moment and can make changes without touching the main version. It's like creating a separate version just to test or develop something new.
A stash is like temporarily saving changes. Imagine you started something, but you need to switch tasks: you "store" those changes without finishing them and can retrieve them later exactly where you left off.
In the world of AI agents, the concept is the same: context isolation. Each agent (or subagent) operates in its own workspace, without interfering with what the other is doing. It's working in parallel without breaking what already works.
In the end, none of this is about isolated technology. It's about structure.
Because whoever just uses AI requests. Whoever understands, organizes. And when the scenario changes — because it always does — whoever depends on it freezes. Whoever understands, figures it out.
And being completely honest: I'm also still learning. This world is new to me, to you, to everyone.
The difference isn't who already knows everything. It's who is trying to understand while everything is still being built.
But the truth is, this is still just the beginning. We talked about structure, agents, context, and organization. But there's still one important piece of this kitchen missing: what makes all of this work on its own.
Because up until now, there's still someone deciding every step. And when you scale that… you don't just want to organize. You want to automate. You want the system to react, make simple decisions, and keep running without you having to intervene all the time.
And that's exactly where hooks come in. But that… is a topic for the next article. 👀
〔CONCLUSION〕
Before you go: what you just read isn't science fiction theory. It's the real skeleton of how AI-powered systems organize themselves today.
MCP as a connection structure. Skills as reusable abilities. Agents as orchestrators. Subagents as specialists. Worktree as context isolation.
Each of these concepts solves a specific problem, and together, they form the foundation of any AI system that goes beyond "chatting with a bot."
If you understood this, you're already ahead of a lot of people who are still debating whether AI will or won't replace developers. While they argue, you're learning.
See you at the next commit.
References
If you want to keep diving deeper, here are some of the materials I used as a foundation:
Mentorship with Pedro Lacerda
GitHub Copilot documentation (agent customization): https://docs.github.com/en/enterprise-cloud@latest/copilot/reference/customization-cheat-sheet
Model Context Protocol (MCP) – Anthropic: https://www.anthropic.com/news/model-context-protocol
Top comments (0)