Skip to main content
Version: Current

LLM Fundamentals and Agent Workflows

Core SystemsModule 3 · Required

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

Illustration of a layered language model processing streams of tokens.

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​

video

3Blue1Brown: Large Language Models explained briefly

Required. Begin with this visual overview of generation, learned weights, training, and transformer components.

article
Further reading

3Blue1Brown: Large Language Models explained briefly — companion lesson

Further reading. A written reference for the video overview above.

video
Selected scope

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.

course
Selected scope

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.

course
Selected scope

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​

course

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.

course
Selected scope

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.

course
Further reading

Claude Academy: Introduction to agent skills

Further reading. Use the first-skill and troubleshooting lessons when developing your reusable procedure.

course
Further reading

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.