H2MHuczyńskiSystems you own
Contact

Service 03 / 04 · AI training for teams · all services

Your team automating its own work in a day, safely

Workshops for business teams built from 75-minute modules, up to four a day, on site or remote. Bring any device with a browser: the sandbox, the tools and the API tokens come from me.

  • Entry module: no setup
  • AI agents in daily work
  • Git for everyone
  • Office documents from prompts
  • Your own MCP servers
  • Browser automation
  • Evals and guardrails
2–12
people per group
75 min
one module
≤ 4
modules a day

Every engagement ends with a system your team can operate without me, so teaching is part of the job. The workshop is built the same way: no slides for the sake of slides, the material is the repository the team fills during the modules. The entry module needs nothing installed: each participant opens a browser, lands on their own sandbox desktop over RDP, and ships something in the first 75 minutes.

Easy to enter, built from modules

Business teams: operations, sales, marketing, finance, support, and the developers who serve them. Mixed groups work best. Nothing to install: the entry module runs in a browser.

  1. Entry

    Module 00 · 75 min

    Everyone opens a browser and lands on their own sandbox desktop. opencode with my tokens, the team repo, one real task each. By the end every participant has an agent that did something for them, committed.

  2. A day

    up to 4 modules

    Modules follow the tree: a day is a path, not a list. On site in one room or remote, 9:00 to 15:00 with breaks. Most teams do one or two days to start.

  3. Continuation

    1–2 modules a week, remote

    The deeper branches run on the team's real work: they bring what they built and where it broke, we harden and extend. The sandbox stays up for 30 days after the last module.

The module tree

Eight modules of 75 minutes. Each one ends with something the participant built and committed. Arrows show what a module needs before it; a day is a path through the tree, up to four modules long.

Entry

00

Entry: your first agent

75 min

Browser, sandbox, opencode. What an agent is and is not, writing a task it can finish, where it must stop and ask.

You build One recurring task of yours done end to end by an agent, committed to the team repo.

Nothing to install, nothing before it

Foundations

01

AI agents in daily work

75 min

Agents with tools: reading files, running commands, browsing. Checklists of what they may not do. Working with Claude and opencode side by side.

You build An agent with a written scope and a checklist, running on a task from your week.

Needs 00

02

Git for everyone

75 min

A repository as the team's shared memory. Commit, branch, pull request, review, revert, in plain words and in practice.

You build A pull request from every participant, reviewed by a peer, merged.

Needs 00

Branches

03

Office documents from prompts

75 min

Word, Excel and PowerPoint from data and templates: reports, offers, monthly decks. The document is built from the source, not typed into a chat.

You build A generator that reads a spreadsheet or a CRM export and writes the file your team sends by hand today.

Needs 01

04

Browser automation

75 min

Automating what only has a web interface: portals, back-offices, suppliers' sites. Playwright driven by the agent, screenshots as proof, a stop when the page changes.

You build One automation of a portal your team logs into every week, with proof of each run.

Needs 01

05

Your own MCP servers

75 min

Model Context Protocol: your systems as tools. A minimal server, a read tool, a write tool behind a confirmation, an audit log, connected for the whole team.

You build An MCP server over one company system the team can use from Claude or opencode the next day.

Needs 01 02

Depth

06

Evals and guardrails

75 min

How to know it still works: small eval sets, a rule for when the agent must ask, secrets and data handling, cost per run.

You build An eval for one of the team's agents, running in the repo.

Needs 05

07

Roadmap and handoff

75 min

What to automate next and what not to. The playbook, the owners, the sandbox-to-laptop move for those who want it.

You build A one-page automation roadmap for the quarter and the playbook the team keeps in the repo.

Needs 03 04

Three paths teams take

Up to four modules a day, 9:00 to 15:00 with breaks. Any path through the tree works; these are the usual ones.

1 day · 4 modules

Taster

  1. 00Entry: your first agent
  2. 01AI agents in daily work
  3. 02Git for everyone
  4. 03Office documents from prompts

Entry, agents, git, and the first document generator. The team leaves with a repo and four working things.

2 days · 8 modules

