What a Real AI Workshop Looks Like

The shape of a useful workshop is dictated by what the team needs to be able to do next quarter, not by a fixed curriculum. The discovery call sets the goal. The workshop builds toward it. The post-workshop check-in confirms the team is using what they learned.

• Pre-work: a 60-90 minute discovery call to map the team's stack, their current AI exposure, and the specific feature or workflow the workshop should unlock
• Custom syllabus: written and shared 1-2 weeks before delivery, including reading list, repo setup, and the working problem
• Live sessions: 60-70% hands-on labs, 20-30% live demos and architecture explanations, 10% Q&A and team-specific tangents
• Working artifact: by the end, the team has a running agent, RAG service, eval harness, or automation pipeline against their own data
• Reference repo: clean, documented, MIT-licensed code the team owns going forward, with patterns they can extend to other parts of the product
• Follow-up: a 60 minute Q&A 2-3 weeks after the workshop to unblock the team on whatever they hit when applying the material

Workshop Formats and When to Pick Each

Format is determined by the goal and the team size. Half-day sessions are for narrow upskilling on a specific topic. Full-day sessions are for hands-on builds that produce a working artifact. Multi-day cohorts are for teams that need to absorb a stack from zero to production-ready. Mixing formats inside one engagement is usually a mistake.

• Half-day (3-4 hours): focused topic, e.g. prompt engineering for engineers, evaluation strategy, or MCP server basics. Best for teams that already ship AI features and need a specific skill
• Full-day (6-7 hours): hands-on build session. Team finishes with a working agent or RAG service. Sweet spot for engineering teams of 5-12 who want a working pattern, not a survey
• Two-day deep dive: full agent build with tool use, memory, evaluation, and observability. Day one architecture and primitives, day two integration and durability. Best for teams shipping their first production agent
• Three-day intensive: agentic systems with multi-agent patterns, MCP integration, eval frameworks, and CI integration. Best for teams building the AI platform other teams will use
• Five-day cohort: full AI engineering bootcamp covering LLM apps, retrieval, agents, evals, observability, and production patterns. Best when a team is being created from scratch or pivoting hard into AI
• On-site vs remote: on-site beats remote for whiteboarding and pair work but adds travel cost. Remote works well when the team is already distributed and used to async tooling
• Hybrid cohort: live workshop blocks plus async homework, common for multi-week formats. Requires more facilitator effort but fits busy engineering calendars

Curriculum Modules That Actually Get Booked

The catalog below is the working set of modules teams ask for in 2026. Most engagements pick three to six and arrange them into a one to three day sequence. The selection is driven by where the team is on the curve: pre-production teams need foundations and patterns, production teams need evaluation and observability, platform teams need orchestration and MCP.

• LLM application fundamentals: prompting, structured outputs, function calling, cost and latency budgets, model selection across OpenAI, Anthropic, Google, and open weights
• Retrieval-augmented generation: chunking strategies, embedding models, vector stores (pgvector, Pinecone, Weaviate, Turbopuffer), hybrid search, reranking, and the patterns that survive at scale
• Agent design: ReAct, Plan-and-Execute, supervisor, swarm. Picking the right pattern for the task and not over-engineering
• Tool use and Model Context Protocol: writing MCP servers, exposing internal APIs as tools, schema design, error message design, and the security model around tool surfaces
• Memory architecture: short-term scratchpads, long-term episodic and semantic stores, compaction, and the frameworks (LangMem, Mem0, Zep, Letta) that encode them
• Evaluation: trajectory-level eval, LLM-as-judge with rubrics, golden test suites, and the platforms (LangSmith, Langfuse, Braintrust, Arize Phoenix) that make evals routine
• Observability and debugging: trace structure, span design, prompt versioning, and the workflow for diagnosing a failed agent run in production
• Recovery and durability: idempotent tool design, retry policy, budget caps, human-in-the-loop checkpoints, and durable execution with Temporal or Restate
• Cost and latency engineering: prompt caching, streaming, batching, smaller-model routing, and the architecture choices that bring an agent from cents per run to fractions of a cent
• Safety and guardrails: input sanitization, prompt injection defense, output validation, and the policies needed for regulated domains

Audience and Prerequisites

A workshop is only as good as the room is calibrated. Mixed-seniority rooms work if the labs allow self-pacing. Mixed-role rooms (engineers and PMs together) only work for foundations modules; deeper technical modules need a single audience.

