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—algorithms, patterns, syntax—the more valuable you were.
That model is breaking down, and fast.
Agentic AI tools—GitHub Copilot, Cursor, Claude Code, and a growing list of others—don’t just autocomplete. They plan, generate, refactor, and test across entire codebases. Given a well-scoped prompt, they produce working implementations in minutes that 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—systems thinker, skeptical of generated output—is not.
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. The kind of project that in the past would have taken many months, required a small team, and carried a real risk of getting 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: defining the architecture, making technology decisions, reviewing generated code critically, catching edge cases the AI missed, and steering toward patterns that would hold up in production. The AI handled the implementation 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 forwards, one step back. A tricky integration, an unfamiliar library, an elusive bug—any of these easily stalls a project for days and erodes the motivation to keep going. Working as a curator, that friction largely disappeared. The satisfaction of watching a complete, working system come together in weeks rather than months is genuinely different from anything I’d experienced in previous development cycles.
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, and knowing when it’s wrong requires real expertise. But the leverage available to a single experienced practitioner operating this way 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. If an AI can generate the boilerplate, CRUD operations, and unit tests, 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. The developer who writes beautiful hand-crafted code in three days isn’t more valuable than the curator who ships reviewed, tested, AI-generated code in three hours.
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.