Pricing
Log inGet Started
Training preview · AI Platform Engineering

One engineer.
Four hats. An agentic way to wear them.

In small companies, AI collapsed four jobs into one person: software engineer, platform engineer, AI engineer, ML engineer. This program trains you to carry all four with an agentic working culture: skills, tools, agents, hooks, routines, orchestrators, automation. From toy demos to the production bar.

Train with meSee the full roadmap
8
Phases, foundations to capstone
73
Machine-verified checks across 8 graded missions
8
Tutorial packs, each with a deliberate-failure lab
20
Per-cloud lab guides across 5 delivery targets

The four hats you will actually wear

Not four separate careers. One operator, four capabilities, multiplied by agents. This is what small companies are hiring for now, and what nobody is training properly.

1

Software Engineer

Ship correct, reviewed, tested features with AI agents in the loop, and stay the one accountable for correctness and security.

2

Platform Engineer

Kubernetes, IaC, CI/CD, observability, golden paths. The rails everything (including the AI) runs on.

3

AI Engineer

RAG, agents, tool schemas, evals, guardrails. Turning models into products that survive real users.

4

ML Engineer

Serving, fine-tuning basics, GPU cost, model routing. Enough ML ops to run models, not just call them.

Where you start. Where you finish.

The toy version is the right first brick; pretending you never started simple helps nobody. The job is graduating fast, so every row below is trained as a before and an after.

RAG
Day oneChunk, embed, retrieve. It answers on your demo.
Production barQuery rewriting, hybrid search, re-ranking, tenant filters, bad-chunk failure modes, and retrieval metrics you trust before you trust the answer.
Agents
Day oneLLM + tools in a loop. "Just let it figure things out."
Production barScoped tools, explicit state, hop budgets, dedup and supervision, escalation paths. Autonomy you can afford and audit.
Prompting
Day oneStudy prompts forever; the prompt IS the product.
Production barPrompting as interface design: structured outputs, tool schemas, untrusted-input envelopes. Necessary craft, not the whole job.
Quality
Day one"It works on my demo."
Production barGolden sets, CI eval gates, online metrics. You know when it is wrong and what happens next.
Runtime
Day oneOne API key straight to a model vendor.
Production barGateways, serving, budgets, fallbacks, cost per request. The model proposes, the platform decides.
Way of working
Day oneOne tab, one chat window, copy-paste engineering.
Production barA fully agentic environment: skills, hooks, routines, orchestrators, and automation doing the repetitive work while you do the judgement work.

The agentic working culture, taught as a subject

You do not just learn about agents; you work inside a fully agentic environment from week one. Every layer below becomes muscle memory, with a concrete example you build.

Skills
Reusable, versioned playbooks your agents load on demand
A "ship a migration" skill that encodes your review, test, and rollback steps once.
Tools
Scoped, least-privilege capabilities agents can call
A read-only metrics tool an agent may call freely, and a deploy tool it may not.
Agents
Bounded workers with explicit state and budgets
A triage agent with a 6-hop budget that escalates instead of guessing.
Hooks
Guardrails that fire on events: validate, block, format
A pre-commit hook that refuses any edit to an already-applied migration.
Routines
Scheduled agents doing recurring work unattended
A nightly routine that sweeps dependency CVEs and opens the fix PR.
Orchestrators
Fan-out, pipelines, supervisors, verification
Review across five dimensions in parallel, then adversarially verify each finding.
Automation
CI/CD, GitOps, and evals wiring it all together
An eval gate in CI that fails the build when retrieval recall drops.

The training roadmap

Eight phases over eighteen weeks, each with assignment packs and tutorial packs. Open a phase for the summary, or follow it through to the full brief, rubric, and lab variants.

You cannot design agentic systems for other people while you personally still work in a single chat window. This phase rewires how you work first, because every later phase assumes you can delegate the repetitive half of engineering and keep the judgement half.

  • The four-hats reality: why small teams need one person across SWE, platform, AI, and ML
  • Skills, tools, agents, hooks, routines, orchestrators, automation: what each is for and when to reach for it
  • Everything-as-code: repos, worktrees, PR flow, agent-written changes you stay accountable for
  • Setting up your own agentic workspace: editor agents, CLI agents, guarded hooks, scheduled routines
  • Where agents must not be trusted, and how you enforce that on day one
Outcome:You run daily engineering through agents with guardrails, not chat windows. 10 verified checks 1 tutorial pack
Full brief, rubric and labs

Five delivery targets, one syllabus

The platform labs ship in per-target variants so you train on the stack you will actually run. Pick one as your primary; the concepts transfer to all five.

EKS · Bedrock or self-hosted vLLM · OpenSearch · Terraform

IAM boundaries as the control plane, OpenSearch for hybrid retrieval, Bedrock or vLLM on g5/p4d for serving, cost allocation tags into Cost Explorer.

Every assignment pack contains

  • A realistic scenario with a business constraint, not a toy prompt
  • Definition of done that a script or eval can verify
  • Per-cloud variants (AWS / GCP / Azure / on-prem / agnostic) where infrastructure is involved
  • A rubric: what a pass, a strong pass, and a fail look like

Every tutorial pack contains

  • Step-by-step build with the reasoning, not just the commands
  • The failure you will hit on purpose, and how to read it
  • What to measure at the end to prove it works
  • Extension exercises for going deeper solo

What we deliberately skip

A program is defined as much by what it refuses to teach. These are the rabbit holes that feel productive and are not.

Infinite prompt-engineering courses
Enough prompting to design interfaces, then move to retrieval quality and evals.
Chasing every new agent framework
Control of state, tools, and budgets. Graphs help, but the judgement transfers across every framework.
Fine-tuning as a first resort
Better context and retrieval first. Fine-tune when you can prove the gap needs it.
Benchmarks that do not look like your traffic
A golden set built from your own real queries, however small it starts.

Right constraints

The model proposes, the platform decides. Autonomy is a budget, not a vibe.

Reliable evaluation

"Works on my demo" is not evidence. Golden sets and CI gates are.

Right context

Retrieval quality, schemas, and policies beat a thousand prompt tweaks.

Questions people actually ask

Ready to train, or want this for your team?

This page is the preview. The full program runs as guided cohorts and 1:1 mentorship: live sessions, reviewed assignments, and a capstone you defend. Individuals and companies both welcome; scope and schedule are agreed up front.

Start the conversationFree self-study roadmaps first