HealthOS Academy
Engineering work with AI, put on a production line
Four core 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. Beside the ladder sit two optional courses: one for a deeper understanding of approaches to organizing agentic software development and one on agent memory management. 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 four core 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. Beside the ladder sit two optional courses: the fifth, for a deeper understanding of approaches to organizing agentic software development, and the sixth, on agent memory management, recommended after the second.
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, research and the coordinator’s eleven-stage workflow.
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. Lessons 1–20 form the general environment program. Lessons 21–30 deepen the medical specialization:
- 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.
- Chapter IV. The research pipeline in medicine — protocol, search, deposit, publication screening, extraction, critical appraisal, synthesis, a proposed graph change, authorization and stewardship of a continuously updated evidence base.
Prerequisites — the three preceding Academy courses: their concepts are used here without explanation.
Course 5 · optional · Comparative analysis of agentic development methodologies
An optional course for a deeper understanding of approaches to organizing agentic software development in the corporate segment. This is a domain map in the form of a comparative analysis, aimed at forming a fuller understanding of the distinctive features of contemporary approaches.
- Chapter I. The comparison frame — why compare methodologies rather than teach one more way to write code.
- Chapter II. Code-path methodologies — the axes and modes that set a program’s behaviour.
- Chapter III. Paradigm shift and the course line — where the course line sits among other approaches.
- Chapter IV. Trust engineering and the activity operating system — barriers to trust in the intensive care unit, value chains and the regulatory frame.
Prerequisite — the course “AI-driven PDLC”. The course is aimed at the advanced part of the audience.
Course 6 · optional · Agent memory management
An agent’s memory is everything that outlives the session and enters the window again — rules, logs, summaries, reference books — or is built into the model’s weights. The course examines what kinds of such memory exist, who has the right to write to it, how it fails, and how to verify that it actually works rather than being merely declared.
- Chapter I. Taxonomies — the classes of memory, the forms of its storage and their intersection.
- Chapter II. Scenarios and patterns — who writes, how the window behaves, how memory fails, how to measure it and for whom to build it.
- Chapter III. Running examples in full — two complete scenarios: agentic development and the ECG pipeline.
An optional course; its chapters sit at levels 4.0, 5.0 and 6.0. Recommended after the course “Context management for AI agents in team development”; this is a recommendation, not a condition of access.
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.
Courses 1–4 form a ladder: the order 1–4 on this page is the order to take them in, and the prerequisites of any of them are all the courses before it. The fifth and sixth are optional and do not continue the ladder; the sixth is recommended after the second, but this is a recommendation, not a condition of access. 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 25 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.
- The fifth, optional course is a map of the field: it compares approaches to organizing agentic software development and does not replace the third or the fourth course of the ladder.
- The sixth course rests on two running examples — agentic development and the ECG pipeline; the open questions to which the analysis underlying the course gave no final answer are carried into the chapters’ practice.
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. The fifth, optional course is a comparison of approaches, not a fifth application of the same discipline. Verify concrete tool commands and paths against their current documentation.
The ladder starts with the first lesson.