For most of software history, being a good developer meant being good at writing code. The mental model was simple: business requirement → developer writes code → software happens. The better you were at the craft, the more valuable you were. Algorithms, patterns, syntax—those were the currency.
That model is breaking down, and fast.
Agentic AI tools don’t just autocomplete. GitHub Copilot, Cursor, Claude Code, and a growing list of others plan, generate, refactor, and test across entire codebases. Give them a well-scoped prompt and they produce working implementations in minutes. The same work would have taken a developer hours. The bottleneck has shifted.
The Curator Mindset
A curator doesn’t create from scratch. They select, evaluate, contextualize, and arrange. That’s increasingly the job of a developer working with agentic AI. The value isn’t in the keystrokes. It’s in:
- Problem decomposition: Breaking a business requirement into prompts that actually produce the right output
- Critical evaluation: Knowing when the AI’s output is subtly wrong, insecure, or architecturally bad
- Context management: Understanding the codebase well enough to guide the AI toward patterns that fit
- Integration judgment: Deciding what gets merged, what gets thrown away, and what needs human rewrite
The code jockey—fast typist, strong syntax recall—is being automated out. The curator is not. Systems thinking and skepticism of generated output are what survive.
I Built This Firsthand
I recently designed and shipped a cloud-based email sync service from scratch. Backend services, web application, containerized deployment on Google Cloud—the works. In the past, a project like this would have taken many months. It would have required a small team. And there’s a real chance I’d have got lost in the implementation details somewhere around month two.
I built it in weeks. With minimal actual coding.
Claude Code served as my development resource and best practice advisor throughout. I worked at the curator level. I defined the architecture and made technology decisions. I reviewed generated code critically, caught edge cases the AI missed, and steered toward patterns that would hold up in production. The AI handled the heavy lifting. I handled the judgment.
What struck me most wasn’t just the speed—it was what the speed felt like. In traditional development, progress ebbs and flows. Two steps forward, one step back. A tricky integration, an unfamiliar library, an elusive bug—any of these can stall a project for days. Motivation erodes. Working as a curator, that friction largely disappeared. Watching a complete system come together in weeks rather than months felt genuinely different from anything in my previous development experience.
That’s not an argument for skipping rigor. I still reviewed every significant piece of generated code. I still caught things that would have caused production problems. The curatorial discipline matters enormously. The AI doesn’t always get it right. Knowing when it’s wrong requires real expertise. But the leverage available to a single experienced practitioner today is unlike anything that existed a couple of years ago.
What This Means for Teams
The ratio of senior to junior developers in a well-functioning team is going to shift. AI can now generate the boilerplate, CRUD operations, and unit tests. So what does a junior developer do? They either develop curatorial judgment fast, or they stall.
Senior developers who resist agentic tools out of craft pride are also at risk. Writing beautiful hand-crafted code in three days is no longer a differentiator. The curator who ships reviewed, tested, AI-generated code in three hours delivers more value.
The Risks Nobody Talks About Enough
Agentic AI generates plausible code. It doesn’t generate correct code by default. The failure modes are insidious:
- Security vulnerabilities that look fine on review
- Race conditions in async code that only surface under load
- Business logic errors that pass unit tests but fail edge cases in production
The curator’s most important skill isn’t knowing how to prompt. It’s knowing what to be suspicious of. That requires deep domain knowledge, security awareness, and production experience. Exactly what doesn’t come from training on Stack Overflow.
The Bottom Line
If you’re a development leader, your hiring criteria need to evolve. Look for judgment, not just craft. Look for people who ask the right questions, not just people who write the right code.
The code jockey era isn’t a distant memory just yet. But I for one won’t long for it once it is.