Your AI Learning Roadmap and Project Ideas

You have come a long way. In the first course you learned how models work and how to write prompts. In the second you built an Angular and Node app that talks to Claude: chat, streaming, caching, PDFs, tools and structured output. In this course you added your own data with RAG, built agents, connected tools through MCP, tested your work, protected personal data and made it ready for production.

This last lesson is different. There is no new technology. Instead, you will look back at the skills you have, see how they fit together, plan what to learn next, and choose a project that proves your skills to an employer or a client. The task is to write a project plan. Planning well is a skill, and it saves weeks.

What you can do now

Look at the list of pages in your AI Lab. Each one is a skill you can explain and repeat:

• Call a model from a server and keep the key secret, handle errors and stream replies.
• Control cost with caching, limits and token counting.
• Get reliable JSON out of a model and validate it.
• Chunk, embed and search documents, with keywords, vectors or both.
• Answer from your own data with citations that the server checks.
• Build agents with tools, memory, step limits and token budgets.
• Build and use an MCP server, with permissions, approval and defence against prompt injection.
• Test an AI app with a golden set, protect personal data and run the feature in production.

This is a real set of skills. Many people can write a prompt. Fewer can build a system that is tested, safe and affordable. That second group is who companies look for.

The big picture

Every AI product you will meet is made of the same few parts, arranged differently:

1. A model that reads and writes text (or images, audio).
2. Context that you give it: instructions, examples and retrieved data.
3. Tools that let it act: search, read, write, call services.
4. A loop or a workflow that connects the steps.
5. Guardrails: validation, permissions, approval, limits and privacy.
6. Measurement: tests, metrics and logs.
7. An interface that makes it useful for a person.

When you look at a new AI product, try to name each part. You will start to see how it works, where it may fail and how you could build something like it.

What to learn next

Choose by what you want to do. Here is a map, not a rule.

• If you want to build products: deepen your web skills (authentication, databases, queues, deployment), and learn to build good user interfaces for AI features: streaming, progress, editing, undo and clear explanations.
• If you want to improve quality: learn evaluation in depth: bigger test sets, human review, A/B tests and regression suites. Learn more about retrieval: better chunking, real embedding models, rerankers and query rewriting.
• If you want to build agents: study the Claude Agent SDK and other frameworks, long-running tasks, sandboxes for running code, and observability tools that trace each step.
• If you want to work with models: learn the basics of fine-tuning, when it is worth it, and how to prepare data. Learn about open models you can run yourself and the trade-offs of size, speed and cost.
• If you care about safety and governance: read the provider's usage policies, study privacy law in your market, and learn red-teaming, which means attacking your own app to find weaknesses.

Whatever you choose, keep two habits. First, read the current documentation of every tool and model you use. This field changes every few months. Second, build small things often. Reading creates the feeling of knowing. Building creates the skill.

Five project ideas for your portfolio

A good portfolio project is small enough to finish, real enough to be useful and shows the skills employers want. Here are five. For each, the main skills are listed.

1. A help-center bot for a small business. Load a business's FAQ, build RAG with hybrid search, cited answers and an evaluation set of 20 questions. Skills: RAG, citations, evaluation, refusal.
2. A resume reviewer. Take a resume and a job post, return structured JSON with matched and missing skills and honest suggestions, and a page that explains every suggestion. Redact personal data first. Skills: structured output, privacy, prompt design.
3. A job-post summariser with caching. Summarise job posts into five bullet points, cache repeated posts, rate limit users, and show cost per request. Skills: production basics, metrics.
4. A notes assistant with MCP. An MCP server for your own notes with read, write and delete tools, a policy layer and approval for writes. Skills: MCP, security, human in the loop.
5. A study helper. Load your course notes, answer questions with citations, and create a quiz from a chosen chapter. Skills: RAG, structured output, user interface.

Whichever you choose, finish it, publish it with a clear README, add a short video or screenshots and write what you would do differently. Employers read that last part carefully, because it shows judgement.

Plan before you build

