When the IDE Becomes an Agent Runtime, What Remains the Developer’s Job?

Home » Blog » Software » Enterprise Software » When the IDE Becomes an Agent Runtime, What Remains the Developer’s Job?

For decades, the integrated development environment has been where developers write, navigate, run and debug code. AI initially appeared there as a more capable form of autocomplete. The direction now emerging from JetBrains is considerably more consequential: the IDE is becoming an execution environment in which software agents carry out substantial parts of the development process.

In the Spring podcast episode “AI Development within JetBrains IDEs”, Josh Long and Anton Arhipov discuss this increasingly agent-first approach. An agent can plan a feature, edit several files, run tests and investigate failures. JetBrains Air provides an environment for coordinating different agents while retaining the code intelligence and familiar tools of IntelliJ IDEA.

The debugging example is particularly revealing. An agent is given a failing test, starts a debugging session, examines the application’s runtime state, identifies the underlying cause and implements a correction. Through protocols such as MCP and ACP, agents can use IDE capabilities including navigation, refactoring and debugging. They are becoming active users of the development environment rather than external chatbots that merely generate code snippets.

That raises an obvious question: what remains the developer’s job?

The first responsibility is deciding what the software should accomplish. An agent can implement a clearly described change, but business software contains assumptions that are rarely expressed completely in source code. Developers must uncover domain rules, identify conflicting requirements and decide which trade-offs are acceptable. An efficiently implemented misunderstanding remains a misunderstanding.

Specifications, project rules and reusable agent skills therefore become increasingly important. They give an agent persistent information about architectural boundaries, coding conventions, testing expectations and approved ways of performing recurring tasks. For a Spring application, this might include rules about transaction boundaries, security, module dependencies, database migrations and external integrations. The developer’s work increasingly includes turning such knowledge into explicit, reusable constraints.

Verification remains equally important. An agent may run the tests and correct every reported failure, but a green test suite only confirms the properties that somebody thought to test. It cannot reveal a missing acceptance criterion or determine whether the implementation reflects the intended business process. Developers still need to examine behaviour, question generated abstractions and assess security, maintainability and operational consequences.

The IDE can make this review more effective. Diffs, inspections, debuggers, profilers and test runners provide evidence about what an agent changed and how the resulting system behaves. Multiple agents may propose and implement solutions, while the developer controls their access, evaluates the outcome and remains accountable for accepting it.

The developer’s role is therefore moving further towards specifying, constraining and verifying software. Understanding code remains essential because meaningful supervision requires technical judgement. When the IDE becomes an agent runtime, the most valuable developer is the person who can define the right problem, supply the missing context and recognise whether the resulting software deserves to reach production.

About the author: Bjoern
Independent IT consultant, entrepreneur

Leave a Comment

Your post must include a link to this post.

How does this work?
Write a response on your own website and include a link to this post. Then submit your response’s URL here. Your response may appear here after moderation. To update or remove it, edit or delete your original post and submit the same URL again. Learn more about Webmentions.