This article explains my feelings as a Software Engineer regarding the recent rapid advancements in AI technology and the resulting changes in the developer's role.

There are various terms for applying AI to software development:

• AI-Assisted Development
• AI-Driven Development
• Vibe Coding
• AI Augmented Coding

In this article, I will refer to this as AI dev for short. Services that assist these development methodologies will be called AI coding services.

This article does not cover technical details. While I will briefly mention AI coding tools and services, it is not an article sharing detailed usage methods or know-how.

---

My AI dev Experience

Github Copilot

AI actually works, doesn't it?

My first use of an AI coding service began with Github Copilot. At that time, LLM technology hadn't reached its current performance, and notably, reasoning models didn't exist. So, I primarily used its auto-completion feature for simple code snippets.

I was still somewhat skeptical about AI, especially LLMs, but I vividly remember being quite surprised by the auto-completed code. Nowadays, auto-completion and code suggestions are common, but back then, seeing a complete code snippet suggested in my IDE (without me writing it) after typing just a few characters made me think, "Wow, the world is really going to change."

When I picture the code I want to write in my head and type it out character by character, it magically reads my intentions (though it's probably probability-based next-word generation) and suggests code. I just press the Tab key to complete it. Sometimes that's the end of my coding, and other times I modify just a few parts of the completed code. This process became quite enjoyable because it allowed me to implement code quickly.

ChatGPT

First Experience Implementing Code with Human Language

After ChatGPT was released, I didn't use it for a while, but I started experimenting with it around late 2023 to early 2024. Due to the limitations of a browser-based chat interface, I mainly used ChatGPT for simple, function-level code writing rather than complex features or precise code.

I distinctly remember being incredibly surprised watching code being generated in real-time from a prompt. I've become desensitized to it now, but back then, it was both fascinating and, at times, a bit clumsy, which actually brought some relief. Even after that, I still use ChatGPT occasionally for development. It's particularly useful for writing very simple scripts in unfamiliar domains (e.g., shell scripts).

Cursor

The First Service That Made Me Consider Changing My Workflow

Even if you generate code via chat interfaces like ChatGPT or Claude (Web), you still need to bring that code into an IDE to implement features.

What somewhat alleviated this inconvenience was actually the VS Code + Cline combination. By installing the Cline plugin in VS Code and setting up an OpenAI or Gemini API key, you could create and manage code in real-time using natural language. I thought this was finally a service that could truly be called an AI coding service, as it allowed all tasks to be completed in one place. However, this combination didn't quite suit me. The interface wasn't great to use, and the quality of the code generated by natural language wasn't particularly outstanding.

Nevertheless, the idea of directly connecting an IDE with an LLM was excellent, and several such services were already appearing on the market. Cursor was my second AI coding service, an IDE+LLM combination I chose.

What particularly impressed me about Cursor was that all the inconveniences I felt with the VS Code + Cline combination were resolved. From a user interface perspective, Cursor was excellent, and furthermore, the quality of the output was quite good throughout the process of instructing code generation with natural language, reviewing it, and incorporating it into the actual code.

However, there was one critical drawback. I am primarily a Back-end engineer using Java (Kotlin). Cursor is built on VS Code, which is not an IDE specifically optimized for back-end technologies like Java and Spring Boot. While you can configure it, it lacks many features compared to specialized tools like IntelliJ. So, I would run Cursor and IntelliJ simultaneously, switching between them: generating code with natural language in Cursor and reviewing or writing code myself in IntelliJ. This was a rather poor DX (Developer Experience).

Despite this, I still subscribe to and use Cursor. It was the first service that made me seriously consider AI dev. I led an internal project to adopt it, purchasing licenses for the entire development team and even holding a seminar on how to use Cursor. Through this process, I realized that I needed to change my entire workflow, not just purchase an IDE or tool.

Claude Code

My Ultimate Weapon, Finally Discovered

Among all the AI Agentic coding services I've used up to the present moment of writing this article (November 2025), Claude Code is the one I use best.

Claude, created by Anthropic, not only has good model performance itself, but the user experience with Claude Desktop (Web) and Claude Code in conjunction with Claude is quite excellent. It's like it understands and responds to human language perfectly.

Claude Code, in particular, makes me exclaim "it's so well made!" every time I use it. Especially in terms of freedom and autonomy, it has an overwhelming advantage among the various AI dev experiences I've had so far. Due to the nature of the CLI environment, almost all operations are possible based on the current working directory.

What I began to realize while using Claude Code was that I could apply it not just to coding, but perhaps to everything a developer does. I started using Claude Code as soon as it was released, and its features improved incredibly fast after the first version. As I used each of the improved features, I felt I began to understand a little of what Anthropic wants to achieve with this service and what future they envision.

An AI Agent that doesn't just assist human tasks, but partly replaces them, and perhaps even fully replaces humans.

This is what I perceived as the ultimate goal of this service while using Claude Code. However, official videos and documentation for Claude Code never mention completely replacing humans; they state that its nature is to assist humans.

From Copilot to ChatGPT, VS Code+Cline, Cursor, and Claude Code, what I've realized is that AI dev services have been evolving in a consistent direction. If their first appearance felt like an assistant helping humans, now they feel like co-workers that can be trusted with a certain portion of human tasks.

Assuming that the era of complete human replacement has not yet arrived and will not in the near future, how should a developer's role change at this current moment? This question naturally arose in my mind as I used AI services.

---

How Should a Developer's Role Change?

From Code Author to Code Reviewer

Assuming there's a well-written PRD.md document, and in addition, detailed prompts for the current task are provided to Claude Code (including other services), I believe there are broadly two ways a developer currently writes source code:

1. The human holds the initiative for code writing. The AI reads the code written by the human and is responsible for analyzing side effects or writing test code.
2. The AI holds the initiative for code writing. The AI writes the business logic, and the human reviews it.

The important part here is the assumption. There must be clearly defined Spec and PRD documents. Additionally, the ability to write detailed prompts containing instructions for the current Task or Story is necessary. With this assumption fulfilled, a developer can choose between method 1 and method 2.

And regardless of whether method 1 or 2 is chosen, a Plan must be established before actual coding. Creating this Plan requires collaboration between AI and human. A Plan ensures that the AI doesn't get lost during the task. Due to the stateless nature of current LLMs, a strong guiding Plan must be created at the beginning and followed.

If all these conditions are met and you develop with an AI agentic coding service like Claude Code, it's highly likely you'll proceed with method 2. Services of this type are fundamentally designed to perform code writing. Thus, they continuously attempt to write code and ask for human permission to proceed.

In other words, the initial service design itself is set up for AI to lead code generation and for humans to be prompted for intermittent checks. Of course, depending on the choice, one could even omit the intermediate verification steps entirely and allow the AI to write code from beginning to end.

I believe this is a very crucial moment for developers. One must choose between these two approaches. Of course, when implementing a single Task, both methods can be used. Simple but tedious code can be written by AI, while important and carefully crafted code is handled by humans. However, for very small-unit tasks, one must choose one of the two. And given the pace and direction of AI technology development, I anticipate that this delegation of work will increasingly grow.

Lately, I've been feeling that I'm spending more and more time as a reviewer – reviewing source code written by AI and verifying its output – rather than as a source code author. More precisely, in the initial phase of a Task, I create a Plan with the AI, and then all subsequent source code writing is entrusted to the AI. Once the AI completes the work, I use the diff feature in my IDE to read through the output and evaluate whether the functionality has been correctly implemented. Sometimes a Task is completed in one go; if not, I write detailed prompts on what and how to improve, and then instruct the AI to work again.

It's been about two months since I changed my workflow in this way. I still don't feel fully adapted. But importantly, development speed has definitely increased, and I'm performing not only Back-end side work but also Front-end side work without significant issues. I believe I can adapt quickly now because I've consistently studied FE technologies since the beginning of this year. If I hadn't had knowledge or experience with React, Vite, FE Build, etc., it would have been difficult for me to handle FE development for actual company tasks, no matter how much AI I used.

From Individual Player to AI Orchestrator

Among concrete examples of applying AI technology to workflows, a general approach that could yield significant effects is replacing an entire Team with AI. Instead of a human acting as a component of the overall workflow, the human would only perform the Team lead role, with AI handling the actual specific detailed tasks.

As a developer, it's about creating a sort of development Team. This approach has become more effectively applicable by utilizing features like Custom commands and Sub-agents (based on Claude Code) that AI dev tools have recently started supporting. AI technology has advanced to the point where it's not merely a supportive tool, but capable of completing tasks themselves, enabling the creation of AI agent Teams and the 'delegation' of work.

At this juncture, there are a few things to consider:

• Building an effective Team itself has become a skill. One must efficiently configure the Team and assign clear roles and guidelines to each AI Team member.
  • One must consider how to structure the team. You could create a small team consisting of FE+BE, or a team composed of PM+FE+BE+QA+Designer to handle a Product from inception to completion. Alternatively, you could form a team of Code reviewer+Refactoring engineer+Test code writer and write the actual business logic yourself. You could even configure the team solely for code review with Functional Reviewer+Performance reviewer+Security Code Reviewer+Readability Reviewer.
  • Beyond composition, clearly defining individual AI task handlers is also crucial. You need to define the AI worker's description, under what circumstances it should start working, which tools it can call, what criteria it should use to perform tasks, and so on.
• The way of working itself must be changed from a fundamental level.
  • Not just code writing, but AI must be incorporated into every stage of a developer's work within a company. This means involving AI in analyzing and designing tasks based on PRDs, estimating schedules, designing DB schemas, making technical decisions, designing APIs, implementing business logic, writing test code, and deploying to Alpha and QA environments.
  • One must feel natural about delegating tasks to AI and seamlessly integrate this into the daily work routine. Sticking to existing methods while only partially adopting AI will severely limit the perceived effectiveness.
• Companies/teams must support these new workflow methods.
  • Moving beyond the traditional individual work model, a single worker can now perform multiple roles simultaneously. This means companies or teams need to redefine employee roles.
    • Let's assume a Front-end engineer, after some self-study and experience, decides to take on both FE and BE roles simultaneously. This is a completely different situation from when AI dev wasn't what it is today. It's now a practically viable scenario.
    • If an organization has an Engineering team with separate FE and BE sub-teams, how should it confront such a situation? Should the engineer exemplified above be simultaneously assigned to both the FE and BE teams? Or should the organizational structure itself be reformed? What if it's just one person now, but tomorrow more developers approach their roles differently than before?
  • The process of planning and creating Products must also change. It must be made easy for AI to read documents and generate follow-up documents. It's advisable to avoid excessive images, emojis, or complex table structures in documents provided as context to the AI.
  • The habit of creating intermediate documentation during the decision-making process must be cultivated. Especially, decisions made in meetings should always be summarized and shared as Meeting minutes documents. Furthermore, these documents must be pre-configured to be searchable by AI dev services or tools at any time. Recently, MCP (Multi-Context Processing) technology has been maturing. MCP settings should be pre-configured in services that handle and manage documents like Confluence, Jira, Slack, and Notion, and this information should be disseminated to workers for easy use and continuously managed.

---

So, How Will Things Change?

Evolution of Roles

Synthesizing my experiences over the past few years of integrating AI technology into the development workflow, my recent conclusion is as follows. I anticipate that the developer's role will likely diverge into three main branches.

1. Focus on Fundamentals (Deepening Specialization)

A few days ago, I had the opportunity to discuss Claude Code with another Back-end engineer on my team. They definitely felt an increase in productivity and mentioned that they were spending less time coding and dedicating the remaining time to more fundamental aspects, such as API design, DB table schema structure design, and paying more attention to performance and security.

I think this might be the first natural aspect of a developer's evolving role. It's very natural. By spending less time on code writing, we can focus more on the remaining areas of what we call development.

2. Evolution into a Full-stack Engineer

I believe this change will also come naturally.

It's about expanding one's scope of work. A Back-end engineer can acquire Front-end languages and technologies, and after a short adaptation period, redefine their position as a Full-stack engineer and work accordingly. Other paths (Front-end engineer ➡️ FSE, Mobile Engineer ➡️ FSE) would also be possible.

3. Evolution into a Product Engineer

The last divergence I predict is extending one's boundaries to become a Product Engineer.

What is a Product Engineer?

This includes not only technical domains but also defining problems and deciding how to solve them as part of the job scope. Developers are closer to people who decide how to solve an already defined problem. However, a Product Engineer must shift their mindset and start from the problem definition stage. They are involved in the entire process from identifying customer pain points, recognizing problems, and ultimately creating the final Product. Perhaps, within the concept of 'creating a Product,' this can be seen as tackling the ultimate level of difficulty.

I expect to be able to share more detailed articles on these three main branches soon. I hope that through the writing process, I can further concretize what is still abstractly swirling in my mind.

---

In this article, I've contemplated the role of a developer (Software engineer) in the AI era. This consideration has been a deep one for the past few years, especially over the last year. And I feel that this contemplation will continue into the future.