# course-design

Adopt this skill: https://proskills.md/skills/other/madhvantyagi-gnos-skills-course-design

Page: https://proskills.md/skills/other/madhvantyagi-gnos-skills-course-design
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/course-design/SKILL.md
size: 5699
upstream: https://github.com/madhvantyagi/gnos/blob/main/skills/course-design/SKILL.md

````text
---
name: course-design
description: "Design and revise a course's goal, progression, prerequisites, and sources. Record depth and duration, validate and enroll course.json, then hand the current topic to lesson-design."
---

# Course design

Use this skill when a learning goal needs several sessions or a sequence of
prerequisites. Answer a small local question directly in chat. For a course,
design the progression from the learner's starting point to the agreed goal.
Lesson design develops each topic into a complete lesson.

## Establish depth and duration

Before designing, establish how deeply the learner wants to study and how
much time they have. Ask for whichever information they have not already
provided. Record both in `course.json`:

- `depth`: `survey` for understanding the central ideas and connections,
  `working` for applying them independently, or `mastery` for justifying
  methods and examining their limits.
- `length`: the learner's intended duration, such as one session, six weeks,
  or a term.

Use these answers to choose the scope, pace, research, and useful media.
A shorter course should cover fewer ideas well rather than abbreviating every
explanation.

## Research and plan the course

Read [course-research.md](references/course-research.md). Consult accessible
books, course materials, or documentation to check prerequisites, definitions,
and suitable exercises. Record what you actually opened and which sections
the course will use.

When a current topic or its blocking prerequisite might have a Khan Academy
resource, send lesson design to check [the Khan Academy skill](../khan-academy/SKILL.md).
Record the verified item as a course source, add its ID to that topic's
`resource_ids`, add the Khan skill route to the topic's `skill_routes`, and use
representation kind `khan` when the plan names one; leave clip selection and
placement to lesson design. Do not expand the course around a broad Khan match
when the learner needs one bridge.

Read [course-contract.md](references/course-contract.md) and write
`course.json`. Organize chapters and topics so their outcomes build toward the
course goal. Identify the current topic and leave uncertain later topics
provisional.

Read the selected subject guide through `skills/subject/SKILL.md` and its
assigned teacher's `SOUL.md` when one exists. Use its matching subfield to
check the starting case, difficult distinction, and evidence the topic needs.
Leave media, worked examples, and block order to lesson design using
[representation choices](../lesson-design/references/representation-choices.md).
Keep existing representation plans binding until explicitly revised; new plans
need not prescribe media before the lesson's reasoning is developed.

## Validate and enroll

Validate the plan and enroll it in the same turn:

```bash
python3 skills/course-design/scripts/validate_course.py <course.json>
python3 skills/learner-tracking/scripts/learner_state.py init <learner>
python3 skills/learner-tracking/scripts/learner_state.py enroll <learner> --course <course.json>
```

Use the learner's name, or `learner` when no name was given. Confirm that the
canonical workspace at `learners/<learner>/courses/<course-id>/course.json`
exists before handing the topic to lesson design. Do not stop at saving a plan
under `outputs/`; enroll it so lesson design can use the canonical course.

Briefly explain the course goal, agreed depth and duration, and current topic.
Describe what the current topic will help the learner understand.
Use enough detail to make the plan understandable without reciting its fields.

## Hand the current topic to lesson design

After enrollment, continue with [lesson-design](../lesson-design/SKILL.md).
Read its [teaching reference](../lesson-design/references/lesson-design.md) and
load the current topic, teacher, subject guidance, and learner evidence. When
using the context loader, switch to lesson authoring explicitly:

```bash
python3 skills/learning-orchestrator/scripts/assemble_context.py --subject <subject> \
  --learner <learner> --course-id <course-id> --mode lesson
```

Lesson design must develop and review the explanation before publishing a
ready lesson. Do not turn topic outcomes or representation purposes into short
paragraphs and call that the lesson. Its finished content belongs in
`lessons/<lesson-id>/lesson.json`. Course design stops authoring at the plan;
the same host continues the work under lesson design's instructions.

## Show the finished lesson

**Ask "Do you want to see the course now?" unless the learner already requested or
approved it. This question controls opening the page, not whether lesson
design runs. On yes, use [course-viewer](../course-viewer/SKILL.md) and render**

```bash
python3 skills/course-viewer/scripts/render_viewer.py learners/<learner>/courses/<course-id> --require-current-lesson
```

