Most AI training ends right where the real work begins. People learn to write a decent prompt, watch a few impressive demos, and go back to a workflow that looks exactly like it did before.
AI for Leaders was built to close that gap. As the AI expert consultant for its 1:1 sessions, I've worked with more than 14 people, from complete beginners to confident intermediate users. This post covers how the programme works, how we approach those sessions, and what that work says about the knowledge we have in-house.
How the programme works
AI for Leaders runs in two parts. The group sessions lay the foundation: what current models can and cannot do, how to give one instructions it will actually follow, and what good AI use looks like. The 1:1 sessions are where that foundation gets applied to one person's daily work.
Where the 1:1 sessions come in
In the 1:1 sessions, my role is AI expert consultant. This is where we go past the basics into the parts of the ecosystem that make AI genuinely useful at work: connectors, skills, MCP, plugins, agentic tools and the workflows that tie them together.
Alongside the planned topics, I support participants in whatever technical work comes up. That might mean setting up a project, working out why an integration isn't behaving, or brainstorming which part of their job is worth automating first.
So far I've worked with more than 14 people in these sessions. Some were opening an AI tool for the first time. Others already used one daily and wanted to build something more ambitious.
How we approach every session
Across very different people and roles, the same five principles shape every 1:1 session.
Start from the process, not the tool
Before anyone touches a prompt, we map how the work actually happens today: who sends what to whom, in which format, and where the time disappears. Once the process is on paper, the right AI setup is usually much easier to see.
Be honest about what AI won't fix
Every workflow has bottlenecks, and not all of them are AI-shaped. If the slowest step is waiting for colleagues to reply, a better prompt won't change that. Saying so early builds trust and keeps expectations realistic.
Keep the person in the decision seat
We design setups where AI does the locating, sorting and first-pass consolidation, while the participant verifies and decides. Clear rules matter here, such as telling the model to flag disagreements instead of settling them on its own.
Build for repeatability
A good prompt used once is a nice moment. The same instructions saved in a project, packaged as a skill, or connected to the tools someone already uses become a system they can rely on every week.
Test on real material, then measure
We test on the participant's own documents, not toy examples, and the best test sets include drafts and intermediate versions, not just finished ones. Then we compare three numbers: how long the AI takes, how long checking its work takes, and how long the task took before.
What this looks like in practice
One session shows the approach well. With identifying details removed, the participant was a business development manager responsible for getting vendor contracts reviewed by several internal departments.
The existing process was slow and manual. A contract arrives in the vendor's own template and language, goes out to five or six departments, and each one comments in its own format: tracked changes, free text or email. The manager then consolidates everything by hand, translates it into the vendor's language, and repeats the cycle, sometimes for months.
We split the work into two moments. The first is distribution: the assistant reads a new contract and maps every clause to the department responsible for it, using a fixed list of departments and clause types. Clauses that fit several departments go to all of them, and anything that fits none lands in an "unassigned" section instead of being guessed.
The second is consolidation. When comments come back, points where departments agree go straight into a clean version, labelled with their source. Disagreements are collected in a separate list for the manager and never resolved by the AI, departments that haven't responded are listed on their own, and every item points back to its exact clause.
We were upfront that the biggest delay, waiting for departments to reply, isn't something this setup removes. What it does cut is the hours spent locating, sorting and stitching comments together. The manager still reviews everything and makes the final call before anything goes back to the vendor.
The next step is the one we push in every session: run it on two or three real past contracts, compare AI processing time with review time, and measure both against the old baseline.
Going deeper: the toolkit behind the 1:1 sessions
A 1:1 session can touch anything that turns a chat assistant into a working part of someone's job. We build it up in layers, so each step solves a real problem before the next one adds complexity.
Projects and custom instructions. This is the foundation. A dedicated workspace with its own instructions, reference documents and terminology means the assistant knows the role, the vocabulary and the expected output before the first message.
Connectors. This is where most participants see the biggest jump. Connecting the assistant to document storage, email, calendars, team chat, ticketing or CRM lets it work with live data instead of copy-pasted fragments. We help people pick the connectors that matter for their role, set them up properly, and understand exactly what data the assistant can see.
MCP. The Model Context Protocol is the open standard underneath many of those connections. With technical participants we go further: how MCP servers work, how to evaluate one before trusting it, and when it's worth building a custom server for an internal system.
Skills. These are packaged instructions, templates and best practices that the assistant loads when a task calls for them. A team's report format, review checklist or house style gets written once and applied every time.
Plugins. Plugins bundle skills, connectors and commands into one package a team installs together. They turn one person's well-built workflow into something a whole department can reuse.
Agentic tools. Assistants can now work across files, apps and the browser, carrying out multi-step tasks with little supervision. We cover which tasks are worth handing off, how to scope them, and how to review what comes back. For developers, that includes AI coding agents in the terminal and the IDE.
AI-powered mini tools. Sometimes a participant doesn't need a workflow, they need a tool. We help build small interactive dashboards, calculators and internal helpers that a team can open and use without writing code.
Reliability and evaluation. Underneath every layer sits the same discipline. We work on instructions the model follows consistently, test them on real cases, and learn to spot outputs that look right but aren't.
Not everyone needs every layer. A beginner might spend a whole session getting one project and one connector right, while an intermediate user might leave with a custom skill and a plan for a plugin their team will share.
From first prompt to custom skills
Working with more than 14 people at different levels made one thing clear: the session has to start where the person is, not where the curriculum is.
For complete beginners, the first win is usually small and concrete, like a project with clear instructions that handles one recurring task well. Confidence comes from seeing their own work done faster, not from a feature tour.
Intermediate users arrive with different questions. They want to know why an output is inconsistent, how to connect their tools, or how to share what they've built with colleagues. Those sessions are more technical and more collaborative, closer to building something together than to being taught.
A few lessons hold across both groups:
- The best use cases come from the participant, not from us. Our job is to help shape them.
- Clear rules beat clever prompts. Telling the model what not to do is often as important as telling it what to do.
- Real documents surface real problems. Messy formats and mixed languages show up immediately, and those are exactly what the setup needs to handle.
The knowledge behind the programme
AI for Leaders works because the people running it use these tools every day, on real work. What participants get in a 1:1 session comes from a team that builds and tests this technology internally first.
Internal workshops
We run regular internal workshops where team members demo what they've built, from a new skill to a connector that saved someone an afternoon. Just as importantly, we share what didn't work: the prompt that broke on real data, or the integration that wasn't worth the setup.
AI in our own daily work
We don't keep AI in a lab. People across different roles in our team work side by side with these tools in day-to-day delivery. That means our advice is shaped by what holds up under real deadlines, not just in demos.
Tested on us before it reaches you
The tooling changes almost monthly. New connectors, agent capabilities and model releases get tried on our own workflows first. By the time something comes up in a session, we already know where it shines and where it falls short.
Business and technical, in the same room
The 1:1 format only works if the consultant can follow a participant's business process and also fix the technical setup behind it. That range, from mapping a contract workflow to configuring an MCP server, is what we bring to every session.
Where to start
If your team is past the "AI is interesting" stage and ready to make it part of how work gets done, AI for Leaders offers two ways in:
- AI for Leaders for your team. Group and 1:1 sessions built around your people's real roles, not generic examples.
- Deep-dive 1:1 support. Turning individual use cases into working setups with projects, connectors, skills and plugins.
The best starting point is usually one process that eats more time than it should. Bring it to us, and we'll show you what it could look like.
