How to Use This Wiki (with 3, 6, and 12-Month Study Plans)

Why this matters

People who give up on learning AI engineering rarely lack talent. Usually they lack a sequence: they jump from tutorial to tutorial and never ship anything end to end. This wiki is designed to be followed in order, with a project at each stage. Ten minutes here will save you weeks of wandering.

How the wiki is organized#

The content follows the order in which the skills depend on each other:

1. Start Here: the role, the roadmap, and this guide.
2. Foundations: TypeScript, Node.js, React and Next.js, databases, APIs, DevOps.
3. LLM Fundamentals: how models work, choosing models, keys and billing.
4. LLM App Engineering: your first API call through streaming, structured outputs, tool use, RAG, and caching.
5. AI Agents & Orchestration: workflows vs agents, agent loops, multi-agent systems, MCP, durable execution.
6. Production AI Engineering: evals, observability, reliability, security, and cost.
7. AI-Assisted Development: working effectively with coding agents.
8. Projects: six builds of increasing difficulty, ending with a capstone SaaS assistant.
9. Career: portfolio, writing, interviews, staying current.
10. Reference: glossary, cheat sheets, resources, FAQ.

Use the sidebar to move between sections and the Previous / Next links at the bottom of every page to follow the default reading order. The roadmap shows the same path with typical durations; select a stage to jump to it.

1. 1Start Here2 weeksbeginner Understand the role and pick a study plan.
2. 2Foundations4 weeksbeginner TypeScript, Node.js, React, databases, APIs, and DevOps.
3. 3LLM Fundamentals2 weeksbeginner Tokens, context windows, choosing models, keys and billing.
4. 4LLM App Engineering5 weeksintermediate Streaming, structured outputs, tool use, RAG, and caching.
5. 5Agents & Orchestration5 weeksadvanced Agent loops, multi-agent systems, MCP, durable execution.
6. 6Production AI2 weeksadvanced Evals, tracing, reliability, security, and cost.
7. 7AI-Assisted Development1 weekintermediate Build, review, test, and debug with coding agents.
8. 8Projects3 weeksadvanced Six builds, ending with a production SaaS assistant.
9. 9Career2 weeksintermediate Portfolio, writing, and AI system design interviews.

Show text descriptionHide text description

The roadmap is an ordered path of 9 stages. Each stage builds on the ones before it. Durations follow the 6-month standard plan; the 3-month plan compresses them and the 12-month plan expands the foundations.

1. Start Here (2 weeks, beginner): Understand the role and pick a study plan.
2. Foundations (4 weeks, beginner): TypeScript, Node.js, React, databases, APIs, and DevOps.
3. LLM Fundamentals (2 weeks, beginner): Tokens, context windows, choosing models, keys and billing.
4. LLM App Engineering (5 weeks, intermediate): Streaming, structured outputs, tool use, RAG, and caching.
5. Agents & Orchestration (5 weeks, advanced): Agent loops, multi-agent systems, MCP, durable execution.
6. Production AI (2 weeks, advanced): Evals, tracing, reliability, security, and cost.
7. AI-Assisted Development (1 week, intermediate): Build, review, test, and debug with coding agents.
8. Projects (3 weeks, advanced): Six builds, ending with a production SaaS assistant.
9. Career (2 weeks, intermediate): Portfolio, writing, and AI system design interviews.

Anatomy of an article#

Every article uses the same structure, so you always know where to look:

Every diagram uses the same visual language, so it is worth learning once:

Shapes

• Rounded rectangle: Service or code you run
• Cylinder: Database or storage
• Hexagon: LLM or other model
• Circle: User or actor
• Page: File or document

Colors

• AI / LLM
• Backend
• Frontend
• Data / storage
• Security / risk
• External

Lines

• Request or data
• Async job or event
• Streaming response
• Trust boundary

Set up your environment#

You need three things before the LLM sections: a recent Node.js, a code editor, and an API key.

1. Install Node.js 22 LTS or newer

   Download it from nodejs.org (opens in a new tab) or use a version manager such as nvm or fnm. Check the version:

   node --version

   Node.js 22.18 and later can run .ts files directly by stripping type annotations, so the examples in this wiki run without a build step.

2. Create a practice project

   npmpnpm

   mkdir ai-practice && cd ai-practice
   npm init -y
   npm pkg set type=module
   npm install @anthropic-ai/sdk

   mkdir ai-practice && cd ai-practice
   pnpm init
   npm pkg set type=module
   pnpm add @anthropic-ai/sdk

   Setting "type": "module" makes Node.js treat your files as ES modules, so import and top-level await work.

   Add a tsconfig.json so your editor type-checks the scripts the same way Node.js runs them:

   {
     "compilerOptions": {
       "target": "ES2022",
       "module": "NodeNext",
       "moduleResolution": "NodeNext",
       "strict": true,
       "noEmit": true,
       "allowImportingTsExtensions": true,
       "verbatimModuleSyntax": true,
       "erasableSyntaxOnly": true,
       "skipLibCheck": true
     }
   }

   Node.js runs .ts files by removing their types, without a bundler, so local imports in scripts include the extension: import { anthropic } from "./lib/anthropic.ts". Inside a Next.js app, the bundler resolves imports and you leave the extension off.

   Removing types only works for TypeScript syntax that has no runtime meaning. erasableSyntaxOnly makes the editor flag the few features that do, such as enum and constructor parameter properties (constructor(private x: number)), which Node.js refuses to run.

