AI Full-Stack Engineering FAQ: Answers to Common Questions

Q: My script fails with an authentication error. What should I check?

Check that ANTHROPICAPIKEY is set in the environment of the process that runs your code (for scripts, run them with node --env-file=.env.local), that the key has no extra spaces, and that it has not been revoked. The doctor.ts script below checks all of this.

Answers to the questions learners ask most: prerequisites, time to job-ready, costs, model choice, fine-tuning versus RAG, agents, frameworks, and setup problems.

Beginner10 min readUpdated October 7, 2026

On this page· How long it takes

Why this matters

The same questions come up again and again from people learning AI engineering, and the answers online are often outdated or written to sell a course. These are short, honest answers, with links to the articles that go deeper.

How long it takes#

6 months: you know JavaScript but have gaps in Node.js, databases, or deployment. 8–10 hours a week.

Start & foundations
LLM engineering
Agents
Production
Projects
Career

Learning timelines: Gantt charts of the 3, 6, and 12-month study plans, week by week, from foundations to career preparation.

Show text description

Each plan is a sequence of focus blocks measured in weeks. Choose a plan above the chart to switch.

3 months (13 weeks): for people who already build with TypeScript, React, a backend, and SQL. 10–12 hours a week.

Weeks 1–1: Start Here + LLM Fundamentals (Environment set up; first API call)
Weeks 2–5: LLM App Engineering (Chat app with streaming; docs Q&A with RAG)
Weeks 6–8: Agents & Orchestration (Support agent; custom MCP server)
Weeks 9–10: Production + AI-assisted dev (Evals and tracing on the RAG project)
Weeks 11–12: Capstone (Production SaaS AI assistant)
Weeks 13–13: Career (Portfolio, write-up, mock interview)

6 months (26 weeks): for people who know JavaScript but have gaps in Node.js, databases, or deployment. 8–10 hours a week.

Weeks 1–2: Start Here, find your gaps
Weeks 3–6: Foundations (your gaps) (CRUD app with Postgres, deployed)
Weeks 7–8: LLM Fundamentals
Weeks 9–13: LLM App Engineering (Chat app; docs Q&A with RAG and evals)
Weeks 14–18: Agents & Orchestration (Support agent; MCP server)
Weeks 19–21: Production + AI-assisted dev
Weeks 22–24: Multi-agent project, capstone
Weeks 25–26: Capstone + career

12 months (52 weeks): for people who are new to programming or come from outside web development. 6–8 hours a week.

Weeks 1–2: Start Here, tools, Git
Weeks 3–8: JavaScript & TypeScript
Weeks 9–12: Node.js
Weeks 13–18: React & Next.js
Weeks 19–22: Databases
Weeks 23–25: APIs & auth
Weeks 26–27: DevOps
Weeks 28–30: LLM Fundamentals
Weeks 31–36: LLM App Engineering
Weeks 37–42: Agents & Orchestration
Weeks 43–46: Production + AI-assisted dev
Weeks 47–50: Capstone
Weeks 51–52: Career

Getting started#

Do I need a machine learning or math background?

No. AI full-stack engineering is about building products with models through APIs, not training models. You need solid web development skills (TypeScript, React, Node.js, databases, HTTP), and a working intuition for how models behave, which the LLM fundamentals section gives you. Statistics helps with evals later, but you can learn what you need as you go.

How long does it take to become job-ready?

With solid web development skills, about three to six months of steady part-time work: the LLM engineering and agents sections, two or three serious projects, and interview preparation. Starting from scratch in web development, plan for nine to twelve months. The roadmap has 3, 6, and 12-month plans.

How much will the API cost me while learning?

Usually a few dollars to a few tens of dollars a month. Development requests are small, and caching, smaller models for experiments, and short outputs keep costs down. Set a monthly spending limit in the provider console from day one, and use the cost cheat sheet to estimate anything bigger.

Why TypeScript and not Python?

Python dominates model training and data science; TypeScript dominates the web products people use. AI full-stack engineers build products, so this wiki uses TypeScript end to end: one language for the UI, the API, the agents, and the tooling. The concepts transfer directly if you also use Python.

Building with models#

Which model should I use?

Start with the most capable model while you build, so you learn what is possible, then measure whether a faster, cheaper model passes your evals for each task. Many products route simple requests to a small model and hard ones to a large model. See choosing models and model routing.

Should I fine-tune a model or use RAG?

