Someone left an intriguing comment on one of my posts the other day:
“AI doesn’t make one a developer, like a camera doesn’t make one a photographer.”
It’s a good line. It sounds true, and it’s clever. But — as Oscar Wilde put it — “everybody’s clever nowadays.” So let me take it seriously, because I think it’s right, and I think being right about it leads somewhere more interesting than the person quoting it usually intends.
The adage is true. That’s the problem with it.
A camera really doesn’t make you a photographer. But notice the thing the line quietly skips over: every photographer uses a camera. The tool is necessary. It’s just not sufficient. It’s the medium the craft happens in, not a substitute for the craft.
Which means the adage isn’t actually an argument against the tool. It’s an argument that skill matters — and nobody disagrees with that. So the real question was never “does the tool make you a developer?” No tool ever has. The real question is narrower and more useful: is this a serious tool, or a toy?
I’ve watched the profession answer that question before.
I’ve seen this movie
I started out with a text editor and a compiler. You typed your code into a plain editor, ran a compiler at the command line, read the wall of errors it spat back, and tried again. That was the job.
Then IDEs arrived — the all-in-one coding environments with autocomplete, inline error-checking, one-click refactoring, real debuggers. And a certain kind of developer (me, for an embarrassing while) sniffed that anyone who hadn’t suffered through the command-line years wasn’t a real programmer. Real programmers, we said, understood what was happening underneath.
That gatekeeping looks pretty silly now. The IDE didn’t turn bad developers into good ones. It made good developers faster and freed them to spend their attention on harder problems than remembering a compiler flag. The craft didn’t die — it moved up a level.
And it was the same story the rung before, and the rung before that. “Real programmers write assembly, not these high-level languages.” “Real programmers use punch cards.” Every new tool that removed some drudgery got the same eulogy for the craft. Every time, the craft survived and climbed.
So what does make a developer?
There’s an adage for this side too: writers write. But putting pen to paper doesn’t make you a good writer. That takes years of writing, feedback, and quiet contemplation about why one sentence lands and another doesn’t.
Same here. Developers develop. What makes you one isn’t the editor you type into — it’s judgment. Knowing what to build and what to leave out. Sensing that the clever solution will quietly bite you in a year. Reading unfamiliar code and reconstructing the intent behind it. That judgment is earned by doing the work, over and over. It is not installed by a tool.
AI doesn’t hand you that judgment. It hands you leverage. Point good judgment at it and you’re a genuine force multiplier. Point nothing at it and you get a fast, confident pile of plausible-looking mistakes. The tool amplifies whatever you bring; it doesn’t supply it.
The honest worry
Now, the strongest version of the skeptic’s case — and it is not silly, so I won’t pretend it is:
The IDE still made you write the code. AI can write it for you. So a junior can now ship working software they don’t actually understand — and if you can skip the struggle, you might skip the very reps that build the judgment in the first place. No scar tissue, no wisdom.
That’s real. But it’s a responsibility, not a reason to dismiss the tool — because it’s not new, either. Every tool that removed drudgery also removed a place where people used to learn. You understand less about memory when a garbage collector handles it for you; less about raw SQL when an ORM writes your queries. The profession didn’t collapse. It adapted by teaching the next level up, and by being deliberate about where the fundamentals still get taught.
We’ll have to do that again, on purpose: make juniors read and own the code the AI produces, understand why it did what it did, and stay accountable for the result. The tool doesn’t excuse you from developing. If anything, it raises the bar on what “developing” means — less typing, more judging.
That, for what it’s worth, is exactly how we use it here: senior people directing the AI and owning every decision, not juniors hiding behind it. The judgment stays human. The leverage is enormous.
It’s already becoming the IDE
This isn’t a prediction I’m asking you to take on faith. Look at who’s building the tools.
JetBrains — the company that arguably perfected the IDE — just shipped Air, an IDE built from the ground up around AI agents (it runs Claude, among others). They also ship Junie, their own AI coding agent. The people who spent 25 years refining the editor are now rebuilding it around AI, the same way plain editors once got rebuilt into IDEs.
I’ve felt the shift in my own hands. We rebuilt our company site in a weekend. We built a rehab client’s games with Claude — a reusable framework, then five fully-tested games in two days. A friend’s car-sound game that took us four weekends to build got rebuilt in under an hour. In every one, the tool collapsed the mechanical distance from idea to working software. The judgment about what to keep, what to cut, and what “good” looked like was still ours.
Where it lands
So, back to the adage: yes, AI won’t make you a developer. Neither did the IDE, the compiler, or the high-level language. What makes you a developer is the thing it has always been — judgment, earned by doing the work. AI just changes what “the work” is, and how much of it one person can get through.
Give it a few years and “I used AI” will sound about as controversial as “I used an IDE.” The people who thrive won’t be the ones who refused the tool, or the ones who leaned on it to skip the craft. They’ll be the ones who did the reps and learned to point the leverage in the right direction.
That’s the bet we make on every project we take on.