Get started

AI engineering, step by step.

Four core paths that take you from calling a model to running an AI product, and six career routes for the jobs they lead to. Each lesson points to a hands-on lab in a real terminal, checked on the state of the machine, not on clicks.

4 core paths · 6 career routes

Four core paths

Domain 01

interfaces, grounding, evaluation, production

Building and Deploying AI Applications

Follow an AI feature from its first request to a model, through grounding and testing, to running it for real users. The application is everything around the model, not the model alone.

12-lesson path · 13 h

6 lessons listed · 5 with a lab · 8 labs · 1 h 56 min

  1. Model Interaction Contracts

    Send a request, set the system instructions, and agree on what comes back before anything depends on it.

  2. Structured Generation Contracts

    Make the model return data a program can read, and let it call your functions.

  3. Evidence Representation

    Turn documents into vectors so the right passage can be found for a question.

  4. Retrieval and Freshness

    Keep what the model is shown current, and know when an answer rests on stale evidence.

    No lab for this lesson yet.

  5. Behavioral Evaluation Gates

    Write tests for behaviour that is not deterministic, and stop a release that fails them.

  6. Serving and Recovery

    Limits, retries, health checks and restarts: what keeps the service answering when something breaks.

  7. 6 more lessons in this path are on the way.

Domain 02

full stack, data, architecture, reliability, scale

Software Engineering Fundamentals

A coding assistant saves typing, not judgment. Learn the decisions that stay yours: how an application is delivered, where its data lives, how it is split up, how it is secured, and who owns it when it runs.

13-lesson path · 12 h 10 min

5 lessons listed · 5 with a lab · 10 labs · 2 h 37 min

  1. End-to-End Application Delivery

    Take a change from a commit to a running container through an automated pipeline.

  2. Data Lifecycle and Storage

    Choose a store, shape the records, and understand what happens to the data over time.

  3. System Architecture and Boundaries

    Put a proxy in front, separate the services, and decide what may talk to what.

  4. Secure and Resilient Systems

    Give each part only the access it needs, and harden what you ship.

  5. Production Scale and Service Ownership

    Set reliability targets, measure them, and scale on purpose.

  6. 8 more lessons in this path are on the way.

Domain 03

frame, plan, delegate, verify, improve

Agent-Assisted Engineering

A coding agent is only as dependable as the setup around it: the task, the context, the tools, the feedback and the point where it stops. Build that setup and use it on real repository work.

16-lesson path · 15 h

8 lessons listed · 7 with a lab · 9 labs · 2 h 23 min

  1. Task Framing

    State the goal, the limits and the finish line so an agent can start from something concrete.

  2. Evidence-Based Planning

    Have the agent read before it acts, and plan from what it found.

  3. Agent Workbench

    Give an agent the tools it needs through a small, well-defined server.

  4. Instructions and Memory

    Keep the rules and the state a session needs, and drop what it does not.

  5. Runtime Feedback

    Read logs and output so the agent corrects itself from what really happened.

  6. Verification and Review

    Check the result independently, and read the history to see what changed and why.

  7. Isolated Delegation

    Hand parts of a job to separate agents, each with limited authority.

  8. Durable Improvement

    Turn a lesson from one task into a rule that helps the next one.

    No lab for this lesson yet.

  9. 8 more lessons in this path are on the way.

Domain 04

outcomes, evidence, risk, metrics, feedback

Product Judgment and Delivery

Before building, decide which outcome matters, what supports it and what could go wrong, and how you will know the change helped. Then ship it in small, testable steps and own what comes back.

8-lesson path · 9 h 10 min

8 lessons listed · 4 with a lab · 4 labs · 1 h 2 min

  1. Outcomes Before Output

    Start from the result someone needs, not the feature list.

    No lab for this lesson yet.

  2. Workflow Discovery

    Watch how the work is really done before you decide what to automate.

    No lab for this lesson yet.

  3. Assumptions and Risk

    List what you are betting on, and test the riskiest bet first.

    No lab for this lesson yet.

  4. Testable Slices

    Cut the work into pieces that each prove something on their own.

  5. Executable Specifications

    Write the expected behaviour as a check that can run.

    No lab for this lesson yet.

  6. Success Metrics

    Pick numbers that show whether the change worked, and record them from day one.

  7. Release Strategy

    Release in stages, with a way back.

  8. Feedback Ownership

    Decide who reads the signals after release and who acts on them.

Practice that runs through every path

Whatever the path, the same four habits turn a lesson into work you can rely on.

  1. Direct the agentGive an assistant a clear task, the context it needs and a place to stop.
  2. Verify independentlyCheck the result with your own tests and your own reading, not the assistant's word.
  3. Make the product decisionDecide what is worth shipping, what is too risky and what can wait.
  4. Own the next iterationRead what comes back after release and turn it into the next change.

Six career routes

A route lists the paths to take, in order, for one kind of role. Finishing the labs shows you can do the work; it does not guarantee a job.