Claude Code daily: why it won't replace software engineers
Several months of intensive Claude Code use on production code. What it really changes, what it doesn't replace, and why the job mutates rather than disappears.
My current usage
I code with Claude Code 80% of the time. Not as a demo: it's in my daily flow on client projects in production.
The split between what goes to Claude and what stays on my keyboard is sharp:
| Delegated to Claude | Kept for me |
|---|---|
| Scaffold a component or API endpoint | Deciding what we build, and especially what we don't build |
| Write tests for existing code | Scoping a project with a client |
| Explore an unfamiliar codebase ("where is auth?") | Debugging a subtle production bug |
| Mechanical refactors (rename a type everywhere) | Choosing an architecture for the next 18 months |
| Migrate a file from one API to another | Assessing acceptable technical debt |
| Writing the code that requires taste |
What really changes
The relationship with time. A scaffolding task that took me 2 hours (read the docs, copy-paste, adapt, test) now takes 15 minutes: I describe what I want, Claude generates it, I review, I adjust, I commit.
The barrier to trying things, too. Before, "attempting a refactor" cost 4 hours. If I wasn't sure of the outcome, I didn't do it. Now it costs 30 minutes: I try, I see, I revert if it's bad. So I try more often. And sometimes the refactor I wouldn't have attempted was the right one.
First-line debugging. For an error message I've never seen, Claude is often right, or points me in the right direction. Faster than Google. But it plateaus quickly: on truly novel or contextual bugs, it makes things up.
What it doesn't replace
The classic trap: "Claude writes the code, so the job disappears". This confuses the job with its most visible part.
The real engineering job is:
Understanding what needs to be done. A client tells you "I want a dashboard". The good engineer translates that into: "OK so 3 views, these 5 KPIs, but actually what you want to measure is X, and for that maybe you don't need a dashboard at all". Claude has no business context. It codes what you tell it.
Knowing what NOT to do. More than half of a senior's work is saying no. No to the feature that creates 6 months of debt. No to the over-engineering. No to the hyped tech we don't need. Claude, by default, says yes to everything. Ask for 12 levels of abstraction on a 4-line function, it'll deliver them.
Holding system coherence over time. On a 6-month project, choices made in week 2 have consequences in week 24. Claude sees the current session, not the project's history, not the real reasons behind that architectural choice made 4 months ago.
Deep debugging. The bug that only happens in prod, under load, on Tuesdays. The memory leak that appears after 3 days. The race condition that only reproduces with a specific timing combination. Here, Claude is useful for exploring, but the final diagnosis requires patience, intuition, and deep system knowledge. Not an LLM.
Communication. A dev with no communication is expensive. The job includes: aligning with a non-tech client, pushing back on a bad request, explaining a trade-off to a PM, negotiating a deadline, writing a post-mortem. None of those moments is code.
Three concrete examples from this month
| Case | Situation | Verdict |
|---|---|---|
| Shined | Jest → Vitest migration across 80 test files | 20 min vs. half a day. Mechanical patterns, ideal ground for the tool |
| Stalled | n8n workflow firing twice in cascade | 4 logical fixes, all off-target. Cause was in the UI (duplicate trigger), not the code |
| False friend | Token generation, tests green, code clean | Used Math.random() instead of crypto.getRandomValues(). Without review, that was shipping |
The real shift
The job isn't disappearing. It's moving.
| Before | Now |
|---|---|
| Typing | Critical review |
| Boilerplate | Architecture |
| "How to write this" | "Why write this" |
| Syntax questions | Trade-off questions |
It looks like what a senior did 10 years ago, except now they do it 3x faster, and they're expected to ship things that used to require a team.
What should still worry us
Honest: not everything is rosy for the profession.
| Who | Effect | Response |
|---|---|---|
| Juniors | The simple work where we used to learn (CRUD, glue code) is now automated | Consciously seek situations of active learning, don't watch Claude do it |
| "Throwaway code" companies | Higher code-to-engineer ratio, fewer positions for the same output | No magic answer, this is real job displacement |
| Non-adapting engineers | Market closes for "type-everything-myself" profiles | Learn to direct the tool, don't compete with the machine |
The dependency in the making
A point we forget when glorifying the tool: you'll always need someone who understands what the AI produces. Not to type it themselves, but to review, validate, debug and catch what goes off the rails.
Vibe-coding works as long as three conditions hold:
- You stay on simple things
- The model stays cheap
- Nothing breaks in prod
On all three, I have serious doubts going forward.
On price. Today Claude Code is essentially free (USD 20/month for generous usage). That's a classic acquisition strategy. Anthropic and the others aren't losing money out of charity: prices will rise. When intensive usage costs USD 200 or 500/month instead of 20, many will have to choose between keeping paying or relearning how to code. Those who never really learned will have a knife to their throat.
On maintenance. An AI-generated app runs on day one. Six months later, a dependency drops, an API changes, an edge case appears. If you can't read what's inside, you ask the AI again, which generates a patch you validate with crossed fingers. Three iterations of that and the codebase is unmanageable. You can't maintain it, migrate it, or host it elsewhere.
On independence. For every line you didn't understand, you transferred a bit of power to the AI provider. The day it changes its terms, its prices or its model, you have no plan B. That's not a partnership, that's dependency.
The engineering job isn't just "knowing how to type code". It's knowing how to read, understand, debug, refactor, hand over. These skills are built by doing, not by watching the AI do it for you. Today's vibe-coders shipping fast and clean are building up a knowledge debt that will be very expensive to repay.
My practical rule
For each task, I ask myself: is this code to produce or a decision to make?
| Task type | Decision |
|---|---|
| Code to produce | I delegate, I review, I commit |
| Decision to make | I make it myself; only afterwards Claude turns it into code |
Delegate the decisions to Claude, and you get code that works today but will be unmanageable in 6 months.
Conclusion
Claude Code is the most powerful tool I've added to my flow since Git. But it's a tool. It amplifies a senior engineer by a factor of 3 or 4. It doesn't replace a senior engineer with a junior + Claude.
The part of the job that consists of typing lines will shrink. The part that consists of deciding, scoping, understanding, integrating, maintaining and communicating, that is to say 80% of the job, is intact. And it now demands more relative time, because we've freed some up on the rest.
The job isn't dying. It's moving up a level.