HealthOS Academy
Engineering work with AI, put on a production line
Four courses climb a ladder: from personal AI-development practices — through the context an agent actually sees — to the executable knowledge of a regulated platform and to an environment where a fleet of agents works inside a closed perimeter. The first two steps are tied to neither HealthOS nor a domain.
Paid · registration required · the courses are taken in the personal cabinet.
What is inside
Every lesson ends with three tests and explanations.
Course program
The courses build up, and each one rests on the ones before it. The first two are general — how to run development with AI, and how to assemble the context the agent sees at the moment it answers; neither is tied to a platform or a domain. The third and the fourth show the same discipline inside a regulated ecosystem and inside a closed perimeter.
Course 1 · AI-driven PDLC
How to work with AI as an engineering instrument rather than a “smart autocomplete”. Prerequisites — development experience, Git and the command line.
- Chapter I. Foundations of AI development — the Vibe and Agentic Coding modes, task formulation, context, specification, basic testing of the result, risks and guardrails.
- Chapter II. The AI-driven PDLC concept — the evolution from Waterfall to AI-driven development, Software Engineering 3.0, the intent-centric approach, AI-team roles, agentic patterns.
- Chapter III. Practicum: agentic development in Claude Code and Cursor — how LLMs and the agent mode work, working with agentic tools, subagents, skills and MCP, links and the boundaries of the agent’s contour.
Course 2 · Context management for AI agents in team development
Not about the platform or the environment, but about what the agent sees at the moment it answers. The practices are stated in general terms; where a tool name is needed, examples come in pairs — Cursor and Claude Code.
- Chapter I. The context of an agent: what it is made of — the five layers of context, the permanent layer and its fading, context for a developer, a tester and an analyst, how the layers compete for the window.
- Chapter II. The development team’s context system — rules, README and the decision log; the artefact standard and its owner; the normative layer; task types, implicit sources, quality metrics and the symptoms of context degradation.
- Chapter III. Context at work on a task — planning mode, working from a specification and folding the context, reviewing a context package, whether a document is in force, test design and research.
The prerequisite is “AI-driven PDLC”; beyond it you need experience working with an agent and knowledge of your own domain.
Course 3 · Executable knowledge as the subject of development
How a regulated medical ecosystem works once the subject of the work becomes knowledge rather than the code that executes it.
- Chapter I. The ecosystem: where knowledge lives — the ecosystem’s normative corpus and global conventions, repositories and authority boundaries, developing components with agents, the platform MCP servers, knowledge gathering by agents.
- Chapter II. Extending an existing domain — a program in a domain language, the authorization loop, domain research and the research document, where values come from, threshold calibration, a new consumption surface, and the analysis of a real divergence.
- Chapter III. Standing up a new domain — the boundary between the fixed core and the swappable dialect, the seven-step route, and the list of prerequisites that authoring declarations cannot create.
Course 4. The HealthOS development environment
The earlier courses teach you to work with an agent that has you: your terminal, your browser, your verification. This one is about an environment where all you have is a personal cabinet — and the agent has nothing of you except your assignments. The agent works inside a closed perimeter: no browser, no terminal on the human side, and everything the regulations require of a human must be a button in the personal cabinet.
The course describes the target state of the environment — development is aligned to the course, not the other way around, which is why the course and the environment ship as one event. Three chapters:
- Chapter I. The environment’s configuration — why a closed perimeter is needed, what the configuration consists of, how the gates and topologies are built, what the alternatives cost, and what the MCP servers provide;
- Chapter II. The foundations of a run — the classes of defects and the defences against them; tools, access and queries; the resource lifecycle and the distribution of norms; the task package, the two-phase run and the verification apparatus;
- Chapter III. Boundaries and traces — the specifics of context management, behaviour without a human, the data boundary, roles and secrets, run observability, the response budget — and an honest conclusion about what does not exist yet.
Prerequisites — the three preceding Academy courses: their concepts are used here without explanation.
How to learn
The courses are taken in the personal cabinet: it guides you along a trajectory — chapters, lessons, a knowledge check after each lesson. Every lesson ends with three tests with explanations — of the right answers and the wrong ones alike.
Here, on the Academy site, there are announcements only: the program, the make-up of every course and the terms of subscription. The account, the subscription and access to the content are held by the platform, and signing in happens on its side.
The courses form a ladder: the order on this page is the order to take them in, and the prerequisites of any course are all the courses before it. Start with the first even if you have no need of the platform — the two opening steps are tied to no platform and no domain. Every course is available in full in Russian and English.
Provenance of the material
- The first course draws on three sources: Chapter I on HealthOS experience; Chapter II from the guide “AI-Disrupt PDLC — A concept of transforming the software development life cycle in the AI era” (K. Menshov, aipdlc.ru); Chapter III from work with Claude Code and Cursor.
- The second course grew out of specifications, notes, correspondence, podcasts and articles by various authors, including the HealthOS development team: three modules were taken apart by topic and rewritten into 24 lessons with tests; terminology was reduced to one name per concept, and the practices are stated in general words — tool names appear where the point is unclear without them.
- The third course separated from the first on 29 July 2026, out of its former Chapter IV, once it became clear that work in a regulated environment calls for separate skills. It rests on the platform’s real project practice — normative documents, repositories and service interfaces — with lesson claims sourced in specifications and code; sensitive details are generalized.
- The fourth course describes the target state of the development environment rather than a working system: it rests on that environment’s accepted decisions and specifications, so course and environment ship together.
Scope of applicability. The first two courses describe engineering practices of working with AI and are tied to no specific domain. The third and fourth use one platform as a running example, but their techniques transfer. Verify concrete tool commands and paths against their current documentation.
The ladder starts with the first lesson.