Return the `portal/` link with the current lesson to open. An explicit request
for only an outline may render before a lesson exists; identify that result
as the course outline. For teaching, complete the lesson handoff before
delivering the page. Re-render after changes to the lesson or its artifacts.

If lesson design discovers a missing concept, source, or topic boundary,
revise that part of the course. Record the reason in `revision_notes`, validate
and enroll the revised plan, then return to lesson design. A media change stays
with lesson design unless it changes a binding representation plan.

Use learner evidence to revise future topics as the course progresses. Preserve
stable IDs and record why the sequence, sources, or scope changed, following
[course-contract.md](references/course-contract.md).
````

## File: README.md
upstream: https://github.com/madhvantyagi/gnos/blob/main/README.md

````text
<p align="center">
  <img src="assets/hero.png" alt="GNOS artwork" width="100%" />
</p>

<p align="center">
  <strong>Turn your coding agent into a teacher that builds a course around you.</strong>
</p>

<p align="center">
  <a href="https://github.com/madhvantyagi/Gnos/stargazers"><img src="https://img.shields.io/github/stars/madhvantyagi/Gnos?style=social" alt="Star GNOS on GitHub" /></a>
  &nbsp;·&nbsp;
  <a href=".codex-plugin/plugin.json">Codex plugin</a>
  &nbsp;·&nbsp;
  <a href=".claude-plugin/plugin.json">Claude Code plugin</a>
  &nbsp;·&nbsp;
  <a href=".cursor-plugin/plugin.json">Cursor plugin</a>
  &nbsp;·&nbsp;
  <a href="LICENSE">MIT license</a>
</p>

## What is GNOS?

GNOS is a teaching harness made of skills, scripts, and visual tools. Tell it what you want to learn. For a course, it asks how deep you want to go and how much time you have, uses course materials such as university syllabi, textbooks, and documentation to plan a route, then builds the first lesson. Subagents make its lesson blocks; GNOS reviews and joins them before asking if you want to see the course.

As you work, GNOS records what you tried, where your reasoning broke, and what you could do independently. It uses that evidence to adjust upcoming lessons and exercises. The course grows with you.

## Star history

<p align="center">
  <a href="https://github.com/madhvantyagi/Gnos/stargazers">
    <img src="assets/star-history-light.svg" alt="GNOS GitHub stars over time, based on recorded daily additions" width="100%" />
  </a>
</p>

## Study your course in a browser

Just ask GNOS to show your course in the browser. It routes the request to the `course-viewer` skill, which renders the curriculum and current lesson as a study page. Open a topic to read its lesson, work through exercises, and follow its sources and learning materials.

<p align="center">
  <img src="assets/course-viewer-rl-to-grpo.png" alt="GNOS course viewer showing the RL to GRPO curriculum and selected topic details" width="100%" />
</p>

<p align="center"><em>Browse the curriculum and open a topic to study it in the course viewer.</em></p>

A true slideshow can't run inside a README, so here is the closest thing — click each frame to expand it:

<details>
<summary><strong>Frame 1 · Simulation</strong> — run route policies on the building grid</summary>
<br />
<p align="center">
  <img src="assets/lesson-simulation.png" alt="Grid simulation where the learner runs courier route policies" width="680" />
</p>
</details>

<details>
<summary><strong>Frame 2 · Lesson video</strong> — watch a narrated lesson block</summary>
<br />
<p align="center">
  <img src="assets/lesson-video.png" alt="Rendered lesson video on the Bellman equation" width="680" />
</p>
</details>

## Why does learning with AI still feel hard?

Frontier models know a great deal, but a good answer is only one part of teaching. Learning a large subject also takes a coherent route, a diagnosis of mistakes, and a way to make abstract ideas visible. GNOS gives a coding agent that structure.

