Workshops

Description

Hands-on and tool-agnostic. Bring the AI coding assistant you already use - Copilot, Cursor, Claude Code, or a command-line agent - and work in any language. Day one is the blueprint: turning a plain-language idea into a spec that holds up under a real build. Day two is the inspection line: the guardrails and gates you build yourself so you can trust what the agent ships.

You leave with a working app built from your own spec, and a portable set of enforced checks you can drop into any repository. This workshop is also available as a one-day version.

Day 1: From Vibes to a Spec That Holds

• Building a working app from a plain-language description, using the AI tool you already use
• Spotting code that works but solves the wrong problem
• Turning vague prompts into a lightweight spec - clear intent, explicit constraints, checkable "done when" criteria
• Driving the same build from your spec, and comparing the results
• Reading the difference between a spec that holds and one that drifts

Focus: Stop guessing what the AI will produce. Say what you mean precisely enough that it builds the right thing with any tool.

Day 2: Guardrails You Build Yourself

• Mapping the "certainty ladder": an instruction the agent might follow, versus a check that runs every time whatever wrote the code
• Choosing what earns your trust in a commit, then turning each one into an enforced check
• Building your own preflight check by working with your AI tool - the lasting skill is making guardrails, not being handed them
• Enforcing checks across the whole codebase, and holding the agent to your standard - no self-granted exceptions, no "good enough"
• Using an AI agent to review for design issues like duplicated logic and weak structure
• Optional advanced step: pointing an adversarial agent at your own app, as one more check you can build

Focus: The guardrails are what let you ship code you didn't read line by line - and you leave with a portable setup you can drop into any repository.

Description

Building secure applications requires more than just adding encryption. Key management, metadata protection, and traffic analysis defences are just some of the challenges you'll need to tackle. This workshop takes you from basic encryption to advanced protection mechanisms. You'll learn how to secure data both at rest and in transit, implement perfect forward secrecy, and handle secure device migration.

Through practical implementations and architectural deep-dives, you'll learn the patterns and practices that make applications truly secure. We'll focus on real-world security engineering, emphasising approaches that work at scale.

You'll learn:

• Basic end-to-end encryption setup
• Group encryption fundamentals
• Metadata protection techniques for data at rest
• Traffic analysis protection and metadata in transit
• Perfect forward secrecy and key rotation
• Secure device migration approaches
• Key management best practices

Through a combination of hands-on implementation and architectural theory, you'll end the workshop having built a working encrypted application and gained the knowledge to make informed security decisions in your own projects.

Prerequisites

Familiarity with JavaScript and basic API consumption. Experience building web applications is helpful but not required.

Description

218 commits in 6 days. 334 test files. Zero reverts. A human wrote the specs in 9 hours, an AI agent built the software in 10, and a 9-hour review later the project was done. The tools that made this possible will be different six months from now. The methodology will not.

This workshop teaches spec-driven autonomous development: you write feature specifications, an AI agent breaks them into small, independent tasks, and a build loop implements, tests, and commits each one inside an isolated environment. You write the what. The machine handles the how. Every commit passes your full validation gate before it lands. The approach works regardless of which AI coding tool you use - the constraints and structure are what make it reliable, not the specific agent.

This is for developers who've used AI coding tools and hit their limits - long sessions that drift, agents that break what they just fixed, tests that don't get written. You'll learn why those failures happen and how the loop pattern solves them.

The workshop is hands-on. You'll write specs for a shared project, configure a build loop, verify your first autonomous iteration before lunch, then let it run while you eat. The afternoon is spent reviewing what the AI built, comparing how different spec styles led to different outcomes, and learning from the failures. You'll leave with a working setup, a spec-writing methodology, and the confidence to hand your next project's implementation to an autonomous loop.

Prerequisites

Docker Desktop, an AI coding agent (e.g. Claude Code, Codex, or equivalent), Git, a code editor. Comfort with a terminal and at least one programming language.