AI coding tools are now part of daily development. This post honestly examines what skills are becoming more valuable, what's becoming less critical, and how to stay relevant in a world where the AI writes the code.
The code works, so why did I fail? What reviewers actually look for in take-home assignments and live coding sessions.
ChatGPT answers questions. AI Agents plan, use tools, and complete tasks autonomously. Understanding this difference changes how you build with AI.
I actually used all three AI coding tools for real projects. Here's an honest comparison of Copilot, Claude Code, and Cursor.
Converting words and sentences into numeric vectors lets you do math on meaning. From cosine similarity and ANN algorithms to the OpenAI embeddings API, here's everything you need to know.
Honestly, it still happens. I describe a problem to Claude Code or Cursor, and when the AI's output appears, sometimes I think: "that's better than what I would have written."
Especially for boilerplate-heavy tasks. New API endpoints, TypeScript type definitions, SQL query optimization — AI is faster and makes fewer mistakes.
At first I was anxious. "Am I becoming obsolete?" But over time my thinking shifted. AI writes good code, that's true. But AI doesn't know what to write. That decision still belongs to humans.
That gap is what will differentiate developer value going forward.
First drafts: I hand off the first implementation of a new feature to AI. Describe the requirements and you get 80-90% complete code back. Refining that is much faster than starting from scratch.
Me: "Create a Next.js App Router API route that accepts file uploads
and saves them to Supabase Storage. Max 10MB, images only."
AI: [50 lines of complete code]
Me: Review and fill in edge cases
Debugging: Paste the error message and stack trace and it usually finds the cause. TypeScript type errors and CSS layout issues — AI is often faster than me at these.
Reference code: "Show me how to implement a leaderboard with Redis sorted sets" gets an immediate answer. The time I used to spend hunting through docs has largely disappeared.
Refactoring: "Make this function more readable," "Break this component into smaller pieces" — these work well.
Business logic decisions: AI can tell you how to implement something, but not whether it needs to be built. It doesn't genuinely understand your product, your users, or your team's context.
System design: "Microservices or monolith?" isn't a code question. It depends on team size, deployment cadence, domain complexity, and cost. These factors require synthesis that AI can't perform.
Final judgment on code review: AI checks "does this work?" but evaluating whether it fits team conventions, whether it's maintainable long-term, whether it will cause production problems — that judgment still comes from humans.
AI writes the code. But what it means for the whole system, how it interacts with other components — that's human territory.
Example: Ask AI to "add caching" and it writes correct code. But where to apply caching, what TTL to set, what the invalidation strategy should be — only someone who understands the full system can decide.
Developers with strong systems thinking use AI far more effectively. They write better prompts, catch what the AI missed, and evaluate code from a bigger picture.
The ability to precisely define "what needs to be built" is becoming more important.
AI is excellent at solving given problems. But solving a badly-defined problem perfectly gives you a perfectly wrong answer.
When a PM says "users don't understand the dashboard," the right move isn't to immediately start improving the UI. First understand why they don't understand it. It might be a data structure problem. It might be an onboarding problem. AI can't make that judgment call.
As AI raises code output per developer, each developer covers more surface area. That naturally means more interaction with more people.
Explaining why an API is designed a certain way to non-engineers. Laying out architectural tradeoffs for leadership. Giving useful feedback in code reviews. These skills can't be replaced by AI — and as code production accelerates, the ability to explain the decisions behind the code becomes more differentiating.
Implementation-level code gets AI assistance. Architecture-level decisions still belong to people.
These decisions come from experience. And ironically, using AI more means you can accumulate that experience faster — because AI handling implementation lets you ship more projects.
Bluntly, this is the most immediately practical skill right now.
With identical AI tools, the quality of output varies enormously based on how well someone prompts. A good prompt:
Bad prompt:
"Add user authentication"
Good prompt:
"Implement email/password login in a Next.js 15 App Router + Supabase project.
- Supabase client is at /src/lib/supabase.ts
- Using next-intl with /src/app/[locale]/ routing
- On success, redirect to /dashboard
- On failure, show inline error message (no toast)
- Use Server Actions, not Route Handlers
- TypeScript strict mode"
Honestly: some things genuinely are becoming less important.
Syntax memorization: You don't need to remember Python list comprehension syntax or JavaScript array methods off the top of your head. AI answers immediately. Learning a new language by asking AI while building a project is more efficient than reading a grammar textbook.
Is this bad? No. Developers have always used memory aids — comments, docs, Stack Overflow. AI is just a more powerful version.
Routine implementations: CRUD, form validation, standard auth flows, sort/filter logic — AI handles these well. There's less reason to hand-craft them from scratch.
The caveat: this doesn't mean "you don't need to know this." You still need to understand and validate the code AI generates. That requires knowing the fundamentals.
Memorized algorithm implementations: The practical value of "implement an AVL tree from scratch" style skills is declining. The more useful skill is understanding why a particular algorithm solves a problem well.
Morning:
- Review today's issues/tickets (30 min)
- Think through the technical approach — alone, no AI (15 min)
- Ask Claude Code for a draft (5 min)
- Review and modify the output (30 min)
- Write tests (20 min) ← heavy AI assistance here
Afternoon:
- Open PRs / code review cycles
- Work through complex parts in dialogue with AI
- Analyze next issue
AI writes code directly: ~40-50% of the time
Decision-making, review, communication: still entirely human
The biggest shift: implementation is no longer the bottleneck. I used to spend a lot of time figuring out how to implement something and then building it. Now I spend more time figuring out what to build and why.
A concrete example: building a feature that used to take me 3 days now takes 1. But the extra 2 days don't disappear — I use them to write better tests, explore alternative approaches, review more thoroughly, and write clearer documentation. The work expands to fill the quality space that was previously squeezed out by implementation time.
One thing I think about a lot: what does the AI era mean for people starting their careers?
On one hand, the barrier to writing working code is lower than ever. On the other hand, there's a real risk that junior developers skip the painful-but-formative experience of struggling through implementations themselves.
My honest take: the struggle matters, but it doesn't have to be manual struggle.
The goal of writing your own hash table implementation wasn't really to know how hash tables work. It was to develop the problem-solving muscle, the debugging instinct, and the ability to hold a complex system in your head. AI doesn't give you those — experience gives you those.
But "experience" can come from shipping features, debugging production issues, and reviewing code written by AI. The path to expertise just looks different now.
What I'd tell a junior developer today:
| Skill | Before | Now | Direction |
|---|---|---|---|
| Syntax memorization | High | Low | Declining |
| Boilerplate implementation | High | Low | Declining |
| Simple bug debugging | Medium | Low | Declining |
| Algorithm memorization | Medium | Low | Declining |
| System design | High | Very High | Rising |
| Problem definition | Medium | Very High | Rising |
| Technical communication | Medium | High | Rising |
| AI collaboration | None | High | New |
| Code review judgment | High | Very High | Rising |
| CS fundamentals (understanding) | High | High | Stable |
One-line summary: the center of gravity is shifting from "the ability to build" to "the judgment of what to build and why."
Use AI tools aggressively: Avoiding them out of anxiety is how you fall behind. Go deep on Claude Code, Cursor, or Copilot.
Keep the fundamentals solid: You need to understand the code AI generates. Data structures, algorithms, networking, database fundamentals — these still matter.
Study system design: As implementation becomes easier, system design becomes more important. Architecture patterns, distributed systems, data modeling are worth investing in.
Develop communication skills: Writing, presenting, documenting. Boring advice, but these skills become more valuable in the AI era.
Update how you work with AI constantly: Your current workflow might be outdated in six months. Stay open to new tools and approaches.
Build a portfolio that shows judgment, not just code: As AI makes code easier to produce, what distinguishes you is the reasoning behind your technical decisions. Write about them. Talk about them.
Honestly, there is anxiety. Not about AI taking my job, but about whether I'm adapting fast enough.
But then I remember: developers have always adapted. Assembly to C, C to Java, Java to Python and JavaScript. Each transition brought "coding is getting easier, developers will be less needed." Demand went up anyway.
AI will probably follow the same pattern. Easier coding means more people want to build more software, and the value of people who build it well goes up.
The question isn't "will AI make me obsolete?" It's: "how do I redefine my value alongside AI?"