The Developer Identity Crisis
What AI Changes, How to Adapt, and What Comes Next
Full disclosure: This post was written by a human (me), polished by an AI (it fixed my grammar and made me sound smarter), then reviewed by me again (to make sure the AI didn't make me sound too smart). Any remaining errors are 100% organic, artisanal, human-made mistakes.
Many developers ask one question now: “If the AI writes the code, what am I?” Some people ask it aloud. Most people ask it quietly, alone, after a long day.
I ask it too. I started to write software more than 25 years ago. This post is my honest answer. It explains why the change hurts, what you can do about it, and what I think the future looks like.
The Question That Many Developers Ask
For most of my career, my value was clear. I knew how to write code that other people could not write. I knew the syntax, the frameworks, and the strange bugs. Clients paid for that knowledge. My identity grew around it.
Now an AI agent writes a full feature in ten minutes. It writes the tests. It reads the stack trace and repairs the bug. Sometimes it does the work better than I do. After 25 years, that is a strange feeling.
The question is not only about money. It is about identity. When a skill is part of who you are, a machine that does the skill attacks more than your job. It attacks your sense of self.
What Changed, and What Did Not Change
We must be accurate about the change. Hype makes people afraid. Fear makes people make bad decisions.
AI agents do these tasks well
- Write code from a clear specification.
- Write unit tests and repair tests that fail.
- Read a large codebase and find the files that a change must touch.
- Translate code from one language or framework to a different one.
- Write documentation, database migrations, and boilerplate.
AI agents still have problems with these tasks
- Identify what the customer really needs.
- Make good trade-offs when the requirements are not clear.
- Know which risks are acceptable for this business.
- Keep a large system simple for many years.
- Accept responsibility when the system fails at 3 AM.
The first list is about output. The second list is about judgment. The cost of output falls to almost zero. The value of judgment increases.
This pattern is not new. Compilers removed assembly language from most jobs. Frameworks removed much of the plumbing. Cloud platforms removed the server room. Each time, developers said: “This is the end of our profession.” Each time, the number of developers increased.
I do not say that this time is the same. This change is faster and larger than the others. But the pattern is a good place to start.
Why It Hurts: Five Losses
The identity crisis is not one feeling. It is a group of five different losses. When you know which loss you feel, you can do something about it.
1. You lose the craft
Many of us love the act of writing code. We love the flow, the clean function, and the test that turns green. When an agent writes the code, that pleasure becomes smaller. You become the reviewer of work that you did not do.
2. You lose status
For many years, the developer was the person with the answer. Now a product manager asks an agent and gets an answer in seconds. The answer is not always correct, but it is fast. Your special knowledge is less special.
3. You lose the career path
The old career ladder was clear: junior, mid-level, senior, staff. Each step needed more years of practice. Now the lower steps are not stable. Many companies hire fewer junior developers. Nobody knows how a new developer gets ten years of experience when agents do the first five years of work.
4. You lose financial security
Some companies use AI as a reason to make their teams smaller. Some of these cuts come from real productivity. Some are only a story for investors. Both types of cuts cause fear.
5. You lose control of the code
When you write code, you understand it. When an agent writes 2,000 lines in one hour, you do not understand all of it. You feel like a passenger in your own codebase.
These losses are real. Do not let anyone tell you that the feeling is foolish. But a feeling is not a forecast.
What a Developer Really Is
The crisis comes from a wrong definition. We said: “A developer is a person who writes code.” That was never fully true.
Think about the best developers that you know. Their value was not the speed of their typing. They understood the problem. They said no to bad ideas. They made systems that other people could change. They stayed calm during an outage. They accepted responsibility.
Code was the medium. It was never the product. The product was a system that works and that people trust.
A better definition
A developer is a person who changes a problem into a system that works, and who is responsible for that system.
With this definition, AI does not remove the developer. AI removes the slowest part of the work. The responsibility stays with a human. Somebody must own the result.
I wrote about this difference in Vibe Coding vs Vibe Engineering. An agent can make code that looks correct. An engineer makes sure that it is correct.
How to Future-Proof Your Career
You cannot stop the change. You can choose your position in it. These eight strategies make your value grow while the cost of code falls.
1. Learn the fundamentals more deeply, not less
Some people say: “You do not need the basics now. The AI knows them.” I think this is the most dangerous advice in our industry.
You cannot review what you do not understand. Learn data structures, networks, databases, security, and how operating systems work. When the agent makes a subtle mistake, this knowledge is how you see it.
2. Move from tasks to outcomes
A task is “add a field to the sign-up form.” An outcome is “get 10% more sign-ups.” Agents do tasks very well. Businesses pay for outcomes.
Ask why each task exists. Measure the result after you ship. Then tell people about the result, not about the task.
3. Learn to write good specifications
The quality of the agent output follows the quality of your input. A vague request gives a vague result.
Write clear goals, limits, examples, and acceptance criteria. Good architects always had this skill. Now it is the main skill.
4. Become an excellent reviewer
Your new job is often to read code, not to write it. Read for security, edge cases, performance, and simplicity.
Agents like to add code. A good reviewer removes code. Tests and type checks help you, but they do not replace your judgment.
5. Learn a business domain
General programming knowledge is now cheap. Domain knowledge is not cheap.
A developer who understands healthcare billing, logistics, or insurance law is very difficult to replace. The agent can write the code. It does not know which rule the auditor will check next year.
6. Learn to operate agents
Think of agents as a team that you manage. Give each agent a clear task. Give it tools, context, and a way to verify its work.
Learn about evaluations, guardrails, cost, and the ways that agents fail. Soon, “I manage a team of agents” will be a normal line on a resume.
7. Ship real things
A portfolio of shipped products is stronger than a certificate. With AI, one person can build a full product. Use that power.
With AI, I shipped almost 15 products in two years. I wrote about that experience in 25 Years of Building. The tools did not make me less of a developer. They made me a developer with more output.
8. Make your human skills stronger
Communication, trust, and taste become more valuable. Somebody must talk to the customer. Somebody must explain the trade-off to the CEO.
Somebody must also say: “This works, but it is ugly, and users will not like it.” Machines can help with these tasks. They do not own them.
How to Adapt: A Practical Procedure
Strategies are easy to read and difficult to do. Use this procedure to start. Do one step each week. Do not try to do all the steps at the same time.
- Use an AI coding agent for all your work for two weeks. Continue when it feels uncomfortable.
- Record the tasks where the agent saves time. Record the tasks where it fails.
- Write a short specification before each large task. Compare the result with the specification.
- Read every line of the generated code before you merge it.
- Ask the agent to explain each part of the code that you do not understand.
- Choose one business domain. Read about it for 30 minutes each day.
- Build one small product from idea to production. Get one real user.
- Teach one person what you learned. When you teach, you see the gaps in your knowledge.
WARNING: Do not merge code that you cannot explain. If the system fails, you are responsible. The agent is not responsible.
CAUTION: Do not stop writing code by hand completely. Write some code by hand each week. If you stop, your skills become weak. Then your reviews become weak too.
A Note for Junior Developers
This is the most difficult time to start a career in software. I will not tell you a different story. But you also have an advantage. You do not have old habits to remove. You start with agents as a normal tool.
Do these things:
- Learn the fundamentals without AI first. Then use AI to go faster.
- Build in public. Show your work, your mistakes, and what you learned.
- Read code from good open source projects. Learn how experienced people think.
- Find a mentor. Agents give answers. Mentors give judgment and opportunities.
- Show judgment, not only output. In interviews, explain why you rejected the first answer from the agent.
A Note for Leaders
If you lead a team, your decisions shape this change for many people. Here is my advice.
- Continue to hire junior developers. If nobody trains juniors today, nobody will be senior in ten years.
- Measure outcomes, not lines of code. AI makes lines of code cheap. As a metric, they are now almost useless.
- Give your team time to learn. A developer who operates agents well can do the work of a much larger team.
- Make your review culture strong. More code means more review, not less.
- Talk honestly about the change. Silence makes fear grow. Clear plans make fear smaller.
What the Future Looks Like
Nobody knows the future. This is my best estimate. I will probably be wrong about some parts.
The next two years
Agents write most new code in many teams. The developer writes the specification, reviews the result, and connects the parts. Teams become smaller. Companies expect more products from fewer people.
Two to five years
Agents work for many hours without supervision. They run tests, deploy to staging, and monitor the results. The developer role divides into types: product engineers, platform engineers, and domain engineers. More people make simple software, because non-developers can make their own tools. The demand for people who make complex software reliable also increases.
Five to ten years
Software becomes much cheaper to make. When a thing becomes cheaper, people use more of it. Economists call this the Jevons paradox. I think we will have more software, not less. Every small business, school, and clinic will have custom software. Somebody must design it, connect it, secure it, and be responsible for it.
That somebody will look like a developer, even if the job title changes.
Some things will not change:
- Users will want software that works.
- Businesses will want a person who is responsible.
- Complex systems will fail in ways that nobody expected.
- People will trust people, not tools.
Who You Are Now
Go back to the first question: “If the AI writes the code, what am I?”
My answer is this. You are the person who knows what to build and why. You are the person who knows how to prove that it works. You are the person who is responsible. That was always the real job. The code was only the part that people could see.
The identity crisis is real. But it is also an invitation. Let go of the identity “I write code.” Accept the identity “I solve problems with software, and I own the result.” That identity has a long future.
Use the tools. Keep your judgment. Ship real things. And be kind to yourself during this change. Everyone in our industry learns this lesson at the same time.
Related Articles
Vibe Coding vs Vibe Engineering: The Difference Between Slop and Software Excellence
Explore the critical distinction between vibe coding—which produces superficially working applications—and vibe engineering, which creates fantastic software backed by real engineering principles, foundational work, and performance optimization.
25 Years of Building: Failures, Side Projects, and Why I Keep Going
A raw look at 25 years of entrepreneurial struggle—the failures, small wins, daily doubts, and how AI became an incredible multiplier. From 15 products in 2 years to automated podcasts and StoryFlow.
Small Teams Beat Large Organizations (And Here's Why)
Basecamp's origin story and why 15 specialized roles at Facebook created unnecessary complexity. The economics of simplicity vs. the politics of headcount, and how to structure teams for actual output.