Eight decks.
Pick your level.

You know what an LLM is. You just don't know which tool to open.

• You use ChatGPT or Claude and wonder what else exists
• You don't write code — and don't plan to
• You want to know what things cost before you ask for a licence

You'll leave with A practical way to choose tools by task, review their output, and work with files or connected apps. Product tables are in a separate reference deck.

31 slides · no code · reference deck included

You write code and want an agent doing it with you — starting today.

• You've heard of Claude Code / Copilot but never really used one
• You want the mental model: model, harness, agent, the loop
• You want to know what it's allowed to touch, and how to teach it your project

You'll leave with One invoice example that explains the agent loop, context, permissions, project rules and tools — ending with a task you can verify.

26 slides · optional demo · reference deck included

You use agents and want to understand their machinery and failure modes.

• Connect the model, harness and tool results
• Define verifiers and enforce bounded loops
• Measure context, cost and delegation choices

You'll leave with Model and harness mechanics, bounded verification loops, worked cost arithmetic, context, delegation and reusable checks.

30 slides · 10-slide reference · no live run required

You want to know what helpers inherit and when cached input saves work.

• Distinguish fresh contexts from conversation forks
• Design task inputs and evidence-bearing returns
• Calculate cache reuse, warm-up and break-even

You'll leave with Fresh helpers versus forks, evidence-bearing returns, local/cloud boundaries, cache eligibility, warm-up and break-even arithmetic.

21 slides · 4-slide reference · no live run required

You want to measure a complete task and simplify its instructions.

• Read uncached input, cache and output usage separately
• Choose an access route from actual requirements
• Compare instruction variants without losing correctness

You'll leave with A worked bill, access-route decisions, a before/after instruction file and an exercise that checks correctness as well as usage.

17 slides · 4-slide reference · no live run required

You need clear ownership, boundaries and review when work is delegated.

• Follow one ticket through claim, work and review
• Separate workspaces from security containment
• Compare skills, tools and interface choices in context

You'll leave with One ticket lifecycle, coordination versus containment, verification skills and an MCP/CLI comparison exercise.

19 slides · 4-slide reference · no live run required

You want evidence that a prompt, model or workflow change helped.

• Define cases, graders and repeated trials
• Inspect traces without assuming every repeat is waste
• Compare complete results, including failures and cost

You'll leave with Invoice acceptance cases, graders, repeated trials, trace interpretation, a scoring worksheet and measured hardware choices.

19 slides · 5-slide reference · no live run required

You use Claude Code daily and want practices to test in your own repository.

• Audit conflicting and outdated instructions
• Build a useful verification skill
• Measure effort, caching and delegation tradeoffs

You'll leave with Applied lessons from Anthropic engineering posts: instruction audits, verification skills, cache tradeoffs, measured effort and two delegation patterns.

30 slides · 5-slide reference · no live run required

You want hands-on exercises that work with or without a live agent.

• Define and score invoice acceptance cases
• Revise instructions and design a ticket contract
• Write a verification skill and your next experiment

You'll leave with A 210-minute workshop with timeboxes, participant outputs and self-contained invoice exercises. Optional live execution has explicit preparation requirements.

44 slides · 8-slide reference · 210 minutes · static exercises included