AI and the Changing Craft of the Developer

The process of creating software has never stood still. Go back to the very beginning and you'll find punch cards giving way to terminals, terminals to editors that finished our sentences. Stack Overflow turned the most obscure error into a simple search. Each shift moved the same line a little further: less time spent on the mechanical part, more on the parts that need a person. We adapted, and within a year or two the new tool stopped looking like a tool. It had simply become the new way of working.

AI belongs to that lineage, and it would be easy to file it there and move on. But it reaches a place the earlier tools didn't. A better autocomplete sped up your typing. A model that writes a function, explains a stack trace, or sketches a whole feature reaches the part of the craft we thought was ours alone - the thinking. That's why this shift feels different, and why it's worth being honest about what it changes for the people who work in this field, rather than giving in to hype or dread.

From author to reviewer

The most immediate change shows up in the everyday. You spend far less time producing the first version of things. You describe what you want, something appears, and your attention is already racing to the next question before you've finished reading: is this correct? is the empty case handled? is this really what I meant?

The craft tilts, from writing toward reviewing. From writing every line to rereading lines that arrived faster than you can take them in. For some, it's a relief - the blank page was never the favorite moment. For others, it's a quiet loss, because writing the thing yourself was exactly how you understood it. Both reactions hold up. But one thing is true for everyone: the skill that matters has changed. Judgment - that ability to look at a result that seems correct and know whether it actually is - now weighs more than the ability to churn out a first draft.

And the word that matters here is "seems". These tools have a fluency that sometimes outruns their correctness. The confident, well-presented answer that's wrong on one detail: that's the new trap. And spotting it is real work - work that's all the harder the less you wrote yourself.

Building skill gets harder

This is the part that worries us most - might as well say it plainly. You get good at this craft by struggling with it. You debug something for three hours, you finally understand why it was breaking, and that understanding is yours for good. The difficulty wasn't a flaw in how we learned - it was the engine of it.

AI is very good at removing exactly that difficulty. For someone experienced, it's a lever: they have the judgment to see when an answer is wrong. For someone still building that judgment, the same tool can deliver a working result while quietly skipping the step where understanding forms. You can ship without learning. The danger isn't that juniors become useless - it's that the path from junior to senior, which always ran through earned difficulty, gets foggier. Teams that care about growing their people will have to adapt to this new difficulty.

The lines between roles blur

Software has always been created by more than developers and AI loosens the seams between these roles. A designer can prototype a real, clickable interface without waiting on a developer. A developer can mock up a decent interface without a designer in the room. A product manager can hack together a rough draft to test an idea instead of describing it in a document. Someone on support can pull answers out of a codebase they've never opened.

None of this dissolves the disciplines - taste, system design, knowing what's worth building still take years. But the lines grow more porous, and the ones who'll do best are the people comfortable working a notch outside their lane, who see the others less as gatekeepers than as the deeper expertise you turn to when the rough version isn't enough.

What doesn't change

In the middle of all this, we easily forget everything that stays out of the model's reach.

Understanding the real problem (what a person is actually trying to do, the thing they couldn't quite put into words) stays a human act. AI will build you the thing you asked for; it has no opinion on whether you asked for the right one. Caring about the people on the other side of the screen, sweating the detail no one asked for but everyone feels, knowing which corner you can cut safely and which one will rot everything else: none of that gets automated. It's taste, and taste is still earned slowly.

And responsibility doesn't move. When software fails - when it loses someone's data, charges the wrong card, makes a decision it had no business making - no one accepts "the model wrote it" as an answer. The responsibility stays with the ones who shipped it. This isn't a limit anyone expects to see disappear. It's precisely why judgment matters.

How we see it

We're not anxious about all this, and we're not caught up in the hype either. AI has made some parts of our work faster and others more interesting, and it has thrown into sharper relief the parts that were always the real work - understanding, deciding, caring about the result - precisely because those are the ones that didn't get easier.

The tools will keep changing. They always have. What we owe the people we build for hasn't moved an inch: software that does what they need, created by real people who understood and analyzed those needs. That part is still ours. And we intend to keep it that way.