Core

  1. 00Entry: your first agent
  2. 01AI agents in daily work
  3. 02Git for everyone
  4. 03Office documents from prompts
  5. 04Browser automation
  6. 05Your own MCP servers
  7. 06Evals and guardrails
  8. 07Roadmap and handoff

The whole tree. Day two can be on site or split into remote modules over two weeks.

1 day · 4 modules

Developers

  1. 00Entry: your first agent
  2. 02Git for everyone
  3. 05Your own MCP servers
  4. 06Evals and guardrails

Entry, git, MCP servers, evals. For the people who will own the tools the rest of the team uses.

Requirements

Bring any device with a browser

The sandbox, the tools and the API tokens come from me. Nothing is installed on company laptops unless the team wants to keep going afterwards.

You bring
Any device with a modern browser and internet: laptop, Chromebook, even a tablet with a keyboard. No admin rights, no installs.
I bring
A sandbox desktop per participant, reachable in the browser over RDP, with opencode, git, Node, Python, VS Code, Playwright and the team repo. API tokens for the workshop. Everything is cleaned or handed over 30 days after.
Accounts
A GitHub account per participant and an organisation for the team repo. I can create the organisation and hand it over; it is yours.
Network
Wi-Fi that reaches the sandbox host and github.com. Corporate proxies usually pass RDP-in-browser; I test it with your IT a week before.
Room, on site
One room for the whole group, a screen or projector, power at every seat. Remote: a video call and the same sandboxes.
Data
One real dataset or export per module a participant will take (spreadsheet, CRM export, a portal login on a test account). Nothing production-critical on day one.

This is the right call when

  1. 01

    Your team pays for AI subscriptions and uses them like a search box.

  2. 02

    Two people in the company can automate things; the other twenty send them tickets.

  3. 03

    You want the team to build its own small tools and agents, safely, and keep them in git.

What you get

What lands on your account

  • A shared repository with everything the team built, in git, with history
  • Each participant's sandbox for 30 days after, and an install script if they want it locally
  • A team playbook: prompts, guardrails, what to automate next
  • Continuation modules remote, one or two a week, on the team's real work

Case studies

The systems behind this service, with the numbers their owners cleared for publication.

  1. awesome-ai-system-prompts

    The public reference collection of production system prompts, used as teaching material for prompt and agent design.

    Open source, maintained on GitHub.

    6,208
    GitHub stars

    See the build

  2. h2mai.com

    This site: a research build of a five-layer silver UI, WebGL cloth, shader type and a six-step intake, used as teaching material for the workshop.

    The material for the modules on agents, git and browser automation was built on this repository.

    5
    documented layers
    0
    build step

Runs on

  • Claude
  • Anthropic
  • MCP
  • Git
  • Github
  • Node.js
  • Python
  • Typescript

Questions I get about this

Tap a question. The answer comes back like a text.

Scoping calls · most weeks

Any device with a browser and internet. Each participant gets a sandbox over RDP with everything installed, plus opencode with API tokens I provide for the workshop. Nothing is installed on company laptops unless the team wants to keep going afterwards.

A Linux desktop per participant reachable from the browser: opencode with tokens, git, Node, Python, VS Code, Playwright with a browser, and the team repo cloned. It lives for the workshop plus 30 days; the repo is yours forever.

No. The tree shows what each module needs before it. Most teams start with the entry module and one day, then pick the branches that match their work. The order inside a day is fixed by the tree, the set is yours.

Two to twelve people. Two is a pair that wants to move fast; above twelve the hands-on part stops working and I split it into two groups.

Either. A day is up to four 75-minute modules with breaks. The first day works best in one room; the continuation modules run remote, one or two per week, on the team's real work.

No. The entry module needs a browser and nothing else. Mixed groups work best: non-developers ship documents, browser automations and small tools; developers take the MCP and evals branch of the tree.

Per module per group, not per seat. A day is up to four modules. Sandbox, tokens and the team repo are included; you get a quote after a short call about who is in the room and which branch of the tree they need.

Yes, before you send the brief if you need it. Send yours or use mine.

Something else? Ask it on the call

A 30-minute call, free

Thirty minutes, then a written plan

Leave an email. I reply within one working day with three questions and a proposed plan, not a deck.