The most useful thing you can do before writing code is to answer a few questions in writing. The plan template in the lab has seven sections:

1. The problem. Who has it, what do they do today, and what would better look like in one sentence?
2. The data. What documents or records will the AI use? Who owns them? Do they contain personal data? How will you keep them up to date?
3. The design. Do you need only a prompt, structured output, RAG, tools or MCP, or an agent loop? Choose the simplest one that can work.
4. Safety. Which tool needs approval? Which text is untrusted? Which data is removed before it leaves your server? What does the app say when the AI is wrong or down?
5. Evaluation. Write ten test questions and the answers or sources you expect, and say how you will run them after every change.
6. Cost and operations. Estimate calls per day, tokens per call and monthly cost. Plan the cache, rate limit, timeout, fallback and metrics.
7. The first milestone. What can a real user try within two weeks?

# My AI project plan

Copy this file, fill in every line, and keep it with your code.

## 1. The problem
Who has the problem? What do they do today? What would "better" look like in one sentence?

## 2. The data
What documents or records will the AI use? Who owns them? Do they contain personal data? How will I keep them up to date?

## 3. The design (tick what you need)
- [ ] Plain prompt (no extra data)
- [ ] Structured output (JSON with validation)
- [ ] RAG over my documents
- [ ] Tools or MCP (list them and mark each read / write / destructive)
- [ ] An agent loop (list the limits: steps, tokens, time)

## 4. Safety
- Which tool needs human approval?
- Which text is untrusted, and how is it marked?
- Which personal data is removed before it leaves my server?
- What does the app say when the AI is wrong or unavailable?

## 5. Evaluation
List 10 test questions with the answer or source you expect. Say how you will run them after every change.

## 6. Cost and operations
Estimated calls per day, tokens per call, price per call, monthly cost. Cache, rate limit, timeout, fallback, metrics.

## 7. First milestone
What can I show a real user within two weeks?

Writing this takes about an hour, and it will save you days. Most failed AI projects fail because the problem or the data was unclear, not because the code was hard.

The capstone checklist page

The last page in your lab is a checklist of the skills in this course, with a link to the page that practises each one. Tick a skill only when you could do it again without looking at the lesson. Your ticks are saved in the browser, so they are still there tomorrow. If storage is blocked, the page still works, it just does not remember. That is a good habit too: features should degrade, not break.

Your task: write your project plan and finish the lab

Choose one project idea (or your own) and write the plan. Then add the capstone page to your lab.

What you will build

• A file docs/capstone-plan.md, filled in for your chosen project.
• An Angular Capstone page with a checklist of the skills, links to the pages that practise them, a progress bar and saved ticks.
• A short list of your next three learning goals.

Steps

1. Choose your project. Write one sentence about the problem and one sentence about who has it.
2. Copy the plan template and answer all seven sections. Be specific: write real numbers for the cost estimate and real questions for the test set.
3. Write ten test questions for your project and the answer or source you expect for each one.
4. Build the Capstone page. Keep the list of skills in an array. Save the ticked ids in localStorage inside try/catch.
5. Show a progress bar from the number of ticked skills.
6. Tick only the skills you are sure about. Choose your three weakest and write a plan to practise each one this week.

Hints

• Link each skill to its lab page with routerLink.
• Filter the saved ids against the known list, in case the list changes later.
• If a section of the plan is hard to fill in, that is where the project is riskiest. Spend time there first.

You know it works when your plan answers all seven sections with specific details, the checklist remembers your ticks after a refresh, and the page still works when browser storage is blocked.

Solution

The plan template was shown above. This is the Angular page:

import { Component, OnInit, signal } from '@angular/core';
import { RouterLink } from '@angular/router';

const KEY = 'ai-lab-capstone';

type Item = { id: string; text: string; page?: string };

