A hands on technical workshop is where an engineering claim meets its constraints. Not a slide saying an agent can call tools, but a working implementation with permissions, logs, failed inputs, latency limits, and a clear answer to who can stop it. For teams adopting AI and changing their platforms, that distinction matters more than another product demo.
The best workshops do not promise that everyone leaves with the same solution. They create enough shared context for people to make better decisions in their own codebases. You build something real, observe where it breaks, and leave with a model for the next decision.
Why a hands on technical workshop changes the work
Talks are useful for pattern recognition. A strong speaker can explain why prompt injection changes the security boundary, why idempotency is necessary in a distributed workflow, or why generated code still needs an understandable architecture. A workshop has a different job: it makes participants encounter the implementation costs themselves.
That means working through the questions that presentations often have to compress. What happens when an agent receives untrusted content and has access to an internal tool? Where does policy enforcement sit when several services can initiate an action? Which telemetry is useful when an existing application has no consistent tracing? How do you test a retrieval pipeline when a plausible answer is still wrong?
Those questions cannot be settled by copying a repository or accepting a vendor default. They require choices. A hands on format gives engineers time to make those choices, inspect the consequences, and compare them with other practitioners in the room.
For senior engineers and technical leads, the value is also organizational. You see which assumptions need to be documented, where your team lacks a common vocabulary, and which parts of a proposed architecture are too fragile to delegate. That is practical evidence for a roadmap, not just personal learning.
Start with a problem that can fail
A workshop should begin with a bounded technical problem, not a broad topic. “Build an AI agent” is too vague. “Build an agent that can query a support system without allowing prompt-injected content to issue refunds” gives the work a boundary. So does “add OpenTelemetry to a service with incomplete instrumentation” or “design a retry-safe workflow for an event that may be delivered twice.”
A useful exercise includes a failure mode on purpose. Give participants an adversarial document in a RAG corpus. Introduce duplicate messages in an event stream. Set a token budget that makes unrestricted tool use impractical. Remove a dependency and ask the system to degrade without losing critical work.
This changes the conversation from capability to control. Many systems look convincing when inputs are clean and services respond immediately. Production behavior is defined at the edges: stale context, partial failure, unclear ownership, surprising user input, and pressure to ship before the design is understood.
The right level of difficulty depends on the audience. A workshop for engineers new to a platform may prioritize a runnable baseline and clear guidance. A session for experienced architects can begin with competing constraints and ask groups to defend different designs. Neither approach is inherently better. The important part is being honest about the intended starting point.
Working code is necessary, not sufficient
A repository that runs on every laptop is table stakes. It reduces setup friction and protects the time set aside for learning. But a prebuilt environment should not turn participants into button-clickers.
The exercise needs deliberate gaps. Perhaps authorization checks are absent, traces are inconsistent, retrieval and generation are evaluated as one opaque score, or a service retries without idempotency keys. Participants should add, replace, or justify something meaningful. They need to see the design move under their hands.
This is especially relevant for AI-native development. Generated code can accelerate the first draft, but it can also obscure the boundaries between untrusted data, model output, business rules, and authority to act. A workshop should make those boundaries explicit in code and configuration. If no one can explain why an action was allowed, the system is not ready merely because it completed the task.
The structure that makes practice stick
The strongest workshop design alternates between short instruction, focused implementation, and inspection. Long lectures consume the time people came to use. Unstructured coding can leave participants blocked by environment issues or uncertain about the goal.
A practical sequence has four parts:
- Establish the system boundary, success criteria, and non-negotiable constraints.
- Build a small vertical slice that produces observable behavior.
- Introduce a realistic failure, attack, or scale constraint.
- Review the evidence and discuss the decision each team would carry into production.
For example, a session on private AI can compare hosted, local, on-device, and air-gapped deployment options. The goal should not be to crown one approach. Hosted models may offer speed and operational simplicity. Air-gapped environments can protect sensitive data but create real constraints around model updates, hardware, observability, and operational support. The workshop earns its value when participants can articulate those trade-offs for their own requirements.
Prepare for the work before the room opens
Good preparation protects the workshop from becoming a support queue. Participants should know the required language version, container runtime, account access, local resource needs, and whether an internet connection is assumed. They should be able to run a quick validation command before arriving.
Facilitators should test the material from a clean machine and provide a fallback environment for people whose corporate devices cannot install required tools. This is not glamorous work, but it determines whether the session starts with design decisions or dependency errors.
Teams should also decide what they want to bring back. A useful question before attending is: which decision are we currently postponing because we lack evidence? It may be whether to introduce an AI gateway, how to separate agent memory from application data, how to instrument a legacy service, or how to set human approval thresholds. Entering with a live question makes the exercises more valuable.
At Build Stuff 2026, workshops and masterclasses sit alongside sessions on AI safety, secure software engineering, distributed systems, data infrastructure, and developer craft. That mix matters because the hard problems cross disciplines. An agent architecture is also a security design. An observability decision affects recovery. A data center discussion has consequences for capacity, cost, and the feasibility of the systems teams are being asked to operate.
Choose facilitators who can explain the failed path
A facilitator does not need to present a perfect system. In fact, the most credible ones can show where an earlier approach broke down and why they changed it. Production postmortems, rejected designs, and inconvenient constraints make a workshop more useful than an idealized reference architecture.
That is why practitioners such as Jimmy Bogard, who works on adding OpenTelemetry to existing systems, or Mihaela Gheorghe-Roman, whose work addresses LLMs in air-gapped production environments, are valuable voices for this format. The relevant question is not whether a technique is fashionable. It is what it costs to operate, secure, test, and explain.
Participants should expect to ask precise questions: What happens under retry? Where is the audit log? How is a policy change deployed? Which test catches a regression in retrieval quality? What is the rollback plan when an automated action behaves correctly according to code but incorrectly according to intent?
Leave with a decision artifact
The output of a hands on technical workshop should be more than a folder on a laptop. It might be a threat model, a small reference implementation, an evaluation harness, an observability checklist, a set of architecture decisions, or a migration plan with known risks.
The artifact should be modest enough to use. A one-page decision record that names the context, options, trade-offs, and next experiment can be more valuable than pages of notes. It gives a team a starting point for discussion when they return to their own constraints.
There is also value in retaining the unresolved questions. If an exercise exposes that no one owns agent permissions, that is a result. If the group cannot define an acceptable failure mode for an automated workflow, that is a reason to slow down before increasing its authority. Human agency is not refusing automation. It is deciding where automation stops and making that decision visible.
Bring a problem worth testing, not just a tool you want to try. The most useful workshop result is a clearer boundary between what your software can do and what it should be allowed to do.
