Profound Academy’s Hands-On Course Agent

Profound Academy is a course-building project for creating hands-on technical courses with an AI agent. It deals with the gap between “generate me a syllabus” and “help me build the actual lessons, exercises, starter code, and checks.” The takeaway is simple: the interesting part is not course text generation, but treating course material like a repo the agent can edit and verify.

An agentic course builder is an AI system that can plan, edit, and test course artifacts instead of only drafting prose. That makes Profound Academy relevant to AI coding training and agentic coding work, because the course itself starts to look like software: structured files, constraints, reviews, and testable outcomes.

What Profound Academy is trying to make editable

Profound Academy’s Show HN pitch was concrete. The author described an AI course builder that can create and edit modules, lessons, learning paths, coding exercises, SQL exercises, multiple-choice questions, checkbox questions, written exercises, starter code, and automatic checks for student submissions.

That is a different shape from the usual AI course generator. A syllabus is a plan. A lesson with a broken starter project, hidden assumptions, and weak tests is a product bug.

The useful idea is that a course agent should work on the course body, not just the outline. In a JavaScript foundations course, for example, the agent should be able to add a lesson on array methods, create a small map exercise, include starter code, and attach a check that catches the common “mutates the original array” mistake.

The trap is believing that more generated content means a better course. Hands-on education fails at the seams: setup, ambiguity, test quality, grading edge cases, and whether the learner can recover after getting stuck.

Why developers cared about the Show HN

Developers cared because Profound Academy frames course creation like a coding-agent problem. Claude Code, Anthropic’s coding agent, and Codex, OpenAI’s coding agent, made people comfortable with the idea that an agent can operate over a structured workspace. Profound Academy applies that same mental model to learning material.

That is why the author compared the desired feel to Claude Code or Codex. The agent is not only chatting. It is changing course objects and producing exercises that are meant to be run, checked, and revised.

This also explains the likely objection. If the checks are shallow, the agent can manufacture confidence. A multiple-choice question may look fine at a glance. A coding exercise can pass one happy-path test while teaching the wrong habit.

The practical lesson for Codex users is familiar: do not review the conversation; review the diff and the verification path. Codex, Anysphere’s AI code editor, makes the same point in a different interface with its Agent workflow: agent output becomes useful when it can be inspected against files, commands, and intent.

Where a Codex-style workflow fits

A course workspace benefits from the same small boundaries you would put around a coding agent. Keep the agent close to the artifact, keep edits scoped, and make verification explicit.

Here is a realistic repo rule for a course experiment:

# AGENTS.md

- The agent may edit only /courses/js-basics/** during this experiment.
- Every generated coding exercise must include starter code, a reference solution, and at least one check that fails before the solution passes.
- Do not publish generated lessons until a human completes the exercise from a clean checkout.
- If an exercise depends on external docs or packages, record the exact dependency in the lesson notes.

That is not bureaucracy. It is the smallest useful fence. It tells Codex what “done” means without turning the whole course into a policy document.

A simple verification loop can stay boring:

git checkout -b course-agent-smoke
# Let the agent edit only one lesson and one exercise.
npm test -- courses/js-basics
git diff -- courses/js-basics

The trap is giving the agent the whole curriculum on the first pass. A full course rewrite makes review expensive and hides the important question: did one generated exercise actually teach the concept?

Connect outside systems carefully

If a course agent can grade submissions, fetch student work, or write back to a learning platform, the boundary matters more than the model. The Model Context Protocol, originally introduced by Anthropic, is a standard way for AI applications to connect to tools and data sources through servers with defined capabilities.

For a Profound-style builder, the safe first MCP boundary is read-only. Let the agent inspect a course repo, a problem bank, or anonymized submission examples. Do not let it write grades, email students, or publish modules until the review path is boring and repeatable.

A useful boundary note looks like this:

# MCP boundary note

First experiment: read-only access to course content and sample submissions.
Allowed: list lessons, read exercise files, read anonymized failed submissions.
Blocked: publish lessons, change grades, message students, modify production LMS data.

That same pattern shows up in agent runbook work like Engram Shares AI Agent Runbooks via MCP: give the agent useful context, but make the write path deliberate.

If you are mapping this into the related training topic, keep the emphasis on reviewable artifacts. The goal is not to slow the agent down. The goal is to make the agent’s work legible enough that a human can trust or reject it quickly.

Try it safely with one small course

Try Profound Academy when you already have a course idea and need to turn it into interactive material. It is especially promising for technical topics where exercises can be checked: Python basics, SQL joins, frontend component tasks, API debugging, shell workflows, or data cleaning.

It is overkill if you only need a polished outline, a slide deck, or a one-off internal note. It is also risky if the subject requires careful human judgment and the feedback cannot be tested, such as performance reviews, sensitive compliance training, or high-stakes certification content.

Use this small checklist before trusting generated course work:

• Pick one lesson, not a full course.
• Ask for one exercise with starter code, a reference solution, and checks.
• Run the exercise from a clean checkout as a learner.
• Intentionally submit two wrong answers and confirm the feedback is useful.
• Review the diff, not just the agent summary.
• Keep publishing and grading permissions manual.
• Record what the agent misunderstood so the next prompt or course rule gets better.

The best first experiment is boring on purpose. If one lesson survives that loop, you have a real signal. If it does not, you learned before the course had twenty generated modules.

Common questions

• Is Profound Academy just another AI syllabus generator?

  No. The interesting claim is that Profound Academy works on hands-on course artifacts, not only outlines or lesson prose. As described in the Show HN post, it can create modules, lessons, learning paths, several exercise types, starter code, and automatic checks for submitted work.

• Why should Codex users care about a course builder?

  Codex users should care because the workflow looks like agentic coding in another domain. The agent edits structured material, needs scoped instructions, and should be judged by tests or checks. A course exercise is not far from a small repo task: both need a clear goal, a diff, and verification.

• Where does MCP fit in a course-building agent?

  MCP fits when the course builder needs controlled access to external systems such as repositories, document stores, LMS data, or submission examples. The safe first capability is read-only context. Write actions like publishing a module or changing grades should stay blocked until the review loop is proven.

• What is the main limitation of this approach?

  The main limitation is that generated exercises can look correct while teaching poorly. A test may cover the happy path but miss the misconception the lesson is supposed to address. Human review should include one clean learner run and at least two intentionally wrong submissions.

• When is Profound Academy worth trying?

  It is worth trying when the course has hands-on work that can be checked automatically. Coding, SQL, debugging, and data tasks are good candidates. It is less useful for purely narrative material, vague learning goals, or topics where correctness depends on nuanced human evaluation.

Best ways to use this research

• Best for: Developers and educators evaluating whether an agent can build real exercises, not just course outlines.
• Best first artifact: One generated lesson with starter code, a reference solution, and a check that fails before it passes.
• Best comparison angle: Compare Profound Academy’s course-agent workflow with coding-agent workflows in Codex or Codex: scoped edits, reviewable diffs, and command-based verification.
• Best safety boundary: Start with read-only course and submission context, then add write permissions only after publishing and grading are reviewed manually.

Further reading

• Profound Academy — source
• Model Context Protocol — specification
• Codex — Agent
• OpenAI Codex — repository

Start with one exercise

Pick one technical lesson and ask the agent to build the smallest checkable exercise for it. Then run it like a learner, break it on purpose, and review the diff before you let the course grow.

One methodology lens

One useful way to read this through our methodology is the Plan step: delegate first-pass decomposition and dependency mapping, review the sequencing and assumptions, and keep ownership of scope and priorities. If that split is still fuzzy, the workflow usually is too.