| The problem | What GNOS does |
| --- | --- |
| **The voice feels generic** | Subject-specific teachers use `SOUL.md` files to guide their explanations and judgment. This builds on my earlier [SOUL.md project](https://github.com/madhvantyagi/SOUL.md). |
| **Lessons lose the thread** | A living course plan and learner records keep topics, prior attempts, and the next step together across sessions. |
| **A correct answer gets mistaken for understanding** | Learner tracking distinguishes seeing an explanation, solving with help, and solving independently; the next exercise responds to the evidence. |
| **Everything becomes text** | GNOS can choose diagrams, images, simulations, narrated animations, or PDF handouts when that format helps explain the idea. Visual tools and media dependencies vary by environment. |

## Get started

Start with Git, Python 3, and your preferred coding agent installed. Codex, Claude Code, and other agents use a local checkout. Cursor adds the skills from Customize, in the section below.

Clone GNOS once and use this folder as your learning workspace:

```sh
git clone https://github.com/madhvantyagi/Gnos.git
cd Gnos
```

### Codex

Install the [plugin](https://developers.openai.com/codex/plugins/) through the Codex CLI:

```sh
codex plugin marketplace add madhvantyagi/Gnos --ref main
codex plugin add gnos@gnos
```

Start a new Codex session in `Gnos`, or open the folder in the Codex app and start a new task. Ask:

> Use GNOS. Read `skills/learning-orchestrator/SKILL.md` in this workspace and teach me [topic].

### Claude Code

From `Gnos`, launch Claude Code with the plugin:

```sh
claude --plugin-dir .
```

Enter `/gnos:learning-orchestrator Teach me [topic]`. Repeat the launch command each session; [`--plugin-dir` is session-only](https://code.claude.com/docs/en/plugins/create#load-a-plugin-for-one-session).

### Cursor

1. Open **Customize**.
2. Add this repository:

   ```text
   https://github.com/madhvantyagi/Gnos
   ```

3. Open a new agent chat and send:

   > Use GNOS. Read `skills/learning-orchestrator/SKILL.md` and teach me [topic].

That installs the teaching skills. These buttons install the diagram servers:

[![Add Excalidraw to Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en/install-mcp?name=excalidraw&config=eyJ0eXBlIjoiaHR0cCIsInVybCI6Imh0dHBzOi8vbWNwLmV4Y2FsaWRyYXcuY29tL21jcCJ9)

Excalidraw

[![Add Pinepaper to Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en/install-mcp?name=pinepaper&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIi1wIiwiQHBpbmVwYXBlci5zdHVkaW8vbWNwLXNlcnZlckAxLjYuNyIsIi1wIiwicHVwcGV0ZWVyQDI1LjkuMCIsInBpbmVwYXBlci1tY3AiXSwiZW52Ijp7IlBJTkVQQVBFUl9FWEVDVVRJT05fTU9ERSI6InB1cHBldGVlciIsIlBJTkVQQVBFUl9IRUFETEVTUyI6InRydWUiLCJQSU5FUEFQRVJfVE9PTEtJVCI6ImFnZW50IiwiUElORVBBUEVSX1ZFUkJPU0lUWSI6ImNvbXBhY3QiLCJQSU5FUEFQRVJfU0NSRUVOU0hPVF9NT0RFIjoib25fcmVxdWVzdCJ9fQ%3D%3D)

Pinepaper

Approve Excalidraw and Pinepaper if Cursor asks. To keep a course in a local folder, clone the repository, open that folder, and send the same message. The folder loads the same skills.

### OpenCode, Antigravity, and other agents

Open the `Gnos` folder as your workspace. For **OpenCode**, run `opencode` from that folder; for **Antigravity**, open it in the editor. Send:

```text
Read AGENTS.md, then skills/learning-orchestrator/SKILL.md.
Use GNOS to teach me [topic]. Keep courses and progress in this workspace.
```

This uses GNOS directly from its files; your agent needs local file and terminal access. [OpenCode also loads `AGENTS.md` automatically](https://opencode.ai/docs/rules/). Keep the repository together so its teachers, references, and scripts remain available.

**Visual tools:** Codex and Claude Code load the server definitions in [`.mcp.json`](.mcp.json). In Cursor, use the Add to Cursor buttons above, or open the folder so [`.cursor/mcp.json`](.cursor/mcp.json) loads the same servers. For [OpenCode](https://opencode.ai/docs/mcp-servers/) or [Antigravity](https://antigravity.google/docs/mcp), configure those servers using the host's MCP format. Pinepaper needs Node.js/npm; image generation uses your agent's available tools, while PDF and video lessons need their own dependencies.

For a course, share your goal, starting point, depth, and available time. To study the result, ask: **“Show my course in the browser.”**

## Help it grow

GNOS grows through its users. If it helps you learn something hard, [share what worked or broke](https://github.com/madhvantyagi/Gnos/issues) and [star the repo](https://github.com/madhvantyagi/Gnos/stargazers) so others can find it.
````
