LLM Fundamentals and Agent Workflows
Understand language-model behavior and limitations, then use a coding agent to investigate, implement, and verify changes in a real project.

Understand LLMs
Explain the terminology, capabilities, and limitations behind the tools you use.
Configure your agent
Use project instructions, skills, tools, and verification hooks.
Verify the result
Review changes, run checks, and correct incomplete or incorrect work.
LLM fundamentals
Understand the basic concepts needed to use language models deliberately and explain their behavior.
Before you start: Engineering Fundamentals Python and basic familiarity with prediction tasks.
Learn
- LLMs, tokens, tokenization, parameters/weights, and next-token generation; distinguish pretraining, fine-tuning, and inference.
- An introductory transformer mental model: token embeddings, context-dependent attention, feed-forward layers, and next-token probabilities.
- Prompts, message roles, instructions, and examples; explain how prompting differs from changing model weights.
- Context windows, conversation history, and supplied information; distinguish model knowledge from external sources and stored session information.
- Hallucinations, knowledge limits, and variable outputs; recognize that a confident response is not evidence of correctness.
- Temperature, output limits, and basic quality, latency, and usage/cost tradeoffs; understand structured responses and why valid structure does not establish factual accuracy.
- Embeddings, retrieval, RAG, tool calling, agents, and harnesses at a conceptual level; explain which problem each addresses.
Resources
3Blue1Brown: Large Language Models explained briefly
Required. Begin with this visual overview of generation, learned weights, training, and transformer components.
3Blue1Brown: Large Language Models explained briefly — companion lesson
Further reading. A written reference for the video overview above.
3Blue1Brown: Transformers, the tech behind LLMs
Required selected material. Study the architecture overview, tokens and embeddings, and the path to next-token probabilities. Focus on explaining the components and the distinction between learned weights and input data; detailed calculations are supporting material.
Claude Academy: AI capabilities and limitations
Required selected lessons. Study model knowledge, context limits, and instruction-following. Complete the corresponding practical exercises and relate the observed limitations to the model overview.
Claude Academy: Building with the Claude API
Required selected lessons. Use the introductory request, message, sampling, and structured-response material, plus the introductory retrieval and tool-use lessons, to establish terminology. Full API integration, RAG implementation, and agent development belong to the electives.
Practice
- Sketch the path from input text through tokens, embeddings, transformer blocks, and output probabilities to a generated token. Explain which values are learned during training and which change with the input.
- Use an available model for a small extraction or question-answering task. Specify the desired response and check both its structure and its content.
- Compare a vague instruction with a clear instruction containing examples. Then supply relevant source material and inspect how the answer changes, including a question the source cannot answer.
- Record an observed limitation and explain whether clearer instructions, more relevant context, retrieval, tool use, or a different model would address it. Explain which changes alter the input and which would require model training.
Expected output
A short notebook or documented interaction record containing a model-flow sketch, prompts, outputs, checks, and an explanation of a model limitation. You can explain the terminology and distinguish prompting, model learning, external information, and tool execution. A model interface or Academy-provided endpoint can support the exercise.
Agent-assisted engineering
Work with an existing coding agent and understand the harness that manages its context, tools, and execution.
Before you start: the LLM fundamentals section and Software Engineering for AI; Engineering Fundamentals terminal, Git, and debugging skills.
Learn
- Understand the model, agentic loop, and harness: how a task leads to tool calls, actions, observations, and verification.
- Write clear tasks with relevant files, constraints, a manageable plan, and acceptance criteria.
- Maintain project instructions in CLAUDE.md or an equivalent file; manage context, compaction, and continuation across sessions.
- Choose appropriate permission settings, inspect tool actions, and interrupt or redirect an ineffective run.
- Create a reusable skill and understand how it differs from project instructions, hooks, subagents, and MCP connections.
- Use a verification hook or equivalent automated check; inspect diffs and test actual behavior rather than relying on a completion summary.
- Diagnose a failed attempt, correct the approach, and explain the resulting code and engineering decisions.
Resources
Claude Academy: Claude Code 101
Required. Complete the course and quiz. Apply its planning, context management, project instructions, and code-review workflow to your repository. Use the agent-loop lesson to understand the harness.
Claude Academy: Claude Code in action
Required selected lessons. Study steering longer sessions, project instructions, verification skills, permissions, hooks, and checking unsupervised work. Apply one verification mechanism. Scheduling, plugins, and headless automation are further reading.
Claude Academy: Introduction to agent skills
Further reading. Use the first-skill and troubleshooting lessons when developing your reusable procedure.
Claude Academy: Introduction to subagents
Further reading. Explore delegation after a single-agent workflow works reliably.
Practice
- Use an existing Python project. Define a bounded feature or bug fix with clear acceptance criteria and a baseline check.
- Add project instructions, ask the agent to inspect and plan the task, and review the plan before implementation.
- Create and use one reusable skill. Configure a hook or equivalent automated check that runs a relevant test or validation command; demonstrate both failure and success.
- Review the diff, verify normal behavior and a meaningful failure case, and correct an issue or reject an unsuitable suggestion.
- Continue the work in a fresh or resumed session, then submit the change through a pull request and respond to review.
Expected output
A runnable repository, a reviewed change, project instructions, one reusable skill, an automated verification check, and a short record of the checks and corrections. You can explain the implementation and fix a small bug during discussion. Use Academy-provided agent access where needed.
Workload
Workload estimate pending pilot. Include setup, practice, debugging, review, and revision.
Finish this module
Keep the LLM fundamentals exercise and agent-workflow outputs. Explain the terminology and your engineering decisions, diagnose a relevant failure during review, and revise incomplete evidence after feedback. Resource completion supports progress; practical requirements determine completion.







