I'm writing this at the end of October 2026, between JSConf México in Guadalajara and a run of Devin meetups across Mexico. It feels like the right moment to look back, because this month closed a loop: CityJS Athens, JSConf México, and a calendar of community events that took me from Venezuela to Berlin, Athens, Madrid, and a dozen Latin American cities — all in the same year I stopped writing most of my own code and started directing agents that write it for me.
That's the transition I want to be honest about in this post.
The twenty years before the agents
I started writing code in 2006. The path since then ran through agency work in Venezuela and Chile — shipping sites for clients like Lollapalooza Chile and Banco de Chile — then technical leadership, then almost five years at Globant on problems that don't fit in a blog post: a global entertainment company's design systems, the payments flow of a parks business, and rebuilding a major airline's web experience leading a team of 10+ engineers.
What that era taught me, compressed: software engineering is a coordination discipline wearing a technical costume. The hard problems were never the React — they were keeping conventions coherent across teams, versioning shared contracts, reviewing enough code to keep the architecture honest, and making decisions that survive your departure. I wrote about that in detail in my post about design systems and microfrontends.
In 2025 I said "yes" to a talk at CaribeConf and accidentally discovered the thing I was missing: community. Ten cities, seven countries, three Platzi courses later, I became a Windsurf ambassador — now Devin ambassador — for Latin America, and spent 2026 taking agent-assisted development to meetups, workshops, and conferences on three continents.
What building with agents actually taught me
Here's the thing about being an ambassador for AI coding tools in 2026: you can't just talk about them. So I started building the event experiences themselves with the tools.
- Caritas, the 16-bit selfie wall — a dozen event variants, ~290 AI portraits at WeAreDevelopers Berlin alone, ~$35 in generation costs.
- Fracer, a live multiplayer racing game — a first playable version in about an hour with SWE-2, then days of human polish, then 98 simultaneous players in Lima.
The lessons that kept repeating:
1. Implementation got cheap; judgment got expensive. An agent writes a Socket.IO game loop faster than I can type the function signature. What it can't do is tell me whether 98 simultaneous players will break the starting grid — that took me knowing what to look for. My twenty years didn't become less relevant. They became the review layer.
2. Reliability is where the demo ends. Every one of my event apps worked live because I distrusted them appropriately beforehand: adversarial review of state machines, input validation, the paths where "plausible" code quietly fails at the edges. Productivity headlines measure the generation; the reliability work happens in verification — and nobody writes keynotes about that part.
3. Fundamentals compound. Context windows, tool use, structured outputs, cost models — I teach these in my Platzi courses, and every workshop confirms it: the engineers who get the most out of agents aren't the best prompters, they're the ones who can read a diff and know what breaks in production.
Why multi-agent collaboration keeps pulling at me
In Athens I gave a talk about coordinating human teams on shared frontends — bounded contexts, versioned contracts, review as propagation of conventions. On the flight home it clicked: I'd spent the month watching coding agents drift into exactly the failure modes my talk described. Two agents touching the same codebase produce the same inconsistencies five teams produce — uncoordinated conventions, duplicated abstractions, silent contract violations — just faster and at smaller scale.
I don't have results here. What I have is a hypothesis born from an odd resume: the organizational patterns we developed for human teams might be a starting point for supervising agent teams — ownership boundaries, explicit interfaces, review gates, drift detection. Whether that analogy holds under real scrutiny is a research question, and it's the one I want to spend my next years on: how can autonomous coding agents collaborate on complex software while staying reliable, accountable, and meaningfully supervised by humans?
I know what I bring to that question — two decades of shipped systems, team leadership at scale, a year of daily hands-on agentic building, and a classroom's worth of evidence about where developers' mental models of agents break. I also know what I don't bring yet: formal research training, evaluation methodology, rigor. That's exactly why I want to learn it properly.
What stays constant
Two things I keep coming back to in every city:
First, community is the force multiplier nobody can automate. Every event — a vibeathon in Lima, a meetup in Montevideo, a congress in Berlin — is a room full of people trying to figure out the same transition I'm going through. Teaching them what I've learned and hearing what they've tried is the fastest feedback loop I've ever had.
Second, the deeper AI gets into our workflow, the more the job looks like what it always secretly was: specify clearly, verify honestly, own the outcome. The tools changed the speed. They didn't change the responsibility.
See you at the next event — I'll be the one projecting a QR code.