Integrated Development Environments (IDEs) have long been the primary tools for boosting developer productivity. Recently, however, Large Language Models (LLMs) have also fundamentally shifted how developers work.
IDEs consolidate a wide range of functionalities—from syntax support and code generation to validation and verification—in a way that is deterministic and cost-effective. In contrast, LLMs (often integrated into environments via tools like Antigravity or Copilot) provide similar types of support but operate non-deterministically and at a higher computational or token cost.
The choice of which tool to use depends heavily on the specific task. For example, while LLMs are impressive at debugging, they often rely on a trial-and-error strategy that can be expensive in terms of tokens and may occasionally produce “workaround” solutions rather than addressing the root cause. In these instances, I prefer to run the test suite myself and analyze the errors manually. By providing the LLM with the results of my own analysis, I can direct it more accurately toward the final solution.
Renaming is a prime example of where an IDE outperforms an LLM in both cost and accuracy; the IDE uses a deterministic understanding of the code’s abstract syntax tree to ensure every reference is updated correctly. However, if I identify a specific structural pattern that needs to be refactored across multiple similar occurrences, the LLM’s ability to recognize intent often outperforms the rigid rules of an IDE.
Another critical advantage of LLMs arises when I lack a precise vision for a solution. In these cases, an LLM can generate a high-level plan or architectural outline. This helps me think more deeply about the problem and decide whether to let the LLM execute the code or to implement it manually using the IDE’s specialized tools.
While the distinction between “IDE” and “LLM” is increasingly blurring—as IDEs natively integrate AI features—this reasoning still applies to which type of feature I choose for a given task.
In this video series (Introduction, Cohesion, Architecture, Polymorphism, Performance), I follow some of these principles using the classic Martin Fowler refactoring example (Java version), utilizing IntelliJ IDEA alongside Antigravity.