• Engineers and tech leads: comfortable with Python or TypeScript, have shipped at least one production service, no prior LLM experience required for foundations
• Engineering managers and architects: same baseline plus an interest in cost, evaluation, and the operational shape of AI in production
• Product managers and designers: can join the foundations and patterns modules, sit out the deeper labs, work on use-case design in parallel
• Executives and L&D: separate executive briefing module, 90-120 minutes, no code, focused on framing, governance, and decision authority
• Required setup before day one: working dev environment, API keys provisioned, repo cloned, sample data accessible, network access to the relevant providers
• Recommended pre-reading: Anthropic's "Building Effective Agents," OpenAI's Agents SDK quickstart, and one chapter from a stack-relevant resource
• Healthy cohort size: 6-12 engineers for deep labs, up to 25 for foundations and architecture modules, larger groups dilute facilitator attention

Deliverables the Team Keeps

The deliverables are the reason this engagement exists. Without them, a workshop is a TED talk. The artifacts below are what the team owns after the engagement ends, and what they use to extend the work without further facilitator help.

• Reference repository: working code for every lab, organized so the team can lift patterns directly into their production codebase
• Slide deck and architecture diagrams: for internal sharing, onboarding new hires, and presenting back to leadership
• Session recordings: useful for absent team members and for replay during the first weeks of applying the material
• Written notes and decisions log: which patterns we picked, which we rejected, and why, so the rationale is durable
• Evaluation harness: a working eval setup the team can extend with their own cases
• Custom exercises: rebuilt against the team's own data, so the patterns are obvious to apply
• Follow-up Q&A: a scheduled session 2-3 weeks later to clear blockers that only surface during real application
• Optional retainer: monthly hours for the months after the workshop, used as needed for code review and architectural sanity checks

Pricing and How Engagements Get Scoped

Workshop pricing has hardened in the last 18 months as senior practitioners moved into independent training full-time. The market price for a tailored, code-first engagement with a senior facilitator is materially higher than catalog bootcamp pricing because the engineering and customization happen before the room ever opens.

• Half-day focused session: $5,000-$10,000 depending on customization and team size
• Full-day hands-on build: $10,000-$20,000, includes discovery call, custom labs, and reference repo
• Two-day deep dive: $20,000-$35,000, includes follow-up session and 30 days of async Q&A
• Three-day intensive: $30,000-$50,000, the most common shape for engineering teams of 6-15
• Five-day cohort or multi-week format: $50,000-$120,000, typically includes a capstone and a written architecture document
• Industry benchmark from public training market data: per-engagement programs for 10-15 person teams cluster at $19,500-$50,000 for cohort formats, $96K-$180K for executive enterprise tracks, and $250K+ at Big Four scale
• What drives variance: customization depth, on-site travel, cohort size, post-workshop retainer scope, and the level of code review included
• Red flags: per-seat pricing on a tailored engagement (the value is the room, not the seat), fixed-syllabus offers labeled as "custom," and any provider who quotes without a discovery call

What Separates a Workshop That Sticks from One That Does Not

The single best predictor of whether a workshop produces lasting behavior change is what happens in the two weeks after the session. Teams that ship a feature based on the material in those two weeks retain almost all of what they learned. Teams that wait a quarter retain almost nothing. The workshop has to be timed to a real shipping window, and the work has to be obviously easier the day after.

• Real codebase, real data: generic examples are forgettable, working in the team's own repo with their own data is not
• Working artifact at the end of every day: never end a session without something running
• Pair work, not lecture: facilitator pairs with engineers in their IDE, surfaces real friction, fixes it on the spot
• Opinionated patterns: the facilitator should make calls, not survey options. Teams need a reference architecture they can defend, not a menu
• Written rationale: every pattern picked is documented with why, so the team can defend the choice when the next architect questions it
• Post-workshop accountability: a real check-in two weeks later, with the team showing what they shipped, not what they remember
• Calibration on next steps: the workshop ends with a roadmap for what to build next, not a generic "happy hacking"

How to Brief a Workshop Provider

The discovery call is the gate. A facilitator who books a workshop without it is selling a fixed syllabus. The brief below is the working set of inputs a senior practitioner needs to design a workshop that earns its fee.

• Team shape: roles, headcount, seniority distribution, geography, who must attend and who is optional
• Current stack: language, framework, hosting, current LLM exposure if any, current eval and observability tooling
• The bottleneck: the one feature, workflow, or capability the team is stuck on or about to start
• Constraints: privacy, regulated data, on-prem only, model approval lists, vendor relationships
• Timeline: when is the workshop, when is the work it unblocks supposed to ship
• Success criteria: what the team should be doing in the four weeks after the workshop that they cannot do today
• Budget envelope: even an approximate range lets the facilitator scope the right depth and format
• Decision rights: who signs the SOW, who approves the syllabus, who hosts the room

FAQ