@Component({
  selector: 'app-capstone',
  imports: [RouterLink],
  template: `
    <h1>Capstone checklist</h1>
    <p class="hint">Tick each skill once you can do it without looking at the lesson. Your ticks are saved in this browser.</p>

    <div class="card">
      <h2>{{ done().length }} of {{ items.length }} skills</h2>
      <div class="bar"><span [style.width.%]="(done().length / items.length) * 100"></span></div>
      @for (i of items; track i.id) {
        <label class="row">
          <input type="checkbox" [checked]="done().includes(i.id)" (change)="toggle(i.id)" />
          <span>{{ i.text }}</span>
          @if (i.page) { <a [routerLink]="'/' + i.page">open page</a> }
        </label>
      }
    </div>

    <div class="card">
      <h2>Project ideas for your portfolio</h2>
      <ul>
        <li>A help-center chatbot for a small business, with cited answers and an evaluation set.</li>
        <li>A resume reviewer that returns structured JSON and explains every suggestion.</li>
        <li>A job-post summariser that redacts personal data and caches repeated posts.</li>
        <li>A notes assistant using an MCP server with approval for every write.</li>
        <li>A study helper that quizzes you from your own course notes.</li>
      </ul>
      <p class="muted">Use the plan template in docs/capstone-plan.md before you write code.</p>
    </div>
  `,
  styles: [`
    .row { display:flex; gap:10px; align-items:center; padding:6px 0; border-bottom:1px solid #e2e8f0; } .row input { width:auto; margin:0; }
    .row a { margin-left:auto; font-size:.85rem; }
    .bar { height:8px; background:#e2e8f0; border-radius:99px; margin:6px 0 10px; } .bar span { display:block; height:100%; background:#4f46e5; border-radius:99px; }
  `],
})
export class CapstonePage implements OnInit {
  items: Item[] = [
    { id: 'chat', text: 'Call the Claude API from a server and keep the key secret', page: 'ask' },
    { id: 'stream', text: 'Stream a reply to the browser', page: 'stream' },
    { id: 'cache', text: 'Use prompt caching and read the usage numbers', page: 'caching' },
    { id: 'tools', text: 'Give Claude tools and limit the loop', page: 'safe-agent' },
    { id: 'json', text: 'Get validated JSON from a model', page: 'match' },
    { id: 'chunk', text: 'Chunk documents and search by meaning', page: 'search' },
    { id: 'store', text: 'Put vectors behind a store interface', page: 'store' },
    { id: 'rag', text: 'Answer from your own documents with checked citations', page: 'rag-plus' },
    { id: 'agent', text: 'Run an agent with memory and a token budget', page: 'agent-loop' },
    { id: 'team', text: 'Split work between specialised agents', page: 'team' },
    { id: 'mcp', text: 'Build and call an MCP server', page: 'mcp-ask' },
    { id: 'safe', text: 'Require approval for write tools and defend against prompt injection', page: 'mcp-safe' },
    { id: 'eval', text: 'Run a test set after every change', page: 'evals' },
    { id: 'pii', text: 'Redact personal data before it leaves the server', page: 'privacy' },
    { id: 'ops', text: 'Add cache, rate limit, timeout, fallback and metrics', page: 'ops' },
  ];
  done = signal<string[]>([]);

  ngOnInit() {
    try {
      const saved = JSON.parse(localStorage.getItem(KEY) || '[]');
      if (Array.isArray(saved)) this.done.set(saved.filter((x) => this.items.some((i) => i.id === x)));
    } catch { /* storage can be blocked; the page still works */ }
  }

  toggle(id: string) {
    this.done.update((d) => (d.includes(id) ? d.filter((x) => x !== id) : [...d, id]));
    try { localStorage.setItem(KEY, JSON.stringify(this.done())); } catch { /* ignore */ }
  }
}

What you learned

• You can build, test, protect and run an AI feature end to end.
• Every AI product is a model, context, tools, a loop or workflow, guardrails, measurement and an interface.
• A written plan, with data, safety, evaluation and cost, saves more time than any trick.
• The way to keep the skill is to read current documentation and build small things often.

Congratulations on finishing the course. Pick your project, write the plan, and start building. If you publish it, you now have something real to show.