Five days.
One shipped
AI application.

01  Orientation

Read this first. The promise is honest.

This guide takes you from a clean Mac to a deployed, database-backed, evaluated AI application. It is self-paced. It is not solitary. That difference matters more than anything in the curriculum.

Nobody becomes world-class at anything in five days, and a guide that claims otherwise lies on page one. Here is what five days actually buys: a working machine, a working practice loop, and a shipped application you built yourself. World-class comes from running that loop for the ninety days after. This guide installs the loop. The last section is the real path to the title — read it as part of the course, not as an appendix.

Two tracks, one spine

Every section is for everyone unless marked. Two markers route you.

And two honest exits. The Operator exit at the end of Day 3: you have shipped a real AI application and can build AI features into your work — a complete, legitimate finish for consultants, PMs, and analysts. The Builder finish at the end of Day 5: database, structured outputs, tool calling, evals, and a capstone demo. That is the engineer's track.

The rails — what keeps you finishing

Self-paced courses fail quietly. Socially-anchored ones do not. Use all four rails.

So what: you are not learning to type code faster. You are learning to direct capable agents and verify the result like a professional — part architect, part editor, part quality engineer.

03  Doctrine

Six principles the stack can't rot.

Tools depreciate. Versions and model names will rotate under your feet within months. These six invariants will not. Every day drills them. When you are confused, come back here.

1. Plan before code. Energy spent on the plan is repaid by a one-shot implementation. If you can describe the change in one sentence, skip the plan. Otherwise, never skip it.
2. Give the agent a way to verify. An AI stops when work looks done. A test, a build, a screenshot, a lint pass — give it a check it can run, and demand evidence, not assertion. Otherwise you are the verification loop.
3. Context is finite. Performance degrades as the context window fills.⁵ One task per session. Clear between tasks. A focused agent is a smart agent.
4. Git is the safety net. Commit early, commit often, branch for everything. With a clean checkpoint behind you, you can let the agent be bold — every mistake is reversible.
5. The model routes; code does the math. Probabilistic systems classify, draft, extract, and decide what happens next. Deterministic code calculates, stores, and enforces. Keep that boundary sharp and your apps stop being demos.
6. Ship daily. A deployed URL is the unit of progress. Every day of this course ends with something live. So should most weeks of your career after it.

05  Day 1 · Monday

What you build today

A personal landing page, scaffolded with Next.js, edited by Claude Code, version-controlled on GitHub, and deployed to the internet by Vercel — all before lunch.

cd ~ && mkdir -p dev && cd dev
pnpm create next-app@latest hello-blueally
# Say YES to: TypeScript, ESLint, Tailwind CSS, App Router, import alias (@/*).
cd hello-blueally && pnpm dev
# Open http://localhost:3000 — that's your app, running on YOUR machine.
code .   # open the folder in VS Code; ⌃` toggles the built-in terminal

First real work for the agent

In a second terminal tab, start the agent and let it learn the project. Then give it a task that is specific about the file, the content, and the constraint.

claude
/init   # Claude explores the repo and writes CLAUDE.md — its standing memory.
         You'll edit this file all week. Read what it wrote.

Replace the contents of app/page.tsx with a simple personal landing page:
my name, the title "AI Application Engineer in training — BlueAlly",
and a short list of what I'm building this week. Style it with Tailwind,
navy and light-blue, centered, clean. Keep it a server component —
no client-side state. Don't touch any other file.

Claude proposes changes as diffs. Read the diff before you approve. Green lines added, red removed. You don't need to understand every character today — you need the habit of looking. Approve, check the browser, and there is your page. Now put it on GitHub and ship it.

git add -A && git commit -m "feat: personal landing page"
gh repo create hello-blueally --private --source=. --push
vercel        # accept the defaults; ~60s later it prints a preview URL
vercel --prod  # that URL is live, on the internet, built by you, before lunch
# Post it in your wave channel. That's Gate 1's first box.

The one idea to carry forward

Open CLAUDE.md and shape it. This file loads into every Claude session in this repo — it is project memory. Keep it short and true.

# Project: hello-blueally

## Stack
- Next.js (App Router) + TypeScript strict. Tailwind for styles. pnpm ONLY.

## Commands
- dev: pnpm dev · build: pnpm build · lint: pnpm lint

## Rules
- Server components by default; add 'use client' only for state/events.
- Small, focused diffs. One concern per commit. Conventional commit messages.
- After a task, run pnpm lint and pnpm build, and show me the result.

That last line is Principle 2 in action — you just gave the agent a way to verify. All week, whenever you correct Claude, end with: "update CLAUDE.md so you don't make that mistake again." The file compounds. By Friday it codes like you.

08  Day 4 · Thursday

Memory: Neon and Drizzle

Neon is serverless Postgres — real Postgres that scales to zero and branches like git, which is why it is the house database. In the Neon console, create a project in the same region as your Vercel deployment, copy the connection string, and add it to .env.local as DATABASE_URL=postgres://… (and to Vercel for production). Drizzle is an ORM where the schema is TypeScript — you describe a table once and get types, queries, and migrations from it.

import { pgTable, serial, text, varchar, timestamp } from 'drizzle-orm/pg-core';

export const messages = pgTable('messages', {
  id: serial('id').primaryKey(),
  conversationId: varchar('conversation_id', { length: 64 }).notNull(),
  role: varchar('role', { length: 16 }).notNull(),   // 'user' | 'assistant'
  content: text('content').notNull(),
  createdAt: timestamp('created_at').defaultNow().notNull(),
});

