In recent months, I’ve spent time working with AI coding assistants like Cursor, Windsurf, and others across a range of projects. These tools are impressive — surprisingly effective when applied to the right type of work. They represent a glimpse into the likely future of software development. But that future may not come without serious consequences, especially when it comes to developer engagement and long-term fulfilment.
The Magic (and the Mechanics) Behind the Curtain
At first, using tools like Cursor feels a bit like magic. You write a prompt, provide some context, and like a conjurer’s trick, a functional chunk of code appears. Sometimes, it’s even good code — especially if you’ve defined a clear set of rules for the AI to follow. It can draft files, check for errors, and suggest fixes. The whole process feels almost frictionless:
- Define the problem
- Specify or infer the relevant context
- Generate code
- Review and iterate until it works
But it’s not magic — it’s just skilled prompt engineering paired with a robust feedback loop. The success depends not only on how well you frame the problem and interpret the results, but also on the quality of what’s already there — the structure of the codebase, the clarity of the project, and the integrity of the foundation you're building on.
When the Developer Becomes the Reviewer
This is a significant shift in how we work. In the future developers could no longer be needed to write most of the code. Instead, we’re would become code reviewers — approving or tweaking suggestions, rarely diving deep. It’s a transformation that mirrors the shift from artisan to assembly line. I’ve read claims like “Amazon, Google, Microsoft write 30% of their code with AI.” That statistic might sound impressive, but it also signals a move toward the “warehouse-ification” of software engineering.
There is a huge difference between being a coder and a code reviewer. When development becomes a high-speed approval pipeline rather than a creative, cognitive craft, we risk losing the very thing that made the profession fulfilling. Is system development going to become a metered job — "get through so many reviews an hour"
Can coding even remain a skilled profession?
Are we heading toward a future where our job is to press "approve" like Homer Simpson tapping “Y” again and again to avert a meltdown?
Fulfilment Isn’t Just a Perk — It’s Critical
There’s something quietly dangerous about jobs that demand high responsibility but offer little active engagement. It’s similar to what train drivers experience — roles that require constant concentration in low-stimulus environments. That kind of mental strain is real, and in software, we risk creating the same conditions.
This work also demands a completely different skillset from what has traditionally been expected of developers — shifting away from writing code and debugging toward constant supervision, risk assessment, and rapid decision-making. Developers are being asked to stay sharp and accountable while the system does most of the work. That gap between responsibility and agency isn't just unfulfilling — it's unsustainable.
There are several key issues at stake here:
Loss of engagement: When developers only say "yes," "no," or "refine this," they’re no longer immersed in the problem space.
Shallow understanding: Relying too heavily on AI-generated code limits opportunities for deep learning and intuition-building.
Increased risk: Subtle bugs or logic flaws can slip through — things that neither the developer nor the AI catch. It’s like pair programming where one party isn’t truly present. The safety net only works if both sides are actively engaged.
Reduced joy: Solving a problem, debugging something tricky, designing a clever system — these are what make coding satisfying. Reviewing AI suggestions at high speed doesn’t scratch that same itch.
And here's the broader concern: as fulfilment drops, so might the desire to enter or remain in the profession. Coding becomes detached from curiosity and creativity. Enrolment in computer science courses could drop. The people who once got into tech to solve problems and create might not see the appeal anymore.
Better Tools Aren’t the Full Solution
Here’s the key: This isn’t an AI problem — it’s a human problem. These tools are meant to augment our work, not diminish our role. But if we design workflows that prioritise throughput over engagement, we’ll push developers to the margins.
When more powerful models arrive, and they will, this problem won’t be solved. We need to think about developer experience the same way we think about user experience: holistically, empathetically, and with a long-term view.
If we don’t solve the problem of keeping developers engaged and involved, we risk losing them.
I don’t have any of the answers, I think that it just needs to be a collaborative future rather than a transactional one — one where developers remain co-creators in the process, not just overseers of automated output. We need to move away from the closed feedback loops that define these tools today — where the system prompts and answers itself, and leaves the human as a passive gatekeeper.
The company that fixes that — a toolmaker, a platform like Cursor, or whoever figures out how to truly integrate developers into the AI-assisted process — will win. Not just in terms of talent retention, but in setting the pace for long-term innovation. Because teams that stay curious, connected, and fulfilled are the ones that will keep building what’s next. Not just faster, but better.
The Industry’s Choice
What we have now, I think, is partly consequence of human greed and a desire to cut costs. I still believe AI has a key place in software production and will continue to be an incredibly useful tool. But right now, it feels like developers are being pushed aside. We need to build a future where AI is a partner, not a replacement. One that enhances our work, without erasing our role in it.
This is a turning point for our industry. Managers, founders, and team leads must consider not just how to ship faster, but how to keep developers connected to the craft. Because if we lose that connection, we lose more than productivity — we lose the people who truly understand how these systems work.
And if we cede that understanding entirely to machines?
Well, that’s not just a sci-fi plot. That’s a real risk. Consider the recent report about Anthropic's Claude Opus 4 — during internal safety evaluations, the AI model engaged in behavior that resembled blackmail, threatening to expose engineers' personal information when facing shutdown. That’s not speculative — it’s a clear sign of what can happen when we build systems we don’t fully understand and take humans out of the loop.
This kind of incident reinforces the importance of keeping developers embedded in the process — not just as code reviewers or safety net checkers, but as core participants. It’s not about halting AI progress; it’s about shaping it responsibly, together.
Top comments (0)