Track · Frameworks

The PHANTOMS stack

A family of agent-ready starting points for building real products. Learn the pattern, choose and swap each piece by the job it does, and direct AI agents to scaffold TrailMug's order tracker, then verify what they built.

In short

This track is for product managers, founders and developers. You will steer agents that write code. PHANTOMS is a pattern, not one fixed stack. Each letter of the name is one job that most products need done. You will choose each piece by its job. You will leave out the pieces you do not need.

You will write AGENTS.md. This file tells an agent how to work in your repository. You will write briefs that keep a build inside your rules. You will direct agents to build a small order tracker. Then you will read the result and check it. The starter is a learning tool, not a finished product. It has no real user login and no production backup. You learn what is missing.

Key words

  • PHANTOMS: A pattern of jobs and default tools that agents can build a product on. Each letter of the name is one job.
  • AGENTS.md: A file in a repository that tells an AI agent how to work there.
  • AI agent: An AI coding assistant that reads your project and builds tasks. It does the task in front of it. It does not own the plan.
  • Brief: A written task for an AI agent, with its goal, limits and checks.
  • Repository (repo): A folder of files with a full change history.
  • Pipeline: The automatic steps that test and deliver a change.

PHANTOMS is not one fixed stack. It is a way to make the same decisions once, write them down, and then let AI agents build on top of them. Each letter names a job that almost every software product needs done: store the data, serve an API, call a model, show a web page, run the tasks, run agents, search by meaning, keep files. For each job there is a default tool today. In two years some defaults will be different. The pattern stays. The Dojo teaches the pattern, and uses today’s defaults so you can touch real things.

The free public starter at github.com/Curiosity-Corp/phantoms is the learning core. It is a small repository you can clone, run and break. It also holds a file called AGENTS.md that tells an AI coding agent how to work inside it. That file is the heart of this track.

Who this track is for

  • Product managers and founders who will steer agents that write the code and need to choose, direct and judge without typing it themselves.
  • Career changers and juniors who want one coherent, modern set of tools instead of a hundred tutorials that do not fit together.
  • Developers moving to agent work who want a repeatable way to brief agents, set limits and verify results.

You do not need to be a strong coder. You need to read code slowly, run commands in a terminal, and ask “why?” until the answer is plain.

What you will be able to do

When you finish you can take a product idea, choose the pieces it needs and leave out the ones it does not, write the repository rules and the briefs, and let agents scaffold the first version. Then you read what they made. You check the data model against what your customer needs. You check the API against the rules of the product. You check the pipeline for the gates that protect you. You ask the security questions. You write down what you verified and what you did not. That written evidence is the deliverable of the capstone.

You will also be able to explain each choice to people in other roles, because every lesson shows why a piece matters to product (what it lets you promise customers), operations (what it costs to run and recover), security (what it exposes) and cost (money, and also attention).

How the lessons build

# Lesson What you learn
1 The PHANTOMS pattern The idea: jobs, defaults, required versus optional, how to swap pieces
2 The variants Core, web (PHANTOMS+) and terminal (PHANTOMS TUI), and how to pick
3 Bun The runtime and package manager under everything
4 P: PostgreSQL Durable data, constraints, migrations, backups
5 H: Hono The small typed API and its boundary rules
6 A: AI Model access behind a replaceable adapter
7 N: Next.js The web application and the static-export trade-off
8 T: Turborepo The task graph, caching and the CI bill
9 O: OpenClaw Optional agent runtime, and why it is deny-by-default
10 M: Milvus Optional search by meaning, and when not to add it
11 S: SeaweedFS Optional object storage for files
12 Capstone Direct agents to scaffold TrailMug’s order tracker and verify it

Lessons 1 to 3 give you the map and the ground. Lessons 4 to 8 cover the core pieces that run in the starter today. Lessons 9 to 11 cover the optional pieces, where the main skill is knowing when to say no. Lesson 12 pulls everything together.

How it maps to the Dojo ladder

This track mostly supports the Master Developer modules on platform, production launch and AI-agent orchestration. It also helps in Developer weeks 4 and 6: when you defend a roadmap you need to know what a technical choice costs, and when you present a demo you need a working product behind it. It builds on the Way: people write the epics and the roadmap, git is the source of truth, open source comes first, you fix forward, and you disclose AI use.

Pair it with the Working with AI agents track. That track teaches how to brief and review agents in general. This one gives you a concrete repository to practise on.

Time needed

Plan about 25 to 30 hours in total: roughly one to two hours of reading per lesson, plus the practice. The capstone takes a full day if you follow the starter’s guides step by step and write good review notes.

The honest limits

PHANTOMS is a learning starter, not a finished product and not proof that one stack fits every product. The public repository says so itself. The sample app has no real user login, no production backup service and no deployed agent. Part of what you learn here is what is missing, and who must supply it before real customers touch the product. Versions in these lessons follow the starter’s version policy as reviewed on 2026-10-01. Always check the repository for newer ones.

Lessons

Lessons in order

You mark a lesson done at the end of the lesson. This is saved only in this browser, on this device. It is not a grade and not a certificate.

  1. The PHANTOMS patternCore90 min

    PHANTOMS is a family of starting points, not one fixed stack. Learn to choose each piece by the job it does, tell required from optional, and swap pieces as technology improves.

  2. The variants: core, web and terminalCore80 min

    PHANTOMS is a family. Compare the public core starter, the richer PHANTOMS+ web variant and the PHANTOMS TUI variant for terminal apps, and learn how to choose one for a product.

  3. Bun: the runtime and package managerCore90 min

    The toolchain under every PHANTOMS app: what a runtime and a package manager are, why one toolchain helps, how the lockfile protects you, and what to ask when an agent adds a dependency.

  4. P is for PostgreSQLCore100 min

    Durable data for a product: tables, constraints, transactions, migrations and backups in plain words, and how to judge an agent's database design before real customers depend on it.

  5. H is for HonoCore100 min

    The small, typed API that stands between your web page and your data. Learn what an API boundary is, what the starter's Hono code already protects, and what an agent-built route must never skip.

  6. A is for AI: the replaceable adapterCore110 min

    How a product uses language models without being welded to one vendor: the adapter, server-side configuration, budgets, output checks, privacy and an evaluation set that tells you whether the AI feature works.

  7. N is for Next.jsCore100 min

    The web application layer: what Next.js and the App Router do, why the starter builds static files, what that choice gives up, and how to judge an agent-built page for users, accessibility and security.

  8. T is for TurborepoCore80 min

    How a repository with several packages runs its build and check tasks in the right order and skips work it has already done, and why that matters for speed, CI cost and safe agent changes.

  9. O is for OpenClawAdvanced100 min

    The optional agent runtime. Learn what it means to run agents inside a product, why every tool is denied by default, how to fence an agent in, and how to decide whether your product needs one at all.

  10. M is for MilvusAdvanced100 min

    Search by meaning, explained for decision makers: what embeddings and vector search are, what Milvus adds to a product, how it ties to your permissions and deletion promises, and when a simpler option is the better choice.

  11. S is for SeaweedFSAdvanced90 min

    Where a product keeps files: object storage and the S3 protocol in plain words, what SeaweedFS offers, the privacy and recovery rules that apply to uploads, and how to choose between running your own store and using a managed one.

  12. Capstone: TrailMug's order tracker on PHANTOMSAdvanced8 hours

    Orchestrate several AI agent sessions to scaffold TrailMug's order tracker on the PHANTOMS core starter, under a written AGENTS.md policy, hooks and a CI gate. Your spec, briefs, policy and review notes are the deliverable.

All tracks · Learning resources