3. Get an API key and store it safely

   Create a key in the Anthropic Console, then save it in a .env.local file in the project folder. Add that file to .gitignore immediately so the key is never committed:

   ANTHROPIC_API_KEY=your-key-from-the-anthropic-console

   echo ".env.local" >> .gitignore

   Set a monthly spend limit in the console as well. Practice workloads are cheap, but a bug in a loop is not.

4. Verify everything works

   Create this script. It checks your Node.js version and key, then makes one small model call:

   import Anthropic from "@anthropic-ai/sdk";
    
   const [major] = process.versions.node.split(".").map(Number);
   if (major < 22) {
     console.error(`Node.js ${process.versions.node} is too old. Install Node.js 22 LTS or newer.`);
     process.exit(1);
   }
   if (!process.env.ANTHROPIC_API_KEY) {
     console.error("ANTHROPIC_API_KEY is not set. Add it to .env.local and run with --env-file.");
     process.exit(1);
   }
    
   const client = new Anthropic();
   const message = await client.messages.create({
     model: "claude-opus-5-5",
     max_tokens: 1024,
     output_config: { effort: "low" },
     messages: [{ role: "user", content: "Reply with exactly one word: ready" }],
   });
    
   const reply = message.content.flatMap((block) => (block.type === "text" ? [block.text] : [])).join("");
   console.log(`Node.js ${process.versions.node} OK. Model replied: ${reply}`);
   console.log(`Tokens used: ${message.usage.input_tokens} in, ${message.usage.output_tokens} out`);

   Run it, loading the key from .env.local:

   node --env-file=.env.local check-env.ts

   If you see the model's reply and a token count, you are ready for every code example in the wiki.

Choose your study plan#

All three plans reach the same destination: deployed projects, a portfolio, and interview preparation. Choose based on where you start, not how fast you want to finish. Skipping foundations you do not have makes everything after them slower.

3 months: fast track#

For: developers already comfortable with TypeScript, React, a backend framework, and SQL. Pace: 10 to 12 hours per week.

The multi-agent research project is optional on this plan; do it after week 13 if you want depth in orchestration.

6 months: standard path#

For: people who know JavaScript but have gaps in Node.js, databases, or deployment. Pace: 8 to 10 hours per week.

12 months: from zero#

For: beginners to programming or people coming from a non-web background. Pace: 6 to 8 hours per week.

How to study effectively#

• Type the code, do not paste it. Typing forces you to read every line, and the typos you fix teach you the API.
• Change one thing and predict the result. After an example works, alter a parameter (the system prompt, max_tokens, a tool description) and guess what will happen before you run it.
• Keep a build log. A dated file of what you built, what broke, and how you fixed it becomes the raw material for your portfolio write-ups.
• Do the quizzes before rereading. Retrieval practice beats rereading. If you miss a question, read the explanation, then reread only that section.
• Use AI assistants as a tutor, not a crutch. Ask a coding assistant to explain an error or review your code, but write the first version yourself.

Common mistakes#

• Skipping straight to agents. Agents combine everything before them. Without streaming, tool use, and evals, agent bugs are hard to diagnose.
• Collecting tutorials instead of shipping. Ten half-finished demos are worth less than one deployed project with tests, evals, and a README.
• Committing secrets. Add .env.local to .gitignore before your first commit, not after. Leaked keys are found by scanners within minutes of a public push.
• Studying without a target. Pick a plan and put the weekly hours in your calendar. Unscheduled study does not happen.

Try it

Commit to a plan

1. Pick the 3, 6, or 12-month plan that matches where you are today.
2. Block your weekly study hours in your calendar for the next four weeks.
3. Complete the environment setup above and run check-env.ts successfully.
4. Create a build-log.md file and write your first entry: the date, the plan you chose, and what you want to be able to build at the end.

Check your understanding

You already build React and Node.js apps professionally. Which plan fits best?

The 12-month planThe 6-month planThe 3-month fast trackSkip the plans and start with multi-agent systems

Why does the setup run the script with node --env-file=.env.local?

It makes Node.js compile TypeScriptIt loads ANTHROPIC_API_KEY from the file into process.env without hard-coding itIt is required for top-level awaitIt uploads the file to the Anthropic Console

What is the one rule worth keeping even when you fall behind your plan?

Never spend more than a week on a sectionRead every article twiceFinish each project before starting the next sectionAlways use the largest model available

Key takeaways

• The wiki is ordered by dependency: foundations, LLM fundamentals, application engineering, agents, production, then projects and career.
• Every article follows the same structure, from "Why this matters" to quiz and key takeaways.
• Set up Node.js 22+, an ES module project, and a server-side API key stored in an ignored .env.local file.
• Choose the 3, 6, or 12-month plan by your starting point, and ship a project at every stage.
• Active study (typing code, predicting results, quizzing yourself, keeping a build log) beats passive reading.

Next steps#