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 are available in JetBrains, but support varies by feature and plugin version. GitHub’s current comparison marks MCP as supported while custom instructions, custom agents, subagents, prompt files, and Agent Skills remain preview in JetBrains. Check the Copilot customization support matrix before making a feature part of a team workflow.

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 available, with the important caveat

The careful-work toolkit

Open shared-lib in JetBrains - the careful repo, the one with multiple consumers. Agent mode and MCP are the stable parts of this comparison. Several of the customizations used in this course are available as preview features:

Custom agents, subagents, prompt files, and skills. These are preview or version-dependent in JetBrains. Test the exact plugin version before relying on them.
Plan-first work. You can still apply the planning discipline manually, but do not imply that the VS Code plan-agent workflow has identical support in JetBrains.

Why the support boundary matters

The careful posture still transfers: review diffs, keep approvals tight, and plan before editing. What does not transfer automatically is the exact Copilot customization surface. Keep preview features optional until your team’s supported IDE and plugin versions are confirmed.

What’s still in preview

The preview list

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 follows the shared format; it’s 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.

What the split means in practice

The pattern is worth naming: Agent mode and MCP are the stable foundation in JetBrains; customizations are more version-sensitive. The preview gaps do not block the two-repo job if you keep the review and planning steps explicit, but they can block an identical automation workflow.

Doing the work there

So the practical path through orders-service and shared-lib in JetBrains looks similar at the task level. You open the project, verify which instruction files your plugin discovers, and keep a human-readable plan and diff review. If your flow leans on custom agents, subagents, prompt files, or Agent Skills, verify support first and treat those features as optional until your versions 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.