For teaching a model your facts and documents, use RAG: it is cheaper, updates instantly when documents change, and gives citations. Fine-tuning is for changing behavior or format at scale, and current models rarely need it for that, because clear instructions and examples work. Try prompting, then RAG, before considering fine-tuning. See RAG.

When do I need an agent?

When the steps of a task depend on what earlier steps discover and you cannot write them down in advance. If you can draw the flowchart, write a workflow in code instead: it is cheaper, faster, and easier to test. See workflows versus agents.

Do I need a framework such as LangChain?

Not to start. Every pattern in this wiki is a few dozen lines of TypeScript on top of the official SDK, which also includes helpers such as the tool runner. Frameworks can save time later, but learn what they do underneath first, so you can debug them and judge when they help.

How do I stop the model from making things up?

Give it the information it needs (retrieval), tell it to answer only from that information and to say when it does not know, ask for citations, and measure the result with evals. For high-stakes answers, add checks in code and human review. See RAG and evals.

Setup problems#

My script fails with an authentication error. What should I check?

Check that ANTHROPIC_API_KEY is set in the environment of the process that runs your code (for scripts, run them with node --env-file=.env.local), that the key has no extra spaces, and that it has not been revoked. The doctor.ts script below checks all of this.

Node.js says it cannot find a module I import from my own files.

When Node.js runs TypeScript files directly, relative imports need the .ts extension: import { x } from "./lib/x.ts". Inside a Next.js app, the bundler resolves imports and you leave the extension off. See how to use this wiki.

Can I call the API directly from my React components?

No. Calling it from the browser exposes your API key to every visitor. Always call models from your server (route handlers, server actions, or a backend) and stream the result to the browser. See streaming to React.

Check your setup#

This script checks the most common setup problems in one go: Node.js version, the API key, and a minimal request that costs a fraction of a cent.

doctor.ts

import Anthropic from "@anthropic-ai/sdk";
 
const checks: { name: string; run: () => Promise<string> }[] = [
  {
    name: "Node.js version",
    run: async () => {
      const major = Number(process.versions.node.split(".")[0]);
      if (major < 22) throw new Error(`Node.js ${process.versions.node}; install Node.js 22 or newer to run .ts files directly`);
      return process.versions.node;
    },
  },
  {
    name: "API key",
    run: async () => {
      const key = process.env.ANTHROPIC_API_KEY;
      if (!key) throw new Error("ANTHROPIC_API_KEY is not set. Run with: node --env-file=.env.local doctor.ts");
      if (key !== key.trim()) throw new Error("The key has leading or trailing whitespace");
      return `set (${key.length} characters)`;
    },
  },
  {
    name: "API request",
    run: async () => {
      const client = new Anthropic({ maxRetries: 0, timeout: 20_000 });
      const res = await client.messages.create({
        model: "claude-haiku-4-5",
        max_tokens: 5,
        messages: [{ role: "user", content: "Reply with: ok" }],
      });
      return `ok (model ${res.model}, request ${res._request_id ?? "n/a"})`;
    },
  },
];
 
let failed = 0;
for (const check of checks) {
  try {
    console.log(`✓ ${check.name}: ${await check.run()}`);
  } catch (error) {
    failed++;
    const detail = error instanceof Anthropic.APIError ? `${error.status ?? "network"}: ${error.message}` : error instanceof Error ? error.message : String(error);
    console.log(`✗ ${check.name}: ${detail}`);
    if (check.name === "API key") break; // the request check would fail for the same reason
  }
}
process.exitCode = failed ? 1 : 0;

Common mistakes#

Waiting to feel ready before building. Build small things from the first week.
Collecting courses instead of shipping projects. Two finished projects beat ten half-done tutorials.
Skipping the fundamentals. Web development skills are what make AI features production-ready.

Try it

Run the doctor

Run node --env-file=.env.local doctor.ts and fix anything marked with ✗.
Run it once without the key to see the error message, then once with a deliberately wrong key.
Note the request ID it prints; it is what you would give support if something went wrong.

Check your understanding

Key takeaways

You need web development skills, not a machine learning background.
Prefer prompting and RAG over fine-tuning, workflows over agents, and the SDK over frameworks when starting.
Keep API keys on the server, set spending limits, and run the doctor script when something does not work.

Next steps#

The complete roadmap

Plan your path through the wiki.

Glossary

Look up any term you meet along the way.

Finished this article? Track it to see your progress on the roadmap.