The same work in JetBrains

Picture the teammate who never opened VS Code — they’ve lived in a JetBrains IDE their whole career, and they’re not going to switch editors to use Copilot. Good news: they don’t have to. Copilot’s agent runs in JetBrains too, and the work you’ve done across this course mostly transfers as-is. “Mostly” is the operative word, and the point of this lesson is to make the exceptions precise rather than wave at them.

Agent mode and MCP arrived in JetBrains as a public preview (the same wave also brought them to Eclipse and Xcode). So the foundation — an autonomous agent you can talk to, plus the ability to wire in external tools — is present. What’s matured past preview, and what’s still catching up, splits cleanly along feature lines. Here’s the split, mapped onto the work you actually did.

The thing that doesn’t change: your rules

Start with the reassurance, because it’s the biggest one. In the Rules chapter you wrote convention files — an AGENTS.md, and the CLAUDE.md you may have carried over from another course — so Copilot’s first draft would already match how each repo does things. JetBrains auto-discovers and reads those same files. You don’t re-author anything, you don’t flip a JetBrains-specific equivalent, you don’t keep a second copy in sync. The AGENTS.md at the root of shared-lib and orders-service, and the CLAUDE.md if you have one, are picked up the moment you open the project.

This is the whole convergence thesis paying off again, from a different surface. The conventions are a property of the repo, not the editor — so the careful work you did teaching the agent your team’s idioms is exactly as valid in JetBrains as it was in VS Code. The single most expensive context-engineering work in the course travels for free.

What’s generally available

Open shared-lib in JetBrains — the careful repo, the one with twelve consumers. The agent features you reached for during the careful Act-1 work are generally available here:

• Custom agents. The library-reviewer agent you built in the Custom agents chapter — the persona scoped to reviewing changes against the consumers — is GA in JetBrains. You invoke it and it behaves as it did in VS Code.
• Sub-agents. The fan-out pattern, where a coordinating agent spins up sub-agents to check each consumer for breakage, is GA. The orchestration you used to survey twelve services holds up here.
• The plan agent. Plan-first work — the move you leaned on hardest in shared-lib because the blast radius was high — is GA. You can still get a structured plan before a line is written, which is exactly the discipline that repo demands.

So the careful posture — the one the high-stakes library work required — is fully available in JetBrains. That’s not an accident of which features shipped first; the GA set happens to cover the moves you make when the stakes are high, which is the work you least want to be doing on preview footing.

What’s still in preview

Now the exceptions. A handful of features are in JetBrains as preview, which means: know they exist, try them, but don’t build a team’s required workflow on them yet. As of writing, in JetBrains these are preview:

• Agent Skills. The SKILL.md you packaged in the Skills chapter — the team’s audit-event convention as a portable, invokable procedure — is preview in JetBrains. The skill file itself is the same cross-tool standard; it’s the JetBrains support for it that’s still maturing.
• Agent hooks. The deterministic gates on a custom agent are preview.
• Inline agent mode. Driving the agent from inline chat in the editor, rather than the side panel, is preview.
• The Copilot CLI agent inside JetBrains. Reaching the CLI from within the IDE is preview — which is fitting, since the CLI itself is this chapter’s footnote.

The pattern is worth naming: the core of agentic work — agent mode, MCP, custom agents, sub-agents, plan-first — is solid in JetBrains, and the things still in preview are the newer conveniences layered on top. None of the preview gaps block the actual two-repo job. They change how smooth a few steps feel, not whether you can do them.

Doing the work there

So the practical path through orders-service and shared-lib in JetBrains looks almost identical to the VS Code version. You open the project; the agent reads your AGENTS.md without being asked. For the careful library change you reach for the plan agent and your custom reviewer agent and its sub-agents — all GA, all behaving as they did. For the faster app work you let the agent run, the same loosened posture you used before. The two spots where you’d notice a difference: if your flow leaned on Agent Skills or agent hooks, those are preview, so treat them as nice-to-have rather than load-bearing until they mature.

The honest summary for that JetBrains teammate: you lose almost nothing that matters, and the things you do lose are previews that’ll close the gap. The judgment you built — matching autonomy to blast radius — is editor-independent; it was never a VS Code feature in the first place.

There’s one more surface, and it’s the smallest: the same assistant, reachable from a terminal. Next: the terminal footnote — Copilot CLI.