Claude & AI for Engineering

A live opening session built to shift the room, not lecture it: real demos of what Claude can already do inside your workflows, run in front of the group. Participants leave with a working sense of where AI helps and where it doesn't, and enough curiosity to start using it that afternoon.

What tokens, context windows and hallucinations mean, explained without the math and without the hand-waving. Once a team understands why a model sometimes gets things wrong, it stops either trusting it blindly or dismissing it after one bad answer. Every other module in the program builds on this one.

Before the work starts, we walk the Claude screen together: a new conversation, uploading files, choosing a model, and where Projects, Artifacts and Skills live. Face to face it is a live demo; in the online course it is a recorded tour. Ten minutes that save weeks of fumbling.

Claude Skills turn a procedure your team already does well into something Claude can repeat on its own: the same checklist, the same tone, the same edge cases covered every time. You build it once with the person who actually knows the process, and from then on every teammate gets that expertise on demand. For teams where quality depends on one or two people, this is how that stops being a bottleneck.

Structure, context and role framing: the craft of asking in a way that gets a usable result on the first try instead of the fifth. Participants practice on real prompts from their own work, not toy examples, so what they take home already fits the job. Every other module assumes this fluency, which is why it comes early.

Claude Projects hold your documents and instructions in one persistent workspace, so every conversation starts already knowing your company, your terminology and your rules. Teams that set this up once save the ten minutes of re-explaining context at the start of every session, every day. For anyone running the same kind of task repeatedly, this alone changes the math.

Artifacts are documents, dashboards and small interactive tools Claude builds live inside the conversation, editable on the spot instead of copied out and reformatted. The session covers static outputs and interactive artifacts alike, with an eye on what a non-technical teammate can actually ship without engineering help. It's the module that convinces people Claude is a builder, not just a chatbot.

The shift from asking Claude a question to handing it a multi-step task it completes on its own, checking in only where it matters. Participants learn what actually counts as an agent, when handing over work beats doing it turn by turn, and how supervision needs to change once Claude is running unattended. Get this wrong and you either babysit an agent that didn't need it or trust one that did.

In the Claude chat you can hand over a whole job instead of asking a question. Claude plans the steps, searches the web, reads your files, runs code and hands back a finished document, spreadsheet or deck. On a big task it can split the work between several sub-agents running at once. Participants learn which work is worth handing over and how to brief it the way they'd brief a colleague, then practice staying in control while Claude works. They finish by turning a weekly chore into a scheduled task that runs on its own.

Tasks Claude runs on its own, on a schedule: a morning brief from your calendar and inbox, a weekly report, a competitor watch. Participants learn to tell a routine from its schedule, connect only the connectors it needs, and test every routine before it runs alone. They leave with one routine that works from the next morning.

Connecting Claude to the systems your team actually runs on: drives, CRMs, databases, through connectors and MCP, with the permission boundaries covered before the connection ever gets made. Participants leave knowing exactly what to expose and what to keep out of reach. This is the module that turns Claude from a smart typewriter into something acting on real, current data.

Real engineering workflows built agent-first: how a task moves from a prompt in the terminal to reviewed, shipped code. The module is built for developers, but the data-analysis half works just as well for a non-developer who lives in spreadsheets and needs that same rigor applied to a script. Teams leave with a working setup running in their own repo.

How to build agents without writing code: each one gets a job description, a badge that limits what it can touch, and a bottom line it hands back. Participants hire a small team, add an independent checker, and put the controls that matter in place: a request, a lock and a required step. They leave knowing the hard part is the charter, and that the charter is their own expertise, written down.

How context windows, memory and cost interact, and what to do about it before a long working session starts drifting or the bill surprises someone. Participants learn to spot when Claude is still hauling a task that should have been closed an hour ago, and how to reset without losing what mattered. A short module with an outsized effect on both output quality and the invoice.

Designing autonomous agent loops that intake a task, execute it, review their own work and recover from failure without a person watching every step. This is where the program moves from using Claude to building systems that use Claude. Teams walk out with a loop design they can actually run.

Orchestrating several agents at once: how to split work into specialist roles, run pieces in parallel, and integrate the results into one coherent output instead of five conflicting drafts. This module targets teams already comfortable with a single agent and ready to scale up. It closes the gap between a useful demo and a system a team can rely on.

Design, motion and video work built with Claude: brand systems, layout iterations and production-ready assets, covered end to end. It's aimed at teams that need a fast first pass to hand a designer for polish, or that want to close the loop entirely for lighter assets. The session works from participants' own brand materials, not a generic template.

The rules every employee needs before their first real session: what data is safe to share, what isn't, and what org-level guardrails should exist so individual judgment isn't the only safeguard. This module is usually the one legal and IT ask for by name. It replaces vague anxiety about compliance with a clear, specific policy people can actually follow.

