A few years ago, software development was about solving problems. We designed systems, debated architecture, wrote code, tested assumptions, and learnt from failures. Every bug taught us something. Every feature improved our understanding.
Today, the workflow is changing rapidly.
Many developers now spend more time writing prompts than writing code. Instead of building a solution line by line, we ask an AI to generate it, wait for the response, run it, fix a few errors, adjust the prompt, and repeat the cycle.
The question is no longer "Can I build this?"
It has become "Can I make the AI build this?"
The Rise of the "Watch Developer"
A new role seems to be emerging.
The developer becomes a supervisor rather than a creator.
The daily routine starts looking like this:
- Write a prompt.
- Wait for AI to generate code.
- Copy the output.
- Fix compilation errors.
- Prompt again.
- Wait for another response.
- Review the generated code.
- Approve the pull request.
Sometimes it feels less like software engineering and more like watching an automated machine work.
Are we becoming Watch Developers?
Experience Still Matters... For Now
An experienced engineer can usually recognise when AI-generated code is problematic.
They can spot:
- Hidden security issues.
- Poor architecture.
- Performance bottlenecks.
- Code duplication.
- Maintainability problems.
- Missing edge cases.
They understand why something works—not just that it works.
AI becomes a productivity tool, not a replacement.
But What About New Developers?
This is where the real concern begins.
A junior developer who starts their career in an AI-first world may never experience the struggles that build engineering intuition.
If every solution comes from AI:
- How do they learn debugging?
- How do they understand design patterns?
- How do they estimate complexity?
- How do they know when AI is confidently wrong?
- How do they review code they didn't fully understand?
Code review itself becomes difficult because reviewing requires knowledge.
Without experience, approval risks becoming a simple click.
Prompt Engineering Isn't Engineering
Writing good prompts is undoubtedly a valuable skill.
However, prompt engineering is not a substitute for software engineering.
A prompt describes what you want.
Engineering decides whether it should exist, how it scales, how it fails, how it is secured, and how it evolves over time.
Those decisions still belong to humans.
The Infinite Prompt Loop
Many developers are already experiencing something like this:
- Prompt.
- Generate.
- Fix.
- Prompt again.
- Generate again.
- Review.
- Repeat.
Instead of thinking deeply about the problem, we optimise the prompt.
Instead of designing software, we negotiate with AI.
The loop becomes endless.
Eventually, we spend more time talking to AI than understanding our own systems.
The Bigger Risk
The biggest risk isn't that AI writes code.
The biggest risk is that developers stop learning how software actually works.
When everyone depends on AI for answers, who will recognise when those answers are wrong?
Who will design the next generation of architectures?
Who will solve problems AI has never seen before?
Innovation has always come from people who understood the fundamentals—not just the tools.
The Future Developer
Perhaps the future developer will write less code.
But they will need stronger skills in:
- System design.
- Critical thinking.
- Architecture.
- Security.
- Product understanding.
- Business decisions.
- Code review.
- AI verification.
The keyboard may become less important.
Judgement becomes everything.
Final Thought
AI isn't replacing developers.
It is changing what it means to be one.
The real danger isn't becoming obsolete.
The real danger is becoming passive—someone who watches code being generated, clicks "Approve," and moves on without truly understanding what was built.
The future doesn't need fewer developers.
It needs developers who can think beyond the prompt.
Because when AI can generate almost any code, the most valuable engineer won't be the fastest typist.
It will be the one who knows when the AI is right, when it is wrong, and what should be built in the first place.
Top comments (1)
The watch-developer framing is fair. AI-assisted coding makes the bottleneck move from typing to attention. The hidden cost is not only reviewing code, but maintaining enough context to know which generated changes deserve trust and which need a deeper read.