AI Engineer Melbourne 2026 — Software Engineering (Day 2 Midday)

AI demos are easy. Production systems are not.

In this session, we move beyond hype and explore what it actually takes to deliver AI systems that work in the real world. Not experiments. Not playgrounds. Proper, spec-driven, commercially accountable systems.

You will see how clear specifications, structured prompts, testing frameworks and disciplined engineering turn AI from a novelty into a reliable asset. We will cover what goes wrong when you skip the spec, how to avoid costly rework, and how to design AI systems that survive compliance, security reviews and real users.

If you are building AI for clients, boards or production environments, this session will challenge your assumptions and give you a practical blueprint.

In the time it takes to train a frontier model, the open source libraries we rely on can undergo significant changes. This creates an ongoing delta between what an LLM coding agent suggests and what the best practices are, or what even works. For the team at Google DeepMind, this is an ongoing challenge as we publish both models and open-source SDKs.

This talk will share some of the challenges that we, as SDK maintainers face, and we'll share some results from our experiments. We'll focus primarily on the "training cutoff knowledge gap", and how it is applicable for users and owners of open source projects, but we will also discuss some of the other challenges maintainers face in a world where producing code is trivial.

AGENTS.md started as a simple way to guide coding agents, but many teams are discovering that a default or poorly written one can actually make agents worse. Obvious facts, vague rules, outdated guidance, and generic instructions often confuse models more than they help.

But manually crafting it won’t cut it once teams and organizations enter the picture. Because a single static file stops being enough. Agents need a harness that guides how they interpret context, what knowledge applies where, and which decisions carry authority. In this talk we’ll explore why effective agent systems require structured context, hierarchy, and memory — and how building that harness is the real challenge of making AI agents work reliably inside engineering organizations.

In 2024 my team built 2 web-based Interactives for our Science Curriculum. In 2025 we built 50, in 2026 we expect to build over 100. In 2024 Engineers collaborated with Writers to build Interactives. In 2025 Writers built the Interactives and Engineers reviewed and deployed them. In 2026 we're getting Engineering out of the loop.

With AI we're writing more code than ever, and more and more non-Engineers are involved in building with code. It is not sustainable for a human to read and review every line of code. Even if we do human review, the volume is so large and the context is totally gone - we can't expect them to do a good job. So how can we feel safe? What techniques do we need to apply? What technologies do we build? How do we Engineer in a world where we no longer read code?

In this talk I'll go through our journey of building small low-risk software without human review. I'll talk about my experiments in building software without review, and the systems I'm building. I'll also talk about the systems we're using in production to drive high quality code and anti-fragility through AI review. Then how I'm thinking about the future of work in Software Engineering, and whether human review will be a part of that.

For decades, documentation has been the "sacred bridge" between human intent and machine execution. Historically, this was born of necessity: when computer time was scarce, we had to document our plans perfectly before touching a terminal. But in the modern era, documentation has morphed into a static snapshot—often serving more as marketing material than technical truth.

Now, as we enter the age of AI-assisted development, the consumer of our code is changing. LLMs can read source code—the ultimate source of truth—with the same fluency as natural language. This talk draws on real-world experience building against rapidly evolving open-source systems to show why the future isn't about writing better manuals, but about embracing just-in-time understanding generated directly from the code.

For a long time, the world has run on systems built on logic. You put something in, follow a set of rules, and you get an output. Now we have systems that can run on inference: systems that can update belief, decide, and act. That changes how we should think about building systems. We don't need to keep forcing everything into rigid workflows. We can start designing systems that are built around inference from the onset. This talk is a thought process on designing these systems, drawing from principles in human-computer interaction, mathematics, and software design.