As I write this, I’m watching a team of Codex exec runs working in tandem and in sequence to build some software I had an idea for. They start with a backlog-mining phase, plan out their own work, create GitHub issues for each piece of work, then another workflow kicks off that starts with a planning phase, after which the coding agent implements the change, the testing agent creates tests, the documentation update agent updates the references, and an agent handles the PR. A whole agentic software development system that churns through the idea, non-deterministic token output at a time, until we get to something that is not only usable but well-architected and maintainable.
This was not possible 9 months ago, and now I really can’t imagine working any other way.
It crept up the way every big change does: slowly, then all at once, and now we are staring at terminals where a synthetic coworker slings code faster than we can type git status. I spent years building a career around being the person who knew the right incantation for a build that only compiled on Tuesdays. That mattered when keystrokes were the bottleneck. Suddenly the bottleneck is imagination, judgment, and whether you can keep a straight face while your job title quietly slides from “software engineer” to “AI systems wrangler”.
I used to introduce myself with whatever stack was fashionable because it signaled competence. .NET if the room skewed enterprise, React if I wanted to get invited to the next JavaScript meet-up, Go if I needed street cred. The industry loved these tribal markers. We got paid to memorize the ever-changing topography of NPM, to know which dotnet flag would make the build behave, to juggle Kubernetes YAML like we understood it. Now the compiler is a language model that doesn’t care about our meticulously curated GitHub stars. It just wants a clear objective and a reasonable amount of guardrails.
Watching this play out now feels like being the drummer in a band that just discovered drum machines. The crowd still wants rhythm, but we suddenly have a whole rack of new sounds to play with. The machine can keep perfect time, and it frees us to experiment with fills, textures, and dynamics we never could attempt while we were busy counting measures. Progress traded some of the muscle memory for creative direction, and that is a swap I can live with.
Day-to-day, that looks less like typing loops and more like building feedback loops. We design prompts so the model stumbles less. We wire continuous integration so it tattles when the machine hallucinates imports. We choreograph agentic AI systems so they can take confident swings at features while we keep them aligned with the boring realities of uptime, security, and customers. The machine can trace through ten branches at once; we are the ones who decide which branch is worth keeping.
Sarcasm aside, the craft isn’t gone. It’s mutating. The best developers I know are leaning into the boring stuff that always mattered but never earned conference talks: understanding the business domain, talking like a human to stakeholders, spotting the edge cases nobody wrote down, reading a log file without needing a Medium post to explain it. These are the things the model cannot hallucinate because they require context, taste, and the ability to notice when a sentence in a spec feels off.
The short-term play is obvious: learn how to pair with these systems the way we learned Git workflows and pull request etiquette. Be the person who can take a mess of half-baked AI output and turn it into something production-worthy without needing a two-week refactor. As these tools grow more agentic, the real fun is figuring out how to hand them intent, context, and constraints so they can explore while we steer.
Five years out? I will not pretend to know the exact milestone chart, but I am more excited than anxious. I keep meeting teams where agents are handling the doldrums of integration testing and release prep, freeing humans to invent products we did not have the capacity to attempt before. I want to be around when the first agent checks in code that carries a user story from intake to production while we oversee architecture and ethics instead of pushing pixels.
So yeah, the shift is uncomfortable. The status perks of being “the dotnet person” or “the React whisperer” are fading. The opportunity is that we get to decide what replaces them. We can choose to be the engineers who understand systems through and through, who can guide an AI partner without losing sight of why the software exists. The code may write itself, but the responsibility still has our names on it, and that is the good part because it means we get to shape what comes next.