Multi-Agent Workflow Guide: JetBrains Junie x Claude Code in Practice

The Multi-Agent Era: Why One Agent Isn’t Enough Anymore

In February 2026, JetBrains published something unexpected: an official guide recommending developers use both their own AI agent Junie and Claude Code together. Not as competitors. As collaborators.

This is significant. A major IDE vendor publicly stated that their own agent works better when paired with an external one. That admission marks the end of the single-agent era and the beginning of something more interesting.

Around the same time, Weaviate launched open-source Agent Skills — production-ready tool definitions that give AI coding agents structured knowledge about vector database workflows. Not generic prompts. Precise, domain-specific instructions that produce correct code on the first attempt.

These two developments point to the same conclusion: the ceiling of what one general-purpose agent can do is real, and the way past it is composition.

The analogy is Unix philosophy. grep doesn’t try to be a text editor. awk doesn’t try to be a compiler. Each tool does one thing well, and the shell composes them into powerful pipelines. AI agents are following the same evolutionary path.

Agent Strengths Matrix: When to Use Which Agent

Not all AI coding agents are created equal. Each has a distinct sweet spot shaped by how it accesses your code, what tools it can invoke, and where it runs.

Claude Code — The Architect

Claude Code operates from the terminal with full filesystem and shell access. It reads your entire project, runs commands, writes files, and reasons across multiple codebases.

Best for:

• Designing project architecture from scratch
• Large-scale refactoring across dozens of files
• Cross-repo changes and monorepo operations
• Complex debugging with logs, environment variables, and system commands
• Git operations — branching, committing, conflict resolution
• Code review with deep reasoning about design patterns

Key advantage: No file-count limit. Claude Code can hold hundreds of files in context and reason about their relationships. When you need to restructure a module boundary or migrate from one framework to another, this is the tool.

Junie — The IDE-Native Implementer

JetBrains Junie lives inside IntelliJ-based IDEs (GoLand, WebStorm, PyCharm, etc.). It has access to the IDE’s index — type information, symbol resolution, test runners, debugger integration.

Best for:

• Implementing specific functions within an established architecture
• Running and fixing tests iteratively
• IDE-aware refactoring (rename symbol, extract method, move class)
• Language-specific tooling (Go formatting, Java imports, Python type checking)
• Incremental changes where IDE context matters more than breadth

Key advantage: IDE integration. Junie doesn’t just generate code — it interacts with the same tools you use: the test runner, the debugger, the code formatter. It sees compiler errors in real time.

Copilot / Cursor — The Inline Companion

GitHub Copilot and Cursor excel at the micro-level: completing the line you’re typing, suggesting the next function, filling in boilerplate as you work.

Best for:

• Inline code completion while you type
• Quick single-file edits and small fixes
• Tab-completion of repetitive patterns
• Rapid prototyping within a single file

Key advantage: Speed and zero friction. You don’t switch context. You don’t write a prompt. You just keep typing and the agent fills in the gaps.

Agent Skills (Weaviate Pattern) — The Domain Expert

Agent Skills aren’t a standalone agent. They’re structured tool definitions that augment any general-purpose agent with deep domain knowledge about a specific technology.

Best for:

• Vector database operations (collection creation, hybrid search, RAG pipelines)
• Framework-specific code generation (correct API usage, idiomatic patterns)
• Any domain where generic LLM knowledge produces “almost right” code that silently breaks

Key advantage: Precision. A Weaviate Agent Skill doesn’t guess at the API — it encodes the exact schema, parameter types, and best practices. The result is code that works on the first run instead of the third.

The Matrix

Task	Claude Code	Junie	Copilot	Agent Skills
Project architecture	Strong	Weak	Weak	N/A
Cross-file refactoring	Strong	Medium	Weak	N/A
Test-driven iteration	Medium	Strong	Weak	N/A
Inline completion	N/A	Medium	Strong	N/A
Terminal / DevOps	Strong	Weak	Weak	N/A
Domain-specific code	Medium	Medium	Weak	Strong
Code review	Strong	Medium	Weak	N/A

Practical Workflow: The Dual-Agent Pattern

Here is the workflow I use daily, refined over months of building real projects. It follows four stages.

Step 1: Claude Code for Architecture and Scaffolding

Every project starts in the terminal with Claude Code. This is the strategic phase.

You: "Create a Next.js 16 app with Supabase auth,
      Zustand for state, and Tailwind CSS v4.
      Set up the folder structure, routing,
      and database schema for a task management app."

Claude Code generates the project skeleton: directory structure, configuration files, database migrations, environment setup, base components, and routing. It reasons about how pieces fit together — which is exactly what you need when 30 files need to exist simultaneously and reference each other correctly.

