The first two deliverables of the CS224U final project are a literature review and an experiment protocol. The lit review covers 5, 7, or 9 papers depending on team size, under five suggested sections. The protocol has seven required sections, and its core is a hypothesis you can state. The course supplies a six-step paper-search loop, a rule that AI-assistant output must be quoted, and a worked example: a student's final project that became a Findings of EMNLP paper. The Gradescope format and rubric slides, and past exemplary papers, are behind a login.
The CS224U slides compute two numbers from one three-class confusion matrix: accuracy 0.81 and macro F1 0.43. One says the system is good; the other says it gets the two small classes almost entirely wrong. The unit's claim is that different metrics encode different values, and it goes through the bounds, values, and weaknesses of accuracy, the three F-score averages, perplexity, word error rate, and BLEU. Final projects are graded on whether the metrics fit, not on how high the scores are.
CS224U's 'Presenting your research' lecture has four parts: the course-specific rules for the final paper, how to write an NLP paper, how conference submission works, and how to give a talk. Three things matter most. The final paper must include Known project limitations and an Authorship statement. Write as a Shieber-style 'rational reconstruction,' not a chronological tour of your dead ends. At submission, your title largely decides reviewer bidding. The slides, four videos, and projects.md are public; past example papers need a Stanford login.
Claude Academy's opening lesson identifies the core paradox: AI accelerates code generation, but review, testing, and deployment don't keep pace. The bottleneck shifts from 'not writing fast enough' to 'not reviewing fast enough.' The AI-native SDLC fix isn't more AI-generated code — it's embedding AI into every stage where bottlenecks now live.
Traditional requirements scatter across Jira, Slack, and meeting notes, losing fidelity at every handoff. intent.md lets the originator collaborate directly with Claude to produce a human-readable, machine-actionable, version-controlled Markdown proto-spec — from conversation to committed document in hours, not weeks.
Traditionally, requirements analysis and design are separate phases run by different teams — every handoff loses information. This lesson's approach: Claude reads intent.md in a single session, applies organizational standards (brand, security, compliance, UX loaded as skills), and produces a unified spec.md. The product owner reviews; they don't author.
Claude Code's plan mode lets engineers produce a reviewable, version-controlled implementation plan (plan.md) before writing a single line of code. Design review shifts from the PR diff to the planning stage, and the cost of course-correcting drops from 'rewriting code' to 'editing a document.'
CLAUDE.md is a context file at the repo root that Claude reads at the start of every session — your team's conventions, commands, architecture patterns, and pitfalls. The course's core advice: if Claude makes the same mistake twice, write it into CLAUDE.md.
A skill is organizational tacit knowledge made operational — a folder with a SKILL.md that Claude loads automatically when trigger conditions are met. The course's key principle: skills make violations rare; hooks make them nearly impossible.
One engineer runs multiple Claude Code sessions simultaneously, each in its own git worktree; repetitive verification work goes to subagents. The bottleneck shifts from 'writing code' to 'reviewing output.'
Have Claude verify its own output before submitting — tests, builds, and screenshot diffs all run to completion before the task is marked done. Engineers receive code that's already passed verification, not code that 'might be correct.'
Evals are the AI-native equivalent of stage-gate QA — collect 20–50 real tasks as test cases, run them automatically whenever CLAUDE.md, skills, or hooks change, and block the merge if the pass rate drops. Every production incident becomes a permanent eval.
Let AI handle the first review pass so humans can focus on intent and risk. This lesson covers how to define REVIEW.md, layer review passes, set up an automated review-comment fix loop, and why the agent that wrote the code must never approve its own PR.
Hooks are the governance bedrock of the AI-native SDLC — deterministic gates that intercept agent actions and block them if conditions aren't met. This lesson walks from a single production-gate script to full enterprise managed settings covering permission lockdown, sandboxing, credential isolation, and marketplace allowlists. The most technically dense lesson in the entire course.
Plug Claude into the CI/CD pipeline — start with read-only build failure triage, gradually add write operations behind existing gates, expose deployment tooling through MCP, and tier autonomy by environment. The governing principle is one sentence: 'The agent may act up to the production gate and cannot pass it.'
Stage 6 is both the endgame and the starting point of the AI-Native SDLC: a monitoring script detects an anomaly → Claude writes a diagnosis as intent.md → it flows through the entire development pipeline. Humans shift from 'starting work' to 'triaging and reviewing work.'
After 14 lessons, this final article distills the series into three things: a prioritized adoption roadmap, role-specific reading paths, and Anthropic's complete official documentation list.
Anthropic's Claude Academy offers a free 14-lesson course that takes AI-assisted coding from 'individuals using Claude Code' to 'an organization-wide development lifecycle.' Four core concepts — intent.md, CLAUDE.md, Skills, and Hooks — wire together into a complete AI-native SDLC.
GPUtw.ai makes sense as a short-rental GPU learning tool: start with Jupyter, Ollama, or ComfyUI, then try LoRA/QLoRA on a small model. It is not a large foundation-model training platform, and the first run should verify deployment, billing, and data retention with a small budget.
Open-source projects have pushed the cost of training an LLM from scratch absurdly low: MiniMind runs the full PreTrain-to-RL pipeline for about $0.4 (2 hours on a single RTX 3090), while at the other end OLMo 3 and LLM360 K2 publish everything — data, code, and stage-by-stage checkpoints of 65B models. This series walks the whole project spectrum from $0.4 to 65B in 11 articles, and flags where the map is biased.