Open weight models are having a moment, driven by control, choice, and cost. Hybrid and local AI are now getting serious looks, so JetBrains teamed up with DeepLearning.AI on a free AI Coding Workflows: Hybrid to Local course that covers the ideas and options.
The course is now available and uses PyCharm and its AI Chat. Here’s a peek into the course.
Claude Code: Subagents and cheaper models
We start the course with, well, not-local. Instead, we use what you already know – Claude Code and its Anthropic models – to introduce some of the techniques and “levers” that help bring choice, control, and even cost reduction. (Yes, I wrote emdashes.)
We did a previous course on Spec-Driven Development (SDD) so of course, we wanted to start there. Smaller models struggle with big, open-ended “vibe coding.” Dividing and bounding the work keeps smaller models on track. Important note: this course’s example app is really basic. You might say “that’s too easy.” But that’s part of the takeaway: big brain models can do the upfront work, forming right-sized steps for smaller models.
We then illustrate this division with a Claude Code subagent. The main chat prompt implements each roadmap phase in a fresh subagent, to better manage context. This then gives the payoff: a cheaper model for the implementer. Use a “big brain” (Opus) for main conversation thinking and a “little brain” (Haiku) for implementation.
Each lesson finishes with metrics about the change in tokens, turns, cost, and estimated wall time. Which brings us to the main course goal: learning the ideas instead of the specifics, which change weekly.
New agent, inference, and model
That covers the four levers:
- Specs shaped for the model size
- Specialist subagents to divide work
- Cheaper models for the routine work
- Collect metrics as evidence to guide thinking
The course then introduces choice and control:
- New agent: OpenCode
- New inference router: OpenRouter
- New model and inference host: DeepSeek (via OpenRouter) by moving to a new agent (OpenCode) using inference routing (OpenRouter) to inference hosting and models (DeepSeek)
We first move to OpenCode, running in PyCharm. JetBrains wants our IDEs to be open platforms for agents and models. This makes the move from Claude Code to OpenCode straightforward: it’s the same UI. We add OpenRouter (a paid step), connect it to OpenCode, and choose DeepSeek as a model.
Next we repeat our sequence: all in one chat, then context isolation using a subagent. But this time, with a different agent and model.
We finish by making a dedicated implementer subagent in Markdown. This gives quite a number of levers of control: in the frontmatter for mandatory controls, and in the subagent body for “persuasion” guidance. Most importantly, we have the implementer use the smaller DeepSeek v4 Flash model as the “little brain.”
Compared to the Claude Code version, the metrics were, unsurprisingly, a lot cheaper.
Hybrid and Local
Now for the main attraction: for routine development, can we do some – or even all – of the work locally?
We start with a lesson on setting up local AI: LM Studio as the inference server and Gemma 4 12B as the local model, targeting a 32 GB laptop.
We then configure the implementer subagent to use this local Gemma 4 model, promoting DeepSeek v4 Flash from last lesson’s “little brain” up to “big brain.” The results? Quite good, as it turns out.
Then the big test: fully local, with Qwen 3.5 27B as the “big brain.” The results: better than expected, showing that guardrails help.
How did hybrid and local do? Both of these lessons finish with a review of the metrics. That’s one of the big course takeaways: look at the evidence. You can see how small models struggle, and see the effect of helping them succeed.
Hybrid and Local AI Are Heating Up
Much thanks to DeepLearning.AI both for working with us again and for pushing to get this out fast. This topic is now red-hot in the news: Sovereign AI, privacy and security, and of course cost. The innovations are coming really fast and it is important to have a gentle introduction to the fundamentals.
We’ll do more updates here on Local AI for control, choice, and cost. Most of all, we at PyCharm believe in the human-in-the-loop. Stay tuned for more on this.
Facts Only
* JetBrains and DeepLearning.AI created a free course titled "AI Coding Workflows: Hybrid to Local."
* The course utilizes PyCharm and its AI Chat.
* The curriculum begins with Claude Code and Anthropic models.
* The workflow involves using "big brain" models (Opus) for planning and "little brain" models (Haiku) for implementation.
* The course introduces OpenCode as an agent and OpenRouter as an inference router.
* DeepSeek models are utilized via OpenRouter.
* Local AI setup involves LM Studio as the inference server.
* Local models used include Gemma 4 12B and Qwen 3.5 27B.
* Hardware target for local setup is a 32 GB laptop.
* Lessons include metrics on tokens, turns, cost, and estimated wall time.
Executive Summary
JetBrains and DeepLearning.AI have launched a free educational course focused on transitioning AI coding workflows from cloud-based models to hybrid and local environments. The curriculum emphasizes a tiered intelligence approach, where high-capability "big brain" models handle high-level architectural planning and specifications, while smaller, more cost-effective "little brain" models execute the routine implementation. This strategy is designed to optimize for cost and control while maintaining productivity.
The technical progression moves from proprietary ecosystems like Claude Code to open platforms, utilizing OpenCode and OpenRouter to integrate models such as DeepSeek. The final stages of the course demonstrate fully local execution using LM Studio with Gemma 4 and Qwen models on consumer-grade hardware (32 GB RAM). Success is measured through empirical metrics, including token usage and execution time, to provide evidence of the viability of local AI for routine development.
Full Take
This educational initiative treats AI integration as a modular engineering problem rather than a monolithic tool adoption. By framing the workflow as a series of "levers"—spec shaping, subagent specialization, model tiering, and metric collection—the approach shifts the developer's role from a passive user to an orchestrator of intelligence.
The strength of this framework lies in its pragmatism: it acknowledges that while frontier models are superior for reasoning, they are often overkill for implementation. By demonstrating a path toward "Sovereign AI," the curriculum empowers the user to decouple their productivity from specific vendor APIs, reducing both financial cost and systemic dependency.
However, the narrative leans heavily on the "human-in-the-loop" ideal. While it champions agency, the actual workflow described—breaking tasks into "right-sized steps" for smaller models—essentially turns the human developer into a prompt engineer and quality assurance manager for an ensemble of bots. The shift toward local AI is presented as a victory for privacy and cost, but it also necessitates a shift in hardware requirements and local configuration management.
Who benefits most? The developer gains autonomy and cost savings; the IDE provider (JetBrains) secures its position as the essential orchestration layer where these models meet the code.
Bridge Questions:
1. Does the overhead of managing a hybrid local/cloud ensemble eventually outweigh the cost savings of using smaller models?
2. At what point does "spec-driven development" stop being a productivity booster and start becoming a bureaucratic layer between the developer and the code?
3. How does the reliability of "little brain" models scale when moving from "really basic" example apps to complex, legacy enterprise codebases?
Counterstrike Scan: A coordinated campaign to push local AI would typically weaponize fear of cloud data leaks or "vendor lock-in" to force an immediate migration to a specific local toolset. This content does not match that pattern; it presents a gradual, evidence-based transition focused on workflow optimization.
Sentinel — Human
This text appears to be an authentic summary or promotional overview of a technical course, blending real product names and structured experimentation with explanatory commentary.