Why not Junie here? IDE agents work best with existing code. They need something to index, navigate, and refine. Claude Code is better at creating something from nothing.

Step 2: Junie for Implementation and Testing

Once the skeleton exists, open the project in your JetBrains IDE. Now Junie has something to work with — a fully indexed codebase with type information, test fixtures, and IDE configuration.

You: "Implement the createTask function in taskService.ts.
      It should validate input, insert into Supabase,
      and return the created task. Write tests."

Junie writes the function, runs the tests, sees the failures, and iterates until they pass — all within the IDE. It reads compiler errors, navigates to type definitions, and uses the test runner natively.

Why not Claude Code here? Claude Code can certainly write implementations. But Junie’s IDE integration means it catches type errors, import issues, and test failures in a tighter loop. The feedback cycle is faster for focused implementation work.

Step 3: Claude Code for Code Review and Refactoring

After a feature is implemented and tests pass, switch back to Claude Code for a broader perspective.

You: "Review the changes I made today.
      Check for security issues,
      inconsistent patterns, and suggest refactoring."

Claude Code reads every modified file, compares against project conventions, identifies cross-cutting concerns, and suggests improvements. It catches things that single-file analysis misses: duplicated logic between services, inconsistent error handling patterns, or API endpoints that bypass authentication.

Step 4: Agent Skills for Domain-Specific Pipelines

When your project needs specialized infrastructure — a RAG pipeline, a vector search index, a payment integration — this is where Agent Skills shine.

Install the relevant skill (e.g., Weaviate Agent Skills), then use Claude Code with the skill loaded:

You: "Set up a Weaviate collection for document embeddings
      with hybrid search. Generate the schema,
      ingestion pipeline, and query functions."

With the Agent Skill active, the generated code uses correct property types, proper distance metrics, and idiomatic query patterns. Without the skill, you’d get code that looks right but uses deprecated API versions or incorrect parameter names.

My Setup: How I Use Multiple Agents Daily

Every project on this portfolio — Agentopia, RunDNA, SAT Crusher, Prompt Garden — was built using this multi-agent approach. Here’s what a typical day looks like:

Morning — Strategic work with Claude Code. I start in the terminal. Big picture changes: new features, architectural decisions, database migrations, deployment configuration. Claude Code handles the cross-file, cross-system thinking.

Midday — Implementation with IDE agents. I open the project in the IDE. Junie or Copilot handles the detail work: writing specific functions, implementing UI components, running tests, fixing linting errors. The tight feedback loop of IDE integration makes this fast.

Evening — Review and cleanup with Claude Code. Back to the terminal for code review. Claude Code reads everything that changed, checks for consistency, and refactors where needed. Then it handles the git commit, push, and deployment.

The filesystem is the integration layer. No special protocol connects these agents. Claude Code writes files; Junie reads them. Junie modifies files; Claude Code reviews them. The codebase itself is the shared state.

The Non-Developer End of the Spectrum

This multi-agent pattern isn’t limited to professional developers. WordPress users are already combining AI agents — one for content generation, another for SEO optimization, a third for design suggestions. The WordPress Cowork model demonstrates that agent composition works across skill levels. The principle is the same: no single agent covers every need.

Key Takeaways

1. Agent combination beats any single agent. The JetBrains guide isn’t marketing — it reflects a real productivity gain. Claude Code’s architectural reasoning plus Junie’s IDE integration produces better results than either alone. This is true for every agent pairing I’ve tested.

2. Match the agent to the task type. Terminal agents for terminal-native work. IDE agents for IDE-native work. Inline agents for inline work. Domain skills for domain work. Forcing a general-purpose agent to do specialized work is like using a Swiss Army knife to fell a tree — technically possible, practically foolish.

3. Domain skills amplify general agents. The Weaviate Agent Skills pattern will spread to every major framework and database vendor. When a tool vendor ships structured skills for AI agents, the quality of generated code jumps from “looks right” to “works correctly.” Install every skill relevant to your stack.

4. The filesystem is enough for coordination. You don’t need a multi-agent orchestration framework. Two agents reading and writing the same files, combined with a human routing tasks to the right agent, is a simple and effective coordination pattern. Keep it simple.

5. Start with two agents, not five. Claude Code plus one IDE agent covers 90% of use cases. Add domain skills as needed. Add inline completion if you want. But the core dual-agent pattern — terminal agent for strategy, IDE agent for execution — is the foundation everything else builds on.

The future of AI-assisted development isn’t about finding the one perfect agent. It’s about building a personal toolkit of agents, each excelling at different tasks, composed into a workflow that fits how you actually work.

Sources:

• JetBrains Blog — Write Modern Go Code with Junie and Claude Code
• Weaviate Agent Skills Repository