Prompting and Context Engineering for Software Engineers
Prompting and context engineering for software engineers: system prompts, few-shot examples, structured output, and context files, skills, and MCP for agents.
Course catalog
162 live, instructor-led courses in AI coding tools, AI engineering, programming languages, frameworks, cloud, and DevOps. All run online, most can also run on-site, and every outline can be adjusted to your team's stack.
Prompting and context engineering for software engineers: system prompts, few-shot examples, structured output, and context files, skills, and MCP for agents.
A model-agnostic comparison of Claude, GPT, and Gemini for developers: capabilities, pricing, latency, and choosing the right model for each task.
Adopt AWS's AI-Driven Development Life Cycle as a team, with approval gates, mob sessions, and AI-DLC Workflows in Kiro, Claude Code, Copilot, Cursor, or Codex.
Spec-driven development with AI coding agents: GitHub Spec Kit in depth, compared with Kiro specs, OpenSpec, and BMAD, plus spec review gates in CI.
A one-day, no-code course for product owners and analysts on AI-DLC and spec-driven work: Mob Elaboration, approval gates, EARS, and spec review.
Compare VS Code with GitHub Copilot, Cursor, Kiro, Google Antigravity, Devin Desktop, and Zed on the same tasks, then choose and roll out an AI IDE.
Use GitHub Copilot across the IDE, the Copilot CLI, the cloud agent, and the Copilot app, with code review, custom agents, skills, MCP, and governance.
Claude Code training for developers: plan, delegate, and review engineering work, then extend Claude Code with skills, hooks, and plugins and run it in CI.
Work with Cursor's editor, Agents Window, and cloud agents, and set up rules, skills, hooks, MCP, the Cursor CLI, Bugbot review, and team governance.
Kiro course on spec-driven agentic coding: EARS requirements, designs, and task plans, plus steering, hooks, powers, Kiro CLI in CI, and Q Developer migration.
Use Google Antigravity and Gemini models to plan, run, and review agent work in the Antigravity App, the Antigravity CLI, and IDE extensions.
Use OpenAI Codex in the CLI, the IDE extension, the ChatGPT desktop app, and Codex Cloud, with AGENTS.md, MCP, skills, scheduled tasks, review, and CI.
Use Devin Desktop (formerly Windsurf) to run Devin Local in the editor, hand work to Devin Cloud, and manage agents from the Agent Command Center.
A 7-hour survey of Claude Code, OpenAI Codex, and Devin that compares how each agent works and helps teams choose one to pilot.
Ground AI coding agents in large private codebases with code embeddings, AST-aware chunking, hybrid search, reranking, retrieval evals, and MCP.
Run AI review agents on pull requests: Copilot code review, Claude Code in CI, Codex, Cursor Bugbot, auto-fix pipelines, and review policy design.
Secure AI-assisted development against prompt injection, secret leakage, MCP and tool threats, and supply-chain risk, with sandboxing and OWASP mappings.
Govern AI-assisted development: IP and licensing of AI-generated code, vendor review, team policy, governance frameworks, and honest productivity metrics.
Use AI agents to document, test, refactor, and migrate legacy codebases with dependency mapping, strangler fig patterns, and incremental modernization.
AI-driven test generation for developers: find coverage gaps, then generate, validate, and maintain unit, integration, and end-to-end tests with coding agents.
AI agents for DevOps and SRE teams: infrastructure as code, CI/CD pipelines, incident response, runbook automation, and LLM-assisted log and trace analysis.
Language-agnostic AI-assisted development in five days: prompting, context engineering, coding agents, AI-driven testing, MCP, and governed adoption.
AI-assisted Python development in a five-day course: prompting, context engineering, IDE assistants, agentic coding, AI-driven testing, and governed adoption.
Rust developers put AI coding tools to work for five days: prompting, IDE assistants, agentic coding with the compiler in the loop, testing, and governance.
JavaScript and TypeScript developers spend five days with AI coding tools: prompting, IDE assistants, agentic coding, testing, and governed adoption.
AI coding tools for C# and .NET developers: a five-day course on prompting, context engineering, agentic coding, AI-driven testing, and governed adoption.
Build LLM applications in Python over five days, from model APIs and Pydantic outputs to streaming FastAPI services, RAG, evals, and deployment.
Python developers build AI agents in this five-day course, from a hand-written agent loop to LangGraph, Pydantic AI, MCP servers, orchestration, and evals.
Generative AI for software developers, from how LLMs work to RAG, the Model Context Protocol, single and multi-agent systems, and evaluation.
Machine learning in Python for software developers: pandas, scikit-learn, XGBoost, and PyTorch, from messy data to models served with FastAPI and ONNX.
Run machine learning at production scale on a lakehouse with Spark 4, dbt, Airflow 3, Kafka 4, and MLflow 3, from data pipelines to automated retraining.
Build AI agents with Strands Agents and run them on Amazon Bedrock AgentCore, with tools, MCP, memory, identity, evaluation, and security controls.
Build agents with the Claude Agent SDK, OpenAI Agents SDK, and Google ADK, then connect them with MCP and A2A, trace and test them, and deploy them.
Build C# agents with Microsoft Agent Framework, from tools, memory, and middleware to checkpointed workflows, A2A, and hosting on Microsoft Foundry.
Build LLM applications in TypeScript and Python, with prompt pipelines, streaming, structured output, tool calling, cost tracking, and deployment.
Build retrieval-augmented generation (RAG) systems that hold up in production, with better chunking, hybrid search, reranking, evaluation, and deployment.
Design multi-agent systems with orchestration patterns, planner/worker decomposition, hand-offs, shared state, failure recovery, and safety boundaries.
Add voice and multimodal AI to applications: real-time voice, vision, and document understanding, with patterns for latency, reliability, cost, and privacy.
Build and consume Model Context Protocol servers that connect AI assistants and coding agents to internal tools, data sources, and APIs.
Design tools that AI coding agents call reliably, run them in sandboxes, write Agent Skills, and package both as plugins and MCP servers.
Build eval suites, golden datasets, and CI regression checks that measure the quality of AI coding assistants and LLM applications.
Trace LLM applications, enforce token budgets, cache and version prompts, and attribute model cost by feature, user, and model.
Build layered guardrails for LLM apps and agents, from validation and moderation to prompt-injection defense, mapped to the OWASP Top 10 lists.
Cut LLM latency and raise throughput with streaming, caching, model routing, speculative decoding, and quantization, measured against latency budgets.
Rust for developers new to the language, on the 2024 edition: ownership, borrowing, types, pattern matching, error handling, and checking AI-written Rust.
Rust from first program to traits, async, concurrency, unsafe code, FFI, and macros, in a 35-hour course for developers new to the language.
Rust for Python developers on the 2024 edition: ownership, types, traits, async, and Python extension modules built with PyO3 and maturin.
Rust for JavaScript and TypeScript developers on the 2024 edition, from ownership and traits to async Tokio services, Actix-web 4 APIs, and Leptos apps.
Rust for C# and .NET developers on the 2024 edition, comparing ownership with the GC, enums with C# unions, traits with interfaces, and Tokio with Task.
Rust refresher for developers returning to the language: ownership, data modeling, pattern matching, generics, and what changed in the 2024 edition.
A focused Rust course on the borrow checker, lifetimes, smart pointers, interior mutability, self-referential data, and reviewing AI-written Rust.
Parallel and concurrent Rust on the 2024 edition with Rayon, Crossbeam, channels, atomics, and async, with concurrent code tested under Loom and Miri.
Python 3.15 course for programmers new to Python: core data types, control flow, functions, exceptions, and classes, with uv and Ruff for tooling.
Intermediate Python 3.15 course: uv lockfiles, type hints, advanced functions and classes, asyncio, threads, and the free-threaded build.
Advanced Python 3.15 course for experienced developers: the object model, typing, asyncio, free-threading, uv and Ruff, and profiling.
Object-oriented Python with classes, dataclasses, protocols, SOLID, and design patterns, using AI coding assistants.
Unit test Python 3.15 code with pytest 9 and unittest, from fixtures and mocking to Hypothesis property tests, coverage, and CI.
C programming course for Python developers: modern C23 with a focus on memory safety, then calling your own C libraries and extensions from Python.
Speed up Python with native code using the C API, pybind11, nanobind, and Cython 3, including stable ABI and free-threaded extensions.
Rewrite CPU-bound Python hot paths in Rust with PyO3 and Maturin, release the GIL, support free-threaded Python, and ship wheels to PyPI.
AWS Lambda training for programmers with some Python: review core Python and tooling, then build, deploy, and operate Python functions on Lambda.
Azure Functions training for programmers with some Python: review core Python, then build v2 model functions and deploy them on Flex Consumption.
Modern C# on .NET 10 LTS and .NET 11 for developers new to the language, from records, pattern matching, and union types to async, testing, and EF Core.
JavaScript course for programmers new to the language, covering core syntax, built-in objects, the DOM, forms, modules, fetch, and async/await in the browser.
Advanced JavaScript for working developers, covering iterator helpers, Set methods, async patterns, resource management, Temporal, modules, and testing.
A five-day introduction to web development: semantic, accessible HTML, modern CSS with :has() and container queries, JavaScript, Node.js, and browser APIs.
Build and run back-end services on Node.js 26 with ES modules, node:test, type stripping, Express 5, node:sqlite, the permission model, and containers.
A one-day course on moving Jest test suites to Vitest 5, covering config, mocks, timers, snapshots, DOM environments, coverage, CI, codemods, and AI agents.
A two-day introduction to TypeScript 7 covering structural typing, narrowing, generics, satisfies, classes, decorators, using declarations, and tsconfig.
An in-depth course on TypeScript's type system: generics, conditional and mapped types, template literals, declaration files, and the TypeScript 7 compiler.
Build Node.js back ends in TypeScript with Fastify 5, Zod 4 validation, Drizzle, JWT and OIDC auth, tRPC and OpenAPI, Vitest, and Docker.
Move an existing JavaScript codebase to TypeScript step by step, with allowJs, checkJs, JSDoc, strictness ratcheting, codemods, and AI coding agents.
TypeScript for C# developers, taught by translation: structural typing, erased generics, LINQ to array methods, async on the event loop, modules, and npm.
Zig 0.17 from the ground up: comptime, explicit allocators, error unions, the std.Io interface, the build system, testing, and C interop.
Zig for experienced C and C++ developers: map pointers, RAII, errno, NULL, and malloc onto slices, defer, error unions, optionals, and allocators.
Zig as build infrastructure for C and C++ teams: cross-compiling with zig cc, target triples, glibc and musl, build.zig, packages, and CI.
Modern C++ from the ground up through C++26, covering value semantics, RAII, class design, templates, concepts, the standard library, and tooling.
Advanced modern C++ through C++26, from move semantics and concepts to reflection, std::execution, contracts, hardening, and legacy code modernization.
Automate everyday work with Python: files, documents, subprocesses, logging, command-line arguments, async I/O, and APIs, with optional AI coding agent modules.
Build distributed task pipelines in Python: Celery with RabbitMQ or Redis, Apache Kafka 4 in KRaft mode, Kafka-to-Celery patterns, and stream processing.
Build Apache Airflow 3.4 pipelines in Python: the Task SDK, assets, DAG versioning, dynamic and deferrable tasks, and the KubernetesPodOperator.
Run Apache Airflow 3.4 as a platform: executors, Helm on Kubernetes, auth managers, upgrades from Airflow 2, and OpenTelemetry monitoring.
Data engineering course on Ansible, Apache Airflow 3, and Snowflake, including Snowpark, Dynamic Tables, dbt Projects on Snowflake, and Cortex AI Functions.
Apache Spark 4 and PySpark course for batch and streaming pipelines: Spark Connect, Declarative Pipelines, Real-Time Mode, and tuning on any platform.
Jupyter widgets course: build custom widgets with ipywidgets 8 and anywidget, using Python classes and ESM front ends for JupyterLab and Notebook 7.
A broad generative AI course for Python developers, from transformer basics and prompting to RAG, fine-tuning, agents, evals, and responsible AI.
.NET MAUI course for C# developers: native iOS, Android, Windows, and Mac apps on .NET 10 LTS and .NET 11, from XAML and MVVM to store release.
.NET MAUI Blazor Hybrid on .NET 10 and .NET 11: ship native iOS, Android, Windows, and Mac apps from Razor components and share UI with the web.
Test .NET MAUI XAML and Blazor Hybrid apps on .NET 10 and .NET 11 with view model unit tests, bUnit, device test projects, Appium, and CI.
React 19 with JavaScript for developers new to React: components, hooks, forms with Actions, REST API calls, React Router, and unit tests with Vitest.
React 19 course taught in TypeScript, for developers new to React: typed components and hooks, form Actions, REST APIs, routing, and Vitest tests.
Advanced client-side React 19 for experienced developers, covering Actions, the React Compiler, Activity, View Transitions, Suspense, and performance work.
Next.js 16 course for developers new to React: React 19 basics, then the App Router, Server Components, Server Actions, caching, testing, and deployment.
Build full-stack React apps with React Router 8 framework mode, from loaders, actions, and middleware to SSR, and upgrade existing v7 apps.
Build full-stack React apps with TanStack Start 1.0, using type-safe routing, server functions, middleware, streaming SSR, and TanStack Query.
Add real-time features to React and ASP.NET Core MVC apps with SignalR, from typed hubs and the React client to security, reconnection, and scale-out.
ASP.NET Core Blazor on .NET 10 LTS and .NET 11: build interactive web UIs in C#, from Razor components and render modes to forms, routing, and deployment.
Blazor and ASP.NET Core on .NET 10 LTS and .NET 11: full-stack web apps with Minimal APIs, OpenAPI, Entity Framework Core, SignalR, and Aspire.
Test-driven development for Blazor and ASP.NET Core APIs on .NET 10 and .NET 11 with xUnit v3, bUnit, Testcontainers, Playwright for .NET, and CI/CD.
Angular 22 for developers new to the framework: components with signals and control flow, routing, services, pipes, and data loading with httpResource.
Angular 22 in depth for developers new to Angular: signals, control flow, Signal Forms, httpResource, routing, zoneless apps, SSR, and Vitest testing.
Bring a legacy Angular codebase up to Angular 22 one step at a time: standalone components, control flow, zoneless, signals, Signal Forms, and Vitest.
Svelte 5 and SvelteKit 3 for web developers new to Svelte: runes, snippets, attachments, routing, load functions, SSR, and progressively enhanced forms.
Svelte 5 and SvelteKit 3 taught side by side with React: hooks become runes, JSX becomes templates, and Next.js patterns map to SvelteKit.
Svelte 5 and SvelteKit 3 for Angular developers, mapping signals to runes, services to reactive classes, and the Angular Router to SvelteKit routing.
Advanced Svelte 5 and SvelteKit 3 for working developers, covering reactivity, attachments, typed components, motion, hooks, async Svelte, and testing.
Build full-stack apps with SvelteKit 3 and a FastAPI or ASP.NET Core API, connected by a typed OpenAPI client, with auth, real-time updates, and deployment.
A one-day course on upgrading SvelteKit 2 apps to SvelteKit 3, from preparing on 2.x and running sv migrate to fixing breaking changes and rolling out.
Vue 3 from the ground up for web developers, with the Composition API, TypeScript, Pinia, Vue Router 5, Vitest, and a preview of Vapor Mode.
Vue 3 for React developers, taught by comparison: hooks to the Composition API, context to provide/inject, Redux to Pinia, React Router to Vue Router.
Build full-stack apps with a Vue 3 front end and a FastAPI back end, using Pinia, Vue Router 5, Pydantic, async SQLAlchemy, and JWT security.
Build HTML-first web apps with HTMX 2 and the server language you already use, then plan the upgrade to HTMX 4.
Build REST APIs with Python and FastAPI using Pydantic 2 models, async SQLAlchemy 2.x, OAuth2 and JWT security, OpenAPI 3.1 docs, and cloud deployment.
Move Flask and Flask-RESTX APIs to FastAPI route by route, with Pydantic models, OpenAPI contract checks, side-by-side cutover, and AI coding agents.
Build, secure, document, and test REST APIs with Spring Boot 4 and Java 25: records, virtual threads, RestClient, Problem Details, and Testcontainers.
Upgrade Spring Boot 3.x services to Spring Boot 4 and Spring Framework 7 with OpenRewrite and AI coding agents, covering Jakarta EE 11 and Jackson 3.
Build REST APIs in Rust with Actix-web 4: routing, extractors, middleware, WebSockets, OpenAPI with utoipa, sqlx and PostgreSQL, testing, and deployment.
Build reusable, framework-agnostic UI with the Web Components standards, from Custom Elements and Shadow DOM to form-associated elements and testing.
Build and ship Web Components with Lit 3, from reactive controllers, context, and SSR to design-system APIs, testing, and npm publishing.
Leptos course for Rust developers building full-stack web apps with fine-grained reactivity, server functions, routing, and server rendering with hydration.
Tauri 2 and Rust for cross-platform desktop and mobile apps, from commands and capabilities to native menus, iOS, Android, and signed installers.
WPF and MVVM on modern .NET for C# developers new to WPF, from XAML and data binding to CommunityToolkit.Mvvm view models and their tests.
WPF on modern .NET for developers past the basics: build, tune, and ship desktop apps with custom controls, large data grids, Windows interop, and deployment.
Docker training for programmers: Dockerfiles, Compose, hardened images and SBOMs, DevContainers, CI/CD pipelines, and the move to Kubernetes.
Kubernetes 1.37 course for programmers: YAML, workloads, Helm, Headlamp, Gateway API, storage, RBAC, Pod Security Admission, monitoring, and CI/CD.
Docker and Kubernetes in five days: images, Compose, deployments, services, Gateway API, Helm, and a managed Kubernetes module on Amazon EKS or Azure AKS.
Move off the retired ingress-nginx controller to the Kubernetes Gateway API: implementations, ingress2gateway, annotation mapping, TLS, canary, and cutover.
Build production CI/CD pipelines with GitHub Actions: workflow syntax, matrix builds, caching, reusable workflows, environments, OIDC auth, and security.
Use GitHub Secret Protection and GitHub Code Security: secret scanning, push protection, CodeQL, Copilot Autofix, and Dependabot in your pipelines.
Azure DevOps from planning to release: Boards, Repos, Pipelines, Test Plans, Artifacts, infrastructure as code, and working alongside or moving to GitHub.
Plan and run a phased move from Azure DevOps to GitHub: Enterprise Importer, Actions Importer, Boards options, identity, Advanced Security, and coexistence.
Terraform training for Azure teams: HCL, the AzureRM 5.x provider, modules, remote state, testing, CI/CD, governance, and OpenTofu.
Instrument traces, metrics, and logs with OpenTelemetry in Python, .NET, and Node.js: the Collector, sampling, semantic conventions, SLOs, and cost control.
Move from the AWS X-Ray SDKs and daemon, now in maintenance mode, to OpenTelemetry and ADOT: Lambda, ECS, EKS, sampling, backends, and verified cutover.
Secure coding, threat modeling, the OWASP Top 10:2025, supply chain security (SBOM, SLSA, signing), AI and agent risks, and DevSecOps with SAST and DAST.
AWS foundation course for engineers new to the cloud: cloud concepts, IAM and security, compute, storage, databases, networking, monitoring, and cost.
Design resilient, secure, cost-aware AWS solutions with the Well-Architected Framework: compute, serverless, data, networking, observability, and AI.
Build production generative AI on Amazon Bedrock: models, Knowledge Bases for RAG, Strands Agents and AgentCore, Guardrails, customization, and evaluation.
An introduction to Microsoft Azure for engineers, aligned with the AZ-900 exam: cloud concepts, compute, storage, networking, Entra ID, governance, and cost.
Design enterprise Azure infrastructure with the Well-Architected Framework: governance, compute, containers, networking, zero-trust security, and Bicep.
Build AI agents on Microsoft Foundry and Copilot Studio: low-code and pro-code agents, Foundry Agent Service, orchestration, evaluation, and governance.
How cloud reshapes enterprise architecture: cloud models, the 7 Rs migration framework, security, governance, FinOps Framework 2026, and organizational change.
A standards-first introduction to SQL on PostgreSQL 18: the relational model, SELECT, joins, aggregation, subqueries, CTEs, and window functions.
Use PostgreSQL 18 from Python: SQL, schema design, JSONB, PL/pgSQL, async SQLAlchemy with asyncpg, pandas, and pgvector similarity search.
Write PostgreSQL stored procedures and functions in SQL and PL/pgSQL: parameters, transactions, triggers, dynamic SQL, security, and testing.
Administer PostgreSQL 18: installation, security, tuning, backup and recovery, replication, upgrades, and running in containers and the cloud.
Run PostgreSQL 18 on Amazon RDS: provisioning, security, Database Insights monitoring, RDS Proxy, backups, and Blue/Green upgrades.
Run PostgreSQL 18 on Azure Database for PostgreSQL flexible server: provisioning, Entra ID security, high availability, elastic clusters, and migration.
Use Git well: the object model, branching strategies, pull request workflows, interactive rebase and bisect, reflog recovery, and GitHub team features.
Linux command line and Bash for developers: shell basics, files and processes, pipes, grep, sed, awk, jq, and reliable Bash scripts.
Design HTTP APIs: resource modeling, HTTP semantics, versioning, RFC 9457 errors, contract-first OpenAPI 3.2, OAuth 2.0, webhooks, GraphQL, and gRPC.
SOLID and the Gang of Four patterns for Python developers: Pythonic alternatives with first-class functions, protocols, decorators, and modules.
SOLID and Gang of Four patterns for C# on .NET 10 and .NET 11: delegates, records, pattern matching, union types, LINQ, and dependency injection.
SOLID and the Gang of Four patterns for TypeScript developers: structural typing, discriminated unions, generics, functional composition, and DI.
Build a reliable Playwright end-to-end suite: locators, web-first assertions, fixtures, network mocking, parallelism, trace debugging, and flake reduction.
Jargon-free AI training for staff in every role: prompting, documents, research, data, AI agents, checking output, data protection, and EU AI Act literacy.
Build no-code Microsoft 365 Copilot agents with Agent Builder: instructions, knowledge, skills, sharing, Agent 365 governance, and copying to Copilot Studio.
Build no-code assistants and agents with Claude: Projects, instructions, knowledge, Skills, plugins, connectors, Cowork, and Team and Enterprise controls.
Build ChatGPT plugins from skills, apps, and MCP, create workspace agents, and migrate custom GPTs to plugins before they retire, with admin governance.
Build Gemini skills in the Gemini app and Google Workspace, automate work with Workspace Studio flows, and move from Gems to skills before Gems stop.
Build AI agents in Microsoft Copilot Studio with harnesses, skills, Work IQ, tools, workflows, triggers, and evaluations, then publish them to Teams.
Build integrated Copilot Studio agents with Work IQ, Foundry IQ, MCP, A2A, agent flows, evaluations, and ALM, aligned with exam AB-620.
Try a different word or remove a filter. We also build custom courses from our outlines when nothing fits.
Combine courses into a program, or let us build a curriculum around your team.
Online with Zoom, Microsoft Teams, Cisco WebEx, GoTo Training, or Google Meet, or on-site at your location.
Full days, half days, or a few hours a day spread over several weeks.
Every outline is a starting point. We adjust any course to your team's tools, stack, and goals.
Classes we sell directly can be recorded, with each day's recording available once the meeting software finishes processing it. Training marketplaces may have different policies.
Short courses for teams facing a platform retirement or a major-version upgrade. Most of the code migration courses use AI coding agents for the mechanical changes and teach your team to check the results.
Two AI coding tool courses also cover a move: the Kiro course includes moving teams from Amazon Q Developer, and the Google Antigravity course includes moving from Gemini CLI.
Private team training
Tell us what your team works on and what it needs to learn. We will recommend a course or a combination of courses and adjust the outline to your stack.
Prefer to talk? Call +1 434-509-6890 or email help@cloudcontraptions.com.