Integrating AI into development requires more than adopting a new tool — it means reshaping your workflow to use AI effectively at each stage. There are solutions for every part of the process, from writing individual lines of code to orchestrating complete automations, and you'll meet several of them while building your Kotlin Multiplatform app in this course.
This topic covers the main categories of AI tools available today, and where AI fits into the parts of the development process you'll actually go through while building your app: implementing features and writing tests.
Basic usage
The most direct way to bring AI into your workflow is through an IDE plugin or extension — this embeds AI capabilities directly into the editor you already use. The key advantage is minimal disruption: AI assistance meets you where you are, augmenting your existing habits rather than forcing a new environment on you.
These plugins typically offer context-aware code completion, suggesting entire blocks of code based on the existing code and comments in your project, plus an inline chat for asking about or refactoring a piece of code without leaving the editor. In this course, that's the JetBrains AI Assistant, which you'll set up in the next few topics; other popular tools in this category include GitHub Copilot and Amazon Q. They all offer real-time assistance, and the right one for you depends on your ecosystem.
Agentic coding assistants
While IDE plugins act as co-pilots for writing code, agentic assistants function more like project partners. Instead of suggesting the next few lines, an agent can plan and execute multistep goals — such as scaffolding a new feature across your shared and platform-specific source sets, or debugging an issue that spans multiple files. You invoke the agent through a chat panel or command line, give it a natural-language instruction, and it works directly across your project's files: examining, generating, modifying, and organizing code as needed.
For communication with your project and external systems, agentic assistants use the Model Context Protocol (MCP) — covered in detail in an upcoming topic. With MCP, an agent isn't limited to writing code: it can run your tests, use a linter to check for errors, or execute shell commands. Ask an agent to fix a bug, and it can write a fix, run your test suite to verify it, and only report success once everything passes.
JetBrains Junie is this course's main example of an agentic assistant — you'll use it in later topics to work directly on your Kotlin Multiplatform project. Other tools in this category include Claude Code, Aider, and OpenAI Codex. This workflow suits scenarios where you have a clear but non-trivial goal and want a capable collaborator to carry it out end to end.
Security matters here too: MCP provides a framework for access policies, so if an agent needs to reach a sensitive data source, it pauses and asks you to allow or deny access.
AI-native IDEs
A more recent category is IDEs designed around AI from the outset, rather than adding it via extensions. A "codebase-aware" chat maintains a persistent, comprehensive understanding of your entire project, so you can ask something like "what's the data flow for user profile information?" and get a project-wide answer, or describe a large migration and have the changes applied across the whole codebase in one pass. Cursor, a fork of VS Code redesigned around AI interactions, is a well-known example.
Developer productivity tools
AI has also reached the SaaS platforms teams already use for documentation and planning — tools like Notion and Confluence can now summarize discussions, draft documentation, and automate routine writing tasks inside the same familiar interface. Setup is usually just granting the tool access to the right workspace; the provider handles the AI models and processing behind the scenes. This category matters more for teams than for a single project, but it's a useful thing to recognize as part of the broader landscape.
Custom solutions with SDKs
For the highest degree of control, you can work directly with AI models using a provider's SDK (such as OpenAI Java SDK) — moving past pre-built tools to integrate AI programmatically into your own code, scripts, or pipelines. This is the least automatic option: you write the code that handles authentication, formats the input, and parses the response. In exchange, you get full flexibility, unconstrained by any particular tool's feature set.
Conclusion
AI tools fall into a few clear categories — IDE plugins, agentic assistants, AI-native IDEs, SaaS productivity tools, and direct SDK integrations — each suited to a different kind of task. In this course, you'll mainly work with the first two: the JetBrains AI Assistant for day-to-day coding, and Junie for larger, agentic work across your project.
Within your actual build process, the same idea holds throughout: AI tools work best as collaborators that handle the repetitive parts of implementation and testing, while you stay responsible for the architecture, the trade-offs, and the final review. The next topics put this into practice — starting with agent skills, a way to give these assistants project-specific knowledge so they work the way you want them to on your app.