AI workshops / programme 03
A programme for software and product teams. We work in your repository: context and effort control, verification loops, AI-supported design of complex systems, deployment and infrastructure — and the question of how review and ownership work when much of the code is generated.
AI-assisted development is already daily practice in most teams — just at very different levels. The typical patterns: prompts written for older models that today cause over-verification and bloated diffs. Sessions where the context is so full that quality tips over. Generated code that looks plausible, misses edge cases and eats the time at review that was saved up front. And costs nobody knows per task. The differences between a team that works well this way and one that struggles are learnable and surprisingly concrete: context discipline, the right effort level, and a check the model can run itself.
Model and effort choice per task type, context management across long sessions, prompt patterns that still work today — and the ones you should delete from your project files. Plus cost transparency: what a task consumes and which levers cut that by a multiple.
The biggest quality lever: giving the model a check it can run itself — test suite, build exit code, linter, comparison script. We build those loops in your repository and define what human review concentrates on afterwards.
From requirement to a robust design: specifications a model can actually implement, a planning step before implementation, weighing variants against each other, breaking migrations and refactors into verifiable steps — instead of hoping for one large diff.
Infrastructure as code, CI/CD pipelines, logs and monitoring with AI support: generating and checking configuration, triaging incidents, preparing postmortems. Including the guardrails that are non-negotiable — secrets, permissions, environments and what an agent must never do without confirmation.
Capturing recurring work as automation: skills, hooks, subagents and MCP connections to your systems — plus the security questions that come with it: prompt injection from third-party content, handling secrets and customer data, dependencies and licences in generated code.
We look at stack, tests, CI and the existing project and prompt files, and collect the friction points from the team.
A day on real tickets from your backlog: context setup, effort choice, planning step, implementation and verification in rotation.
Project rules, verification scripts, automations and security guardrails land in the repository — not in a document.
We look at real diffs, review time and cost per task, and adjust the setup where daily use has shown the gaps.
One shared setup in the repository instead of seven personal ways of working.
Verification loops that catch errors before a human starts the review.
Traceable cost per task — and a deliberate choice of model and effort.
Smaller, verifiable diffs instead of large changes with no clear scope.
Clear rules for secrets, customer data and what an agent never does alone.
For software, platform and product teams — from engineers to tech leads, DevOps and data engineering. We work in your language and your stack. A group of four to ten people works best; larger teams get split so everyone can work on their own machine.
Whatever you use or are evaluating — typically Claude Code, GitHub Copilot, Cursor or Codex, plus your IDE, CI and cloud environment. The principles are largely tool-independent: context, verification, scope control and cost. We also point out where the tools genuinely differ and where it's just marketing.
Yes, that's part of the programme. We work to your rules — enterprise access without training on your code, handling of secrets and customer data, excluding sensitive repositories, approval requirements for agents with write or deploy rights. On request we also walk through the prompt-injection risks that arise when an agent reads third-party content.
Not automatically, and the evidence is mixed — in a widely cited study on large open-source repositories, experienced developers were in fact slower with AI assistance even though they felt faster. That's exactly why this programme is built around measurement: we look at review time, error rate and cost per task instead of gut feel, and work out the task types where the gain is real in your context.
Deep enough for experienced developers. We work on real tickets from your backlog, cover architecture, migrations and infrastructure, and discuss edge cases rather than hello-world examples. For mixed experience levels there are tiered exercises so nobody is left waiting.