Where people belong in an AI-assisted workflow: which steps need a review gate, which need an approval, and how to calibrate trust so oversight isn't either everywhere or nowhere. This pilot module gives teams a concrete framework instead of a gut feeling about what to check. Get the calibration right and quality goes up without slowing anything down.

Permissions, prompt injection and data boundaries: what makes an agent that can act also one that can go wrong, and how to run it anyway without carrying the risk. This pilot module is built for organizations moving agents past read-only demos into things that write, send and change data. It's the module security teams should sit in on.

Treating tokens as a real budget: measuring current spend, predicting where it grows, and cutting it without cutting the quality of what Claude produces. This pilot module is built for teams past the experimentation phase, where AI cost is now a line item someone has to defend. Finance and engineering leave with the same numbers, which usually hasn't happened before.

Splitting a job across specialized sub-agents: when spawning a new one is worth the overhead, what to hand it, and how its output comes back into the main thread cleanly. This pilot module is the natural next step after agent teams, aimed at engineering and product teams building more complex systems. Participants leave with a decision rule, not just examples.

Turning a repeatable request into a slash command everyone on the team runs the same way, instead of five slightly different versions of the same prompt. This pilot module covers writing, testing and rolling one out across a team. A small investment with an immediate payoff in consistency.

Extending Claude with plugins: how to evaluate one before installing it, what to trust, and when the right move is building the one your team is missing instead. This pilot module keeps the scope practical rather than a tour of everything that exists. Teams leave able to tell a useful plugin from a risky one.

A syllabus item still coming: systematic evaluation of agent output, including regression tests, so a team can tell whether an AI feature works and keeps working after the next change. Participants will build evals for their own agents, not a generic benchmark. Built for teams shipping agent-based features who currently have no way to catch a regression before a user does.

Coming soon: tracing and logging agent runs so a failure is something you can debug, not a mystery you re-run and hope goes better next time. Engineering teams will learn to build the observability layer before they need it, not after a production incident forces the question. It's the module that turns a strange agent glitch into an actual root cause.

Coming soon: running many agents against one codebase without them stepping on each other, covering worktrees, branch strategy and merge discipline built specifically for agent-scale parallelism. This is for engineering teams already running more than one agent and starting to feel the coordination cost. The syllabus targets the failure modes teams hit first: stale branches, silent overwrites, conflicting assumptions.

Coming soon: building a knowledge graph of a codebase or domain so an agent stops re-exploring the same territory every time it's asked something new. Participants will map one of their own systems into a graph an agent can actually query. Aimed at teams whose agents spend more time searching than working.

Coming soon: building the harness around the model itself, tools, permissions, hooks, and the scaffolding that turns a capable model into a dependable agent. This syllabus item goes deeper than any other module into the infrastructure layer, for teams building agents as a product rather than using one off the shelf. Expect to leave with a harness design, not a checklist of terms.

Coming soon: the foundations under the products everyone's using, training, fine-tuning and embeddings, taught for the decisions a non-researcher actually has to make. This is not a path to becoming a data scientist. It's enough grounding to evaluate a vendor's claims or a build-versus-buy question without taking their word for it.

Coming soon: preparing and governing the data an AI system actually works from, structure, access and quality, before automation gets layered on top of it. This syllabus item is for teams that already tried an AI project and hit a data problem they weren't expecting. Skipping this step is the single most common reason automation projects stall.

Coming soon: writing the AI policy an organization actually needs, usage rules, risk tiers and rollout governance, instead of a generic template nobody follows. This syllabus item is for leadership and compliance stakeholders shaping how AI gets adopted company-wide. Built to produce a document teams can point to, not a discussion that goes nowhere.

Coming soon: writing with Claude without losing the voice that makes a brand recognizable, tone, house language, and the specific discipline of native-quality Hebrew rather than a translated one. This syllabus item covers spotting AI tells in a draft as much as producing one. For any team whose writing represents the company in public.

Coming soon: retrieval-augmented generation done properly, chunking strategy, embeddings, and answers traceable back to a specific source rather than a plausible-sounding guess. This syllabus item is for engineering and product teams building a knowledge feature on top of Claude, not just using it in a chat window. Participants leave with a working RAG setup on their own documents.

Coming soon: building on the Claude API and Agent SDK, first integration, tool use, streaming, and the cost controls that matter before something ships to production. This syllabus item is for engineers moving from using Claude manually to embedding it inside a product. Expect a working integration by the end, run against real endpoints.

Coming soon: AI-assisted code review that catches real bugs instead of style nitpicks, with review agents built into the pull request flow while a human keeps final judgment. This syllabus item covers where an agent reviewer earns its place and where it shouldn't be trusted alone. For engineering teams whose bottleneck is the review queue, not the coding itself.