pnpm add drizzle-orm @neondatabase/serverless && pnpm add -D drizzle-kit
pnpm drizzle-kit generate   # writes a .sql migration — read it; it's honest
pnpm drizzle-kit migrate    # applies it to your Neon database
pnpm drizzle-kit studio     # a visual browser for your data — keep it open today

Now persist the conversation through the full loop. The plan to approve: in the chat route's streamText call, add an onFinish callback that inserts the user message and the assistant reply with a conversation id; add a small server function to load history; have the chat page load it on mount. Send a message, refresh the page, watch it persist in Drizzle Studio. Data surviving a refresh is the moment this became an application.

Structured output: the model fills your types

Chat is one mode. The workhorse mode of enterprise AI is: unstructured text in, typed object out. The SDK's generateObject plus a Zod schema (Zod describes a data shape in TypeScript and validates against it) makes the model's output conform to your shape — the pattern behind extraction, triage, scoring, and routing.

import { anthropic } from '@ai-sdk/anthropic';
import { generateObject } from 'ai';
import { z } from 'zod';

const ActionItems = z.object({
  items: z.array(z.object({
    task: z.string().describe('The action item, imperative voice'),
    owner: z.string().describe('Who is responsible; "unassigned" if unclear'),
    due: z.string().nullable().describe('Due date if stated, ISO format'),
    priority: z.enum(['high', 'medium', 'low']),
  })),
});

export async function POST(req: Request) {
  const { notes } = await req.json();
  const { object } = await generateObject({
    model: anthropic('claude-sonnet-4-6'),
    schema: ActionItems,
    prompt: 'Extract every action item from these meeting notes:\n\n' + notes,
  });
  return Response.json(object);   // typed. validated. boring. perfect.
}

Build a small /extract page today: a textarea for notes, a button, a rendered table of the returned items. Paste real notes from a real meeting and feel the consulting use cases line up.

Tool calling: the model gets hands

A tool is a typed function you offer the model; it decides when to call it, your code executes, the result flows back into the answer. This is the primitive under every agent you will build.

import { streamText, convertToModelMessages, tool, stepCountIs } from 'ai';
import { z } from 'zod';

// inside streamText({ ... })
tools: {
  getProjectStatus: tool({
    description: 'Look up the live status of a BlueAlly project by name',
    inputSchema: z.object({ projectName: z.string() }),
    execute: async ({ projectName }) => {
      // deterministic code — a DB query in real life:
      return { projectName, status: 'on track', nextMilestone: '2027-03-02' };
    },
  }),
},
stopWhen: stepCountIs(5),   // let it call tools, then answer — bounded

Ask the chat "what's the status of Project Apollo?" and watch it decide, call, and weave the result into prose. Notice what happened architecturally: the model classified and routed; your code did the work.

The one idea to carry forward: the model ladder

Model choice is an engineering dial — cost and latency against capability. The Claude family is a clean ladder; the names below will rotate, the ladder will not. Verify current models and pricing at the Anthropic docs before client work.⁷

Above the ladder sits Claude Fable 5, Anthropic's most capable model, for the rare task that earns it.⁸ The production pattern worth naming: a smart model orchestrates while cheap models execute subtasks in parallel. You will feel this in Claude Code itself, which routes simple work to smaller models. Judgment here is margin — yours and the client's.

10  When you're stuck

The errors everyone hits — and the fix for each.

A wall on Day 1 is not failure — it is the curriculum. Every error below has stopped someone before you, and every one has a fix that takes minutes. Two habits clear most of them: read the actual error text (the Error Lens extension prints it right in your editor), and paste that exact text to Claude Code — "I ran this, got this error, here it is" — it is good at fixing its own stack.

11  Hard-won warnings

Pitfalls. Each one has a fix.

Every one of these has a body count on real teams. The fix is attached to each. Tape the ones that sting to your monitor.

Keep reading

The week ends. The story continues.

You learned to build the application. These two field guides zoom out to the system it lives in — the parts you direct, and why the model was never the hard part.

13  Sources

Where this comes from

Tools, versions, model names, and prices move fast — every one above was checked against primary sources in June 2026, and you should re-check them before client work. Where a practitioner is credited, the framing is theirs; the synthesis is BlueAlly's.

1. Anthropic, "Claude Code: Best practices for agentic coding." anthropic.com/engineering/claude-code-best-practices
2. Andrej Karpathy, "Software Is Changing (Again)" — keynote, AI Startup School. youtube.com/watch?v=LCEmiRjPEtQ
3. Andrew Ng, "Don't stop learning to code" — DeepLearning.AI, The Batch. deeplearning.ai/the-batch
4. Anthropic, "Claude Code overview" — official documentation. platform.claude.com/docs/en/claude-code/overview
5. Liu et al., "Lost in the Middle: How Language Models Use Long Contexts," arXiv:2307.03172. arxiv.org/abs/2307.03172
6. Vercel, "AI SDK 6" — release announcement (package ai; streamText, ToolLoopAgent, Output.object). vercel.com/blog/ai-sdk-6
7. Anthropic, "Models overview" — pricing and current model IDs. platform.claude.com/docs/en/about-claude/models/overview
8. Anthropic, "Claude — Models overview" (Claude Fable 5, Opus 4.8, Sonnet 4.6, Haiku 4.5). platform.claude.com/docs/en/about-claude/models/overview
9. Anthropic, "Migrate to the Claude Agent SDK" — @anthropic-ai/claude-agent-sdk for headless and programmatic use. platform.claude.com/docs/en/agent-sdk/migration-guide