Over the Christmas break I built an iOS app.
I’m a front-end engineer. Web stuff. JavaScript. I hadn’t touched Swift or Xcode in my life. And yet, there I was, shipping a working iOS app with complex workflows in a couple of days.
Holy shit.
I did it with Claude Code (think ChatGPT, but it lives in your terminal and writes code directly in your project). And here’s what I didn’t expect: I was genuinely enjoying myself.
Not the performative “I love my job” kind. The real kind. The 2am-and-I-don’t-want-to-stop kind. Somewhere along the way, between the meetings and the maintenance and the endless context-switching, I’d lost that feeling.
I found it again.
And yes, this is the part where I’m supposed to freak out. To feel replaced. To question my career choices.
But I don’t (I did for a while, though).
The existential crisis
Developers are having a rough time lately. I’ve seen the tweets, the Reddit threads. “Am I obsolete?” asked the worried. “What’s the point of learning anymore?” asked the cynics. “We’re all fucked.” (that was me, after the third beer).
I get it. I do. It’s disorienting to watch something do in seconds what took you hours. It feels like the ground is shifting.
And yet.
What if AI just reveals what was always true?
What if it doesn’t change what software development is about, but makes it undeniably visible?
Think about it. The goal of software development was never writing code. Code is a liability, not an asset. Simplicity is essential and hard. It’s about feedback loops, not typing speed. Even Claude Code’s own creators admit that the best way to use AI is to give it a way to check that everything works: tests, feedback loops.
AI makes this undeniably, visibly true.
You can now produce code at 100x speed. So what? If you don’t know what to build, you produce garbage faster. If you can’t simplify, you produce more complex garbage. If you don’t understand the problem, you produce sophisticated wrong things.
The “existential crisis” is only a crisis if your identity was “I know syntax” or “I can produce code fast.”
If your identity was “I solve problems”, nothing changed. Except now you have a very powerful tool.
The 10%
Someone on Reddit put it perfectly: “90% of my skills are now useless but the other 10% are now 10000x more valuable.”
That 10% is:
- Knowing what to build (and what not to)
- Taste. Recognizing when something smells wrong.
- Simplicity. AI loves to over-engineer. Someone needs to say no.
- Security, quality standards. The AI doesn’t care, you do
- Talking to stakeholders, understanding context
- Knowing when to trust the output and when to override it
That’s not new. That was always the job. We were just too busy writing hieroglyphics.
(By the way, if you’re a PM or designer reading this: yes, this list looks a lot like your job description. You’ve been doing “the 10%” all along. Welcome to the club, engineers.)
The art thing
I read an analogy that stuck with me: the best artists know the rules and when to break them. Art that follows all rules is boring. Art that breaks all rules is chaos. The magic is in between.
Same with AI-assisted coding. Without fundamentals, you’ll get either derivative (all rules) or broken (no rules). Your expertise lets you navigate the middle.
Back to my iOS app. I moved faster because I knew which shortcuts were safe and which would bite me later. When Claude suggested a singleton for state management, I knew that was a red flag. When it generated a 200-line function, I knew to push back. When the data flow felt tangled, I could articulate why before things got worse.
Could someone without that background have built something? Sure. But they wouldn’t know what they don’t know. And that’s where the real cost hides.
The tool was Claude. The judgment was me.
The honest part
Look, I’m not naive. More code supply might mean less demand for “coders.” If one developer can now do what three did, the market might need fewer of us. That’s a real concern, and I don’t have a clean answer.
There’s also the junior pipeline problem. The 10% comes from somewhere. You build taste by writing bad code, feeling the pain, and learning. If juniors skip the reps and jump straight to AI-assisted coding, where does the judgment come from? I don’t know.
But I do know that the market wants problem-solvers, not coders. For people who understand outcomes over outputs. For people who can talk to stakeholders, exercise judgment, figure out what’s actually valuable.
AI can’t do that. Not yet.
So
I don’t have all the answers. Nobody does.
But the fundamentals (simplicity, feedback loops, outcomes over outputs, small increments) seem more true than ever. Not less.
The 10% that matters is the 10% that was always the job. Now we just see it more clearly.
So if you’re wondering what to do with that clarity: double down on the 10%. Get better at knowing what to build. Get better at saying no. Get closer to the problems you’re solving and the people you’re solving them for.
The rest? Let the machines handle it.