AI-Native Engineering in Practice

A day for people who already use a coding agent and get inconsistent results. You will learn how to prepare a repository’s context, write specs an agent can execute, build the checks around it (the harness), and coordinate multiple agents on the same project.

• Developers who use agents every day and get a different result every session
• Tech leads and architects who need to bring this way of working to a whole team
• People who have already tried writing rules and specs for an agent — and abandoned them because the agent ignored them
• This is not a programming course. You need to be able to read and write code in at least one language.

Module 1 — From vibe coding to AI-Native Engineering. What changes in your role when an agent writes the code, and why intent, constraints, and verification become the centre of the work.

Module 2 — Context engineering. The context window is a budget, not a warehouse. What fills it (system instructions, repository rules, skills, tools, memory), how the agent explores the code on its own, and how to optimise context across sessions.

Module 3 — Spec-driven development. Why a written spec changes the outcome, the specify–plan–execute–verify loop, and the minimum set of documents that support it. We also look at frameworks that automate this — and when it is better to use none of them.

Module 4 — Verification and quality gates. The layers of control around an agent-generated change. Tests, linters, and type checkers as a deterministic net; review by another model; gradual release; and the point where a person really has to decide.

Module 5 — Harness engineering. An agent is a model plus the environment you build around it. Here you work on the part that stays yours: rules files, architecture docs, reusable skills, CLI scripts, and MCP servers. This is the investment that survives a tool change.

Module 6 — Orchestration patterns. Scratchpads and compaction for long jobs, the generator–critic loop, loops that run until a goal is met, subagents, and multiple agents in parallel on the same repository. For each pattern: when it helps, and when it hurts.

The six modules have similar weight — about one hour each.

• Prepare a repository’s context so an agent can work there without you repeating the same instructions every session
• Write a spec and a plan an agent can execute — and recognise when writing them is a waste of time
• Build a rules file and at least one reusable skill for your project
• Set up automatic checks that block a bad change before merge
• Pick the orchestration pattern that fits the job instead of always opening a single session
• Decide which changes can pass on their own and which need your review

• Be able to read and write code in at least one language. The exercises are language-independent
• Have used a coding agent at least a few times. Advanced experience is not required, and you do not need to know how an LLM works — Module 1 covers the basics
• A laptop with Git and a working agent already installed
• A repository, even a small one, to practise on. If you do not have one, we provide a sample in class

• Examples stay independent of any single tool: what you build in class still applies if you switch agent
• Content follows the book AI-Native Software Engineering: Building with AI Agents and Spec-Driven Development (O’Reilly)
• Sample files and artefacts from the exercises stay with participants