For most of my career, you could ask me who I was and I'd answer in five seconds. I'm Miguel. Senior software engineer, full stack, strong backend orientation. Background jobs, scaling, databases, performance. Point A to point B, I'll take you there. I walked into interviews with that answer, and it usually worked.
Ask me today and I hesitate.
Where the answer came from
I started in Venezuela, around 2010. Internet access was limited, so my teachers were books: design patterns, scalability, clean code, naming, readability. I absorbed all of it and applied it to the Java and C++ I was learning at university.
Then, during an internship, someone showed me Ruby and Ruby on Rails. I fell in love. After Java and C++, Ruby felt like writing English. Funny enough, English itself was my weak spot back then. Didn't matter. Code that reads like prose became the standard I held myself to.
That's who I was from the beginning: the guy who cared about readability almost like a craftsman. If the intention isn't clear when you read the code, that's a flag.
Over time, what "craftsman" meant kept changing. First it was readability and naming. Then patterns and architecture. Then performance: requests, caching, SQL, indexes. Eventually it became people, leading teams toward all of the above. I reinvented myself several times without calling it that.
But every reinvention kept me close to the code. The artifact was always in my hands, so I assumed that closeness was my value. Looking back, I'm not sure it ever was. The value was the judgment. The code was just where it showed.
The game that stopped being a game
AI started as a game. We copied from GPT and pasted into the editor. Then Copilot predicted lines for us. Autocomplete became chat, chat became agents, agents became orchestration. Today my work is instructions, skills, and coordinating agents. The pen is gone.
That's what makes this transition different. Readability, architecture, performance, leadership: they changed what I focused on, but not where I stood. Agents move me one abstraction layer away from the artifact itself.
I recently saw Freddy Vega argue that hand-writing code is becoming irresponsible. I hate how much that resonated. I wouldn't make it a rule for everyone, but in my own work, with the leverage available today, deliberately typing every line means choosing the slower tool. And we don't get paid for typing. We get paid for the value we generate.
So if my value was never really the typing, but typing was how I expressed it for ten years, what am I when the typing goes away? For the first time in my career, the five-second answer is gone.
No crystal ball, just repetition
I'm not someone who predicts elaborate agent workflows months in advance. My approach is more boring: I detect a pattern, I turn it into a skill. That's the whole method.
Whenever I catch myself doing the same thing twice with an agent, that's a flag, the same one unclear code used to raise. The repetition becomes a skill. Skills compose with other skills, and the workflow compounds. One example: for years, after finishing a feature, I'd think through the test cases and run them one by one in Postman. Real requests, real user, real database. Eventually I turned that ritual into a skill: it reads the branch diff, figures out which endpoints changed, derives the test cases, and runs them as real HTTP calls. What used to take an afternoon now takes one command. I didn't predict the tool. I simply noticed the repetition.
And building it made something clear. The model can generate the diff. It can run the requests. But knowing that a smoke test only counts if it hits a real endpoint with a real user, knowing which shortcuts it must never take, knowing what "good enough for production" means in this codebase: that came from the years, not from the model. The agent does the work. My experience decides what the work is and when it's done.
These days I spend more time sharpening the system than writing the software. The old me would have called that procrastination. But the workflow gets better every week, and it's mine. It carries everything those books and those ten years taught me. My unit of work used to be the code. Now it's the system that produces the code: context, constraints, skills, feedback loops. The craftsmanship didn't die. It moved.
Who am I, then
I still don't have the title. AI engineer doesn't feel right. Orchestrator sounds ridiculous. What I actually do is judge generated code, build the tools that make it better, and decide what reaches production. I'm the gate between the agents and the users.
And here's the part I didn't expect: one step above the code, I'm finding joy again. I can create faster than I ever could before. It feels less like losing my craft and more like being freed from carrying it line by line.
I spent ten years knowing exactly what I was. I still don't know what to call this version of myself. But someone still has to be the engineer, and for the first time since the agents came, I'm starting to understand what that means.