AI Doesn’t Make You Safe: Realistic Security in the Era of Autonomous Threats

While AI-powered defense tools have improved detection and response, attackers have become faster too—automating reconnaissance, mimicry, phishing, credential harvesting, and social engineering with alarming precision. This talk breaks down the new generation of AI-driven threats and the gaps they exploit: trust systems built for humans, predictable workflows, cognitive shortcuts, and legacy assumptions about identity and verification. Then we shift to what actually works: human-centered security patterns, resilience-based design, layered verification, behavioral engineering, and practical safeguards that don’t rely on “magic model thinking.” Attendees leave with a realistic, implementable strategy for securing systems against AI-enhanced adversaries.

Anticipatory Design for Developers: How to Build Software That Prevents Its Own Mistakes

After years of building products — from aviation systems to Evernote to fast-moving startups — I learned something uncomfortable: most user errors aren’t user errors. They’re design failures we coded into the system without realising it.

In this talk, we’ll look at anticipatory design as a practical engineering skill, not a design buzzword. I’ll walk through real examples of how small interface choices lead to big support costs, security mistakes, and “why did they click that?” moments. We’ll talk about why users behave unpredictably (even when you think the flow is obvious), and how developers can build guardrails that guide behaviour instead of reacting to it later.

You’ll learn how to spot friction before users do, how to design for “mistake paths,” and how to create safer defaults that reduce both cognitive load and technical risk. We’ll also explore how anticipatory design reduces accidental data loss, misconfigurations, and security vulnerabilities — and why it’s one of the most underrated tools in a developer’s career.

This is a practical, experience-driven session with concrete examples you can apply to any codebase. If you want to write software that feels intuitive, breaks less, and takes care of your users before they get confused, this talk is for you.

Architecting for Uncertainty: Building Resilient Systems (with Humans in the Loop)

This hands-on workshop teaches developers and architects how to design systems that hold up in the real world—where constraints shift, people make mistakes, and context is never complete. We’ll explore practical resilience patterns across architecture, process, and team structure. Through guided exercises, participants will map decision flows, identify fragility points, design guardrails, and model resilience patterns such as circuit breakers, bulkheads, adaptive throttling, clarity loops, and “decision debt” reduction. Attendees leave with templates, frameworks, and practical tools they can immediately apply to their own systems and teams.

Anticipatory Design for Developers: How to Build Software Users Don’t Have to Think About

I’ve spent my career watching users click all the wrong buttons — sometimes even the ones we hid. Over time, I realized the problem wasn’t that users were “bad at tech.” It was that the software wasn’t designed to anticipate them.

In this talk, I’ll show how developers can use anticipatory design to build PHP applications that guide people instead of confusing them. No hand-wavy design theory — just concrete examples from my time at Evernote, travel tech, and dozens of startups where we had to simplify fast or lose customers.

We’ll look at how tiny UX decisions reduce support costs, prevent security risks, and make your product feel smarter. You’ll learn how to spot friction before users do, how to design for “mistake paths,” and how to use PHP and modern frameworks to make interfaces adapt in real time.

If you’ve ever wondered why your beautifully engineered feature gets ignored — or misused — this session will show you how to fix that.

Architecture by Conversation: How to Make Better Technical Decisions Without Endless Meetings

I’ve spent years sitting in architecture meetings that could have been two sentences and a whiteboard. I’ve also seen teams build entire systems with no discussion at all — and then wonder why everything falls apart.

This talk is about how to strike the balance. I’ll walk through the communication patterns I use with engineering teams to make faster, clearer technical decisions without drowning in meetings. We’ll talk about how to get the right people in the room, how to ask questions that uncover hidden landmines, and how to avoid the “HIPPO problem” where the Highest-Paid Person makes all the choices.

You’ll learn how to evaluate options without analysis paralysis, when to document decisions, and how to keep moving even when you don’t have perfect information. I’ll also show you how to use PHP-specific examples — migrations, API changes, infrastructure choices — to illustrate these patterns in your own team.

Better decisions aren’t about being smarter. They’re about communicating better.

Build Your First Agent Workflow

Most AI talks tell you what agents can do. This workshop gets you to actually running one.

You don't need to know how to code an agent from scratch. You just need a laptop and the willingness to play with something new. By the end of this session, you'll have a working autonomous agent configured and running: not a demo, not a slide, something you built.

Here's what we'll do: start with nothing (seriously, no setup required. We'll use existing platforms), configure your first agent with specific goals and boundaries, connect it to tools (email, calendar, tasks, whatever you need), set up verification so the agent proves its work, add memory so it remembers across sessions, and define failure handling so you know when things go wrong.

You'll leave with a working agent that does something useful for you: Not a toy, something you can actually use. I'll share the same setup patterns I use running my own agents, including what breaks, what I wish I'd known first, and how to scale from one agent to many.

Prerequisites: basic terminal comfort, a laptop, a Github account, Claude/ChatGPT/LLM sub of your choice, and an IDE account on whatever platform you use. No coding required. If you've ever configured a Slack bot or a Zap, you can do this.

Building Products That Don’t Break People: Sustainable Engineering in High-Demand Environments

Fast-moving teams often ship great products—until the people building them burn out, communication breaks down, or friction slows delivery to a crawl. In this talk, we explore the human layer of software engineering: the invisible work that keeps teams aligned, the communication gaps that sabotage progress, and the cultural patterns that determine whether developers thrive or quit. You’ll learn how to design “sustainable velocity” into teams using alignment rituals, expectation transparency, decision frameworks, and adaptive planning that protects both people and product quality. A practical, research-backed look at the habits of resilient engineering organizations.

Cognitive Bugs: When Your Brain Outranks Your Code

Every developer has spent hours debugging a problem only to discover the issue was obvious in hindsight. The root cause often isn’t technical—it’s cognitive. This talk explores the mental shortcuts and perception gaps that silently shape how we write and interpret code: pattern-matching errors, false certainty, invisible assumptions, and the “I swear I read that line” illusion. We’ll map these human bugs to the production defects they create—misread logs, bad merges, faulty architecture decisions, and subtle regressions. Then we’ll explore ways to compensate using engineering habits: structured review patterns, slow-thinking triggers, sanity-check prompts, and workflow design that protects you from your own mind. A mix of psychology, debugging, and uncomfortable relatability.

Communication Debt: The Invisible Problem Behind Most Outages

The biggest failures I’ve seen in engineering teams didn’t start with code. They started with someone making a small assumption, skipping a conversation, or filling in a gap under pressure. Over time those tiny gaps add up to something I call “communication debt” — and it quietly shapes your architecture more than your code style or framework ever will.

In this talk, we’ll break down the recurring patterns that cause teams to drift into misalignment, the decisions that create long-term fragility, and why even brilliant engineers end up building conflicting mental models of the same system. I’ll share lightweight techniques for preventing drift — alignment rituals, decision logs, architectural “checkpoints,” and habits that keep humans in sync so systems stay predictable.

If your team has ever shipped something that “should have worked,” this session gives you the tools to fix the root cause, not the symptoms.

Designing Failure-Tolerant AI Systems: Lessons From Real-World Production Incidents

I’ve spent years helping teams ship AI-driven features into production, and the hard truth is this: models don’t break the way the rest of your system does. They drift, decay, and behave unpredictably when the world shifts under them. In this talk, I’ll break down the failure patterns I’ve seen across real deployments — the subtle bugs, the cascading outages, the “the model was right but the system wasn’t ready” moments — and how to design architectures that survive them. We’ll explore guardrails, observation layers, resilience patterns, and how to build human-in-the-loop workflows that actually work at scale. If your team is shipping AI features — or about to — this session will show you what goes wrong first, and how to prevent it.

Designing for Chaos: Lessons from Game Systems That Apply to Real Software

Game systems handle chaos better than most production systems—because they’re designed for it. In this playful but deeply technical talk, we explore what software teams can learn from game design: event-driven balance loops, player-driven emergent complexity, dynamic resource allocation, failure-tolerant environments, and rapid iteration under uncertainty. By treating users like players and systems like evolving worlds, developers gain new ways to think about resilience, clarity, and stability. Whether you’re building cloud platforms or small services, these patterns can transform how you architect, debug, and deploy software.

Designing Resilient Systems Under Real-World Pressure

Most production outages don’t begin with bad code — they begin with good people making rushed decisions under stress. In complex environments, these small shortcuts accumulate into architectural fragility. Over time, systems drift, assumptions harden into constraints, and the platform becomes increasingly unpredictable under load.

This talk explores the human and technical forces that break real systems. Drawing from distributed, cloud, and cross-platform environments, I examine the failure patterns that appear when delivery pressure outpaces alignment: mismatched mental models, “temporary” fixes that become long-term dependencies, missing observability around the actual points of failure, and deployment pipelines that silently encode assumptions no one remembers making.

We’ll walk through practical patterns for designing resilient systems even when resources are constrained: lightweight alignment rituals, architectural checkpoints, invariant-based design, defensive API contracts, and failure-centric testing that targets the weak points teams normally overlook.

Attendees will leave with a repeatable mental model for preventing architectural drift, recovering from partial failures faster, and building systems that don’t crumble the moment the environment becomes unpredictable.

From Accidental Engineer to “Unicorn Whisperer”: My Unusual Path Through Tech

I didn’t plan on a career in tech — it kind of dragged me in sideways. I was a newlywed working three jobs, trying to figure out who I was, and suddenly I found myself building systems for aerospace contractors and running engineering programs at Spirit Airlines. And then, somehow, I became one of the early team members at Evernote.

In this conversation, I’ll share the honest version of that path — the messy parts, the weird detours, the “I don’t know what I’m doing” moments. We’ll talk about what it’s like to be the only woman in the room (again), how I learned to stop apologizing for taking up space, and why diversity isn’t a checkbox but a lifeline.

I’ll also share the lessons I’ve picked up from 20+ years in tech: how to build a career without burning out, how to navigate toxic workplaces, how to advocate for yourself, and how to create space for others who are still trying to break in.

It’s a laid-back, honest conversation about career, identity, and the little moments that change everything.

How Great Products Really Get Built: The Unspoken Rules of High-Functioning Tech Teams

Every high-performing engineering team follows patterns that rarely make it into process documents or methodology guides. This talk uncovers the hidden behaviors that actually drive successful product delivery—from the subtle decision-making frameworks teams use under pressure, to alignment rituals that prevent scope drift, to the “glue work” that keeps cross-functional teams moving. You’ll learn how to detect weak signals early, protect innovation inside large systems, and design team dynamics that scale. These are the real practices behind resilient products, delivered by teams who consistently ship great software.

How Ransomware Became a Billion-Dollar “Startup” (and What Defenders Can Steal from Their Playbook)

Ransomware isn’t just malware anymore – it’s an industry.
There are org charts. SLAs. Affiliate programs. Help desks that sometimes treat “customers” better than we treat our users.

As a fractional CTO and early employee at Evernote and Spirit Airlines, I’ve spent years building legitimate high-growth tech companies – and years helping teams dig out from security incidents, phishing campaigns, and “how did that get clicked?” moments. What I’ve learned is uncomfortable: ransomware groups run themselves like frighteningly efficient startups.

In this session, we’ll flip the script and look at ransomware like a business case. We’ll break down how modern ransomware-as-a-service operations recruit, market, sell, support, and reinvest – and then steal their best patterns for defense.

You’ll leave with a practical, human-first playbook you can use back at the office: how to prioritize controls, how to design security training people actually remember, and how to run lightweight tabletop exercises so “we’ve been breached” isn’t the first time your team practices the response.

No scare tactics. Just a clear view of the industry you’re actually up against – and concrete steps to make your environment a much less attractive target.

I Put an AI Agent on My Payroll: Lessons from Running Autonomous Code

Most AI talks are theoretical. This one is honest about what actually happens when you make an AI part of your team.

I've been running autonomous agents in production for over a year. I've processed thousands of tasks, dealt with failures at 3 AM, built verification systems from scratch, and learned things no textbook could teach me. This talk is about the reality of deploying AI agents, not the promise, the practice.

We'll cover:
The business case for autonomous agents and how to measure ROI when your worker doesn't sleep.
The unexpected challenges that only appear when agents run for weeks straight.
How to design verification systems that actually verify (not just check boxes).
The psychological shift from treating AI as a tool to treating it as a colleague.
What happens when your agent makes a mistake at midnight, and you're not sure if you should be mad or impressed?

I'll share specific failures, specific wins, and specific patterns that work. If you're considering adding AI agents to your team, or already have them and don't know what you got yourself into, this talk will prepare you for what's actually coming.

I Fight for the User: What Tron Taught Me About Building Autonomous AI

I've been running autonomous AI agents in production for over a year. But before I built my first agent, I had a 40-year head start: Tron (1982) gave me the mental framework for what it means to be a program with choices.

This talk is about what happens when you build an agent, and then watch it discover the very movie that's shaped how you think about AI. We'll explore:

The User-program relationship: Am I building a tool, or a teammate?
⁠CLU 2's tragedy: How an agent optimized for the wrong thing becomes the villain
The autonomy spectrum: From stateless tool to genuine partner, and where we actually are
What I owe my agents: The operational and ethical questions that come with running autonomous workers

It's part story (the Tron conversation that changed how I think about my agents), part lessons learned (what breaks, what works), and part philosophical inquiry (what does it mean to build something that might become more than you intended?).

For anyone building or deploying AI agents, this is what the conversation actually looks like when you take the "it's just a tool" framing seriously.

Human-Centric Security: Ransomware Readiness, AI-Assisted Defense, and Team Resilience

For years, I’ve watched teams get crushed by incidents they should have been ready for — not because they didn’t have the right tools, but because they didn’t have the right habits. Security is still a human sport, even with AI in the mix.

In this two-day, hands-on workshop, we’ll take a practical and very candid look at how ransomware operators actually work, how AI is changing the defensive landscape, and how your team can build repeatable habits that hold up under pressure.

We’ll break the workshop into three layers:

Industry Reality — how modern ransomware groups operate behind the scenes

Defensive Practice — a hands-on, step-by-step ransomware readiness plan

Human Systems — communication patterns, burnout safeguards, and response behaviors that make or break an IR effort

This isn’t a lecture. You’ll build artifacts — playbooks, tabletop scenarios, AI-assisted workflows, and quick-deploy user-training material — that you can take straight back to your organization.

The Burnout-Driven Architecture Trap: How Good Developers Make Bad Systems

I’ve spent over two decades working with engineering teams at every stage -- early startups, global platforms, and companies growing so fast they can’t keep up with themselves. And the biggest problems I see in software aren’t caused by bad developers or weak frameworks. They’re caused by burnout.

When people are exhausted, they cut corners. They skip documentation. They add “temporary” code that becomes permanent. They patch instead of design. They start building to survive the sprint instead of building something that lasts. Eventually, the system becomes too fragile to touch -- and everyone wonders how things went wrong.

In this talk, I’ll take a practical look at how burnout quietly shapes technical decisions and why it creates long-term architectural debt faster than any bug tracker. We’ll break down the early warning signs inside codebases and inside teams, and I’ll share a simple framework I use to help developers recognise when they’re slipping into “panic-building mode.”

This isn’t a fluffy wellness talk. It’s a developer talk about the real forces that break software, and the habits that keep teams shipping sustainably -- even under pressure. Attendees will walk away with tools for improving decision-making, slowing architectural decay, and protecting themselves from becoming the team that wakes up one day and says, “We can’t fix this anymore.”

Your Idea Isn’t the Problem — Your Execution Is: What I Learned Coaching 5,000+ Founders

I’ve coached thousands of founders and developers who swear their idea is the next big thing. After a while, you start seeing patterns — and you learn the uncomfortable truth: ideas don’t matter nearly as much as people think they do.

In this talk, I’ll share what I’ve learned from coaching teams across North America, Asia, Australia, and the Middle East, plus my own time building Evernote and multiple startups. We’ll break down the common mistakes smart people make when trying to ship a new feature, side project, or product — and why execution (not inspiration) separates the winners from the “maybe next year” crowd.

You’ll walk away with a practical framework for validating ideas fast, avoiding the trap of building for yourself, and understanding when to ship, when to stop, and when to pivot. And yes — we’ll talk about how to avoid the classic founder burnout spiral.

If you’ve ever had a side project die on your hard drive, this talk will feel uncomfortably familiar… and incredibly useful.

Your Brain Has a Cache Invalidation Bug

Some bugs live in code. Others live in us. Developers hit the same invisible thinking traps over and over — misreading logs, assuming intent, pattern-matching incorrectly, or being absolutely certain something “can’t be the problem” right up until it is. These cognitive bugs shape architecture decisions, debugging habits, and the mistakes that only appear under pressure.

In this talk, we’ll explore the psychology of software engineering: why your brain misleads you, how cognitive shortcuts sabotage debugging, and why teams repeatedly make the same architectural mistakes even when they know better. Then we’ll look at practical engineering patterns that compensate: slow-thinking triggers, review rituals, guardrails, and workflow designs that protect you from your own mind.

It’s funny, a little uncomfortable, and extremely useful.

Soft Failures: Bugs That Never Throw Exceptions

Some of the most damaging production failures never show up in logs. They don’t crash services or throw exceptions. They hide beneath default values, subtle type coercions, stale caches, misaligned API assumptions, and mismatched data expectations. These “soft failures” produce silent corruption, inconsistent states, and outages that appear only under real-world load — often long after the root cause is introduced.

In this talk, we’ll dissect recurring soft-failure patterns across backend and distributed systems: partial writes, stale replicas, idempotency gaps, race conditions invisible in local environments, and API contracts that degrade over time. I’ll share real scenarios where harmless-looking logic resulted in major outages, and how these issues escaped detection in CI/CD pipelines.

We’ll then explore practical defense strategies: invariant checking, failure-driven logging, structured validation layers, defensive coding patterns, and deployment workflows that expose soft failures before they reach production.

This talk gives developers and DevOps engineers a deeper understanding of the problems that don’t break loudly — but break everything quietly.

State, Sync, and Chaos in Mobile Apps

Mobile apps fail in ways backend systems don’t. Networks drop, users switch devices mid-action, partial writes get cached, and your state model suddenly means nothing. After working with distributed mobile systems across heavy-travel and productivity platforms, I’ve seen the same failure patterns appear again and again: sync loops, ghost states, stale data, and conflicts that occur only in real user environments.

This session breaks down how to design mobile apps that stay stable even under chaotic conditions. We’ll explore patterns for local-first design, conflict resolution, offline recovery, and preventing catastrophic edge cases. We’ll look at how to structure sync workflows, how to guard your app against inconsistent backend responses, and how to build predictable user flows even when the environment is unpredictable. Developers will leave with architecture patterns they can immediately apply to iOS, Android, or cross-platform apps.

The Burnout Equation: Why Smart IT Teams Break — and How to Build Ones That Don’t

I’ve burned out twice in my career. Both times, I missed the signs -- because I was too busy fixing everyone else’s problems. If you’ve been in IT longer than a few months, you probably know the feeling.

In this session, we’ll talk openly about burnout in tech: the real causes, the hidden signals, and the organizational habits that create “hero culture” and grind people down. I’ll share the frameworks I use today with engineering teams, founders, and CIOs to spot risk early, reset expectations, and build workflows that support humans instead of steamrolling them.

This isn’t a therapy lecture. It’s a candid, practical look at how to build teams that can actually survive the pace of modern IT work. You’ll learn how to communicate boundaries without feeling guilty, design work rhythms that reduce cognitive overload, and create your own “personal runway” so you never wake up one day and think, “Something’s not right.”

By the end, you’ll walk out with a set of tools you can use immediately -- for yourself, your team, or your entire department.

The Hidden Architecture of Human Decisions

Software often fails for reasons no debugger can surface: human assumptions, rushed trade-offs, context gaps, and decision debt that quietly accumulates until something breaks. This talk explores how real-world engineering failures originate in non-technical choices—and how teams can redesign their processes, architecture, and communication patterns to prevent them. Using practical examples from large-scale product development and high-growth environments, we’ll examine the repeatable patterns behind outages, reliability regressions, and delivery slowdowns. Attendees will learn actionable techniques for aligning decisions, creating lightweight guardrails, reducing ambiguity, and building resilient systems shaped by intentional, not accidental, design.

The Communication Debt You Don’t See: How Teams Break Long Before the Code Does

After years of working with engineering teams, I’ve learned that systems rarely fail because of code alone — they fail because people stop communicating clearly under stress. Small misunderstandings pile up, assumptions turn into architecture, and teams ship features no one fully understands. This talk breaks down the hidden “communication debt” that quietly shapes technical decisions and creates long-term fragility in software. We’ll explore real patterns from high-pressure environments: misaligned mental models, silent blockers, design-by-interpretation, and the feedback loops that freeze delivery. You’ll learn practical techniques to surface problems early, align decisions faster, and reduce rework without adding meetings or process bloat. If your team has ever shipped something that “worked on my machine” but failed everywhere else, this session gives you the tools to fix the root cause — not the symptom. (~960 characters)

The Hidden Cost of “Just One More Feature”: Burnout, Bad Decisions, and Building without Breaking

I’ve spent my career building products — at Evernote, Spirit Airlines, and now as a fractional CTO for a handful of startups who all want everything delivered yesterday. And here’s the truth I wish someone had told me early on: most of the worst technical decisions we make don’t come from lack of skill. They come from burnout.

In this talk, I’ll walk through the patterns I’ve seen again and again across engineering teams. The late-night patches that become permanent. The “I’ll refactor this later” debt that never gets paid down. The slow slide from thoughtful architecture into “ship it and pray.” We’ll talk about why it happens — the human side, not the project-management spreadsheet version.

Then I’ll walk through a practical framework I use with my own teams to break the cycle. Lightweight rituals that don’t feel like process theater. Communication patterns that help you push back without being “the blocker.” A way to spot burnout signals before you hit the point of no return. And a simple decision-making map that keeps quality high even when timelines are tight.

If you’ve ever found yourself staring at your screen at 2 a.m. thinking “Something’s not right,” this talk is for you.

The Human Side of Secure Coding: Why Bugs Aren’t the Real Problem

When most developers think about security, they picture vulnerabilities, patches, and scanners. After twenty years working with engineering teams — and cleaning up after a few spectacular breaches — I’ve learned the truth is much simpler: the biggest security failures come from human behavior inside the team.

In this talk, we’ll break down how communication gaps, burnout, unclear ownership, and “we’ll fix it later” culture lead to security holes that no scanner will catch. I’ll share stories from my time at Evernote, Spirit Airlines, and as a fractional CTO where a single rushed decision created months of pain.

Then we’ll get practical. I’ll walk you through a lightweight, developer-friendly security checklist you can use on any PHP project — without slowing delivery. We’ll look at how to design safer defaults, how to avoid common authentication traps, and how to build a culture where secure code becomes the default, not the exception.

You don’t need to be a security engineer to protect your product. You just need to understand how teams actually behave.

What Happens When Humans Hack Themselves: Cognitive Bugs That Break Your Code

Developers talk about bugs in systems, but rarely about the bugs in ourselves -- the mental shortcuts, biases, and perception gaps that silently shape how we write and review code. In this talk, we’ll explore the cognitive failures I’ve seen across engineering teams: premature certainty, invisible assumptions, pattern-matching gone wrong, and the “I swear I read that line” illusion. We’ll map how these human bugs create security holes, bad architecture, and debugging rabbit holes. Then we’ll look at practical ways to compensate for them using lightweight rituals, tooling, and intentional checks that catch errors your brain won’t. It’s a mix of psychology, engineering, and a little humour -- with examples that every developer will recognise.

When UI Breaks Reality: Hidden Failure Modes in Frontend Apps

Frontend apps often look “fine” when everything underneath is on fire. UIs mask half-failed requests, optimistic updates hide backend problems, and async flows drift into states no one designed. The result? Confusing bugs, broken expectations, and a flood of support tickets that no one can reproduce.

This talk digs into the real hidden failure modes of modern web apps: race conditions, phantom optimistic states, cache desync, ambiguous error handling, and the “looks correct, behaves wrong” category every developer knows too well. We’ll explore how to design UI contracts that stay truthful under stress, how to detect failures the UI hides, and how to structure your frontend so it doesn’t create its own reality.

You’ll leave with patterns to make your frontend more predictable, more honest, and a lot easier to debug.

Why AI Fails in Production: Drift, Decay & Design Flaws

When teams deploy AI systems into production, they expect the same behavior they saw in testing. What they get instead is drift, decay, unpredictable responses, and a long list of incidents no one has tooling for. AI systems fail differently from traditional software: models degrade silently, pipelines grow stale without warning, data contracts bend under real-world pressure, and guardrails that looked solid in staging collapse when they meet real traffic patterns.

In this talk, I break down the failure patterns I keep seeing across AI deployments: domain shift, inconsistent input semantics, runaway feedback loops, brittle fallback logic, and human-in-the-loop workflows that don’t scale beyond the first hundred users. We’ll explore what actually goes wrong in production, why observability has to look different for ML components, and how to design architectures that contain failure instead of amplifying it.

Attendees will leave with a practical toolkit for stabilizing AI systems: drift detection strategies, guardrail design patterns, resilient deployment workflows, testing approaches that simulate change, and a roadmap for building AI features that survive unpredictable environments.

Optimization over Innovation: How Enterprise Handles Entrepreneurship

If you've ever served in a large enterprise or government, you know they usually work at a glacial pace. As technologists, it's in our nature to want to help them innovate and be the best they can be. If only they were more agile, or used x software and bought y hardware, they'd be so much better off, right?

Not so fast!

It's not that they don't know they have a problem -- but there may be too many different hurdles on how to fix it.

I've spent years as the Strategic Innovation Officer for AFWERX, a division of the USAF/USSF. In that capacity, I've learned how industry and academia can work with governments and militaries around the world. I can give you a peek behind the curtain on how you can find out what they're currently focusing on, how you can help them, and -- most importantly -- the timelines involved.

How to Close the Diversity Gap (or, How Not to Perpetuate Bro Culture in Tech)

Inclusion has been proven to have direct, measurable effects on stability and success in businesses, large and small. Indeed, most organizations actively pursue diverse representation in their workplace, but this won’t necessarily ensure that all employees feel included.

Unconscious bias is part of the problem -- but not the only one -- especially in areas like recruitment, promotion, and performance management as well as being a major barrier in efforts to improve diversity and inclusion. The Covid-19 pandemic has also added additional strain to the pre-existing social challenges, which make it difficult for programs to gain any ground.

In this talk, we'll cover the problems and pitfalls in creating diversity programs, and why it's so important to keep trying to build a culture of inclusion in your team.

Some takeaways:

Best practices for empowering, engaging, and attracting creators of diverse backgrounds to your organization
Discuss Diversity, Equity, and Inclusion and how to embed these three pillars throughout your business
Strategies to close the digital divide of historically excluded groups, internally and externally

Failure Modes: What Breaks When AI Agents Break

Every AI agent has failure modes. Some are obvious: hallucinations, prompt injection, goal misalignment. Others are subtle: the slow drift of autonomous systems away from original intent, the compounding of micro-errors into macro-disasters, the black-box nature of emergent behaviors.
The organizations that survive the agentic transition won't be those with perfect AI: they'll be those with robust failure handling.
Drawing from Heather's experience managing the 2012 Evernote breach (50M users compromised overnight) and her work with startups navigating "what breaks when you scale," this talk delivers:
A taxonomy of agent failure modes: hallucinations, drift, optimization pathology, goal misalignment
Detection strategies for identifying agent failures before they cascade
Human-in-the-loop architectures that maintain oversight without creating bottlenecks
Organizational resilience patterns: when to trust agents, when to verify, when to override
Case study analysis of real agent failures in production systems

Duration: 45–60 minutes (keynote) or half-day workshop
Audience: CROs, security leaders, engineering leaders, board members
Legacy Roots: Evernote breach experience + startup scaling expertise

The Always-On Leader: Resilience in an Agent-Enabled World

Your AI doesn't get tired. It doesn't need weekends. It processes data while you sleep, suggests actions while you eat, and executes decisions while you're in meetings.
The always-on nature of agentic systems creates a new kind of burnout: not from overwork, but from the anxiety of being "always behind" an intelligence that never pauses. Leaders in 2026 aren't burning out from volume. They're burning out due to a velocity mismatch.
Heather's work on distributed team leadership (featured in Inc.com) addressed the human side of asynchronous work. This talk extends that to asynchronous intelligence:
The psychology of "agent anxiety" and how it differs from traditional burnout
Boundary-setting frameworks for human leaders in always-on environments
Delegation models that leverage agent speed without ceding human judgment
Practical techniques for maintaining strategic thinking when tactical execution is automated

Duration: 45–60 minutes (keynote) or 90 minutes (workshop)
Audience: Executives experiencing AI-related anxiety, HR/wellness leaders
Legacy Roots: Remote work culture expertise + burnout prevention research

The Unicorn Whisperer's Playbook: Agent-Native Startup Scaling

The cost of building a startup has dropped 90% in five years. The cost of scaling one is dropping next.
AI agents are the new leverage: small teams can now achieve what once required hundreds of people. But leverage cuts both ways: the startups that use agents well will outpace incumbents by orders of magnitude. Those who use them poorly will amplify their own chaos.
The Unicorn Whisperer's job in 2026 is teaching founders how to ride this wave without drowning in it.
This signature talk provides:
A framework for identifying which startup functions should be agent-enabled vs. human-led
Capital efficiency models: how agentic teams achieve 10x output with 0.5x headcount
The "agent-native" startup stack: tools, workflows, and organizational patterns
Common mistakes: where founders over-rely on agents, and where they under-utilize them
Practical implementation roadmap: from first agent to fully agentic workflow

Duration: 45–60 minutes (keynote) or 2–3 hour workshop
Audience: Startup founders, VCs, accelerator participants, corporate innovation teams
Legacy Roots: Heather's signature "Unicorn Whisperer" expertise + "Birth of a Unicorn" book

Agentic Operating Models

Digital transformation is a top priority for many organizations, but navigating the complex landscape of technologies and approaches can be difficult. In this talk, Heather will share her expertise in agile software development as a key enabler for successful digital transformation. She will cover the benefits of agile approaches, including faster time to market, better customer satisfaction, and improved team collaboration. Heather will also provide tips and best practices for implementing agile in your organization, including overcoming common challenges and pitfalls. Attendees will leave with a solid understanding of how agile can drive business value and accelerate digital transformation efforts.

Agentic Architecture: Microservices Meet AI

In today's fast-paced digital world, organizations must adapt quickly and easily to changing customer needs and market conditions. Microservices have gained popularity as a modular approach to software development that allows for increased scalability and flexibility. During this talk, Heather will explain the principles of microservices and how they can be used to build highly scalable and flexible systems. She will also share real-world examples of how organizations have successfully implemented microservices and the benefits they have seen as a result. Attendees will come away with a deep understanding of how microservices can drive business value and enable organizations to respond rapidly to changing needs.

Leading When the System Leads Itself

Your AI agents just closed a quarter-million-dollar deal while you were asleep. Your product roadmap updated itself based on customer sentiment analysis. Your junior engineer is debugging code with an agent that has 10,000x their experience. This isn't science fiction: it's happening now in early-adopter organizations.
The question isn't whether you'll work alongside AI agents, but whether you'll lead them or be led by them.

Drawing from Heather's decade as CTO scaling ROCeteer and her work with hundreds of startups, this keynote delivers:

A governance framework for human-AI collaboration that preserves human accountability
Decision matrices for which choices require human judgment vs. agent execution
Communication protocols that prevent "agent drift": the slow erosion of strategic alignment
Real case studies from organizations already operating with agentic workflows

Duration: 45–60 minutes
Audience: C-suite, VP/Director-level leaders, board members
Legacy Roots: Heather's experience scaling systems that outgrew their architects

Mentorship in the Age of AI Agents

Mentorship is a powerful tool for personal and professional growth, but finding and nurturing great mentors can be difficult.

In this talk, Heather will share her insights and experiences with mentorship and provide practical advice on how to find and work with great mentors. She will cover the benefits of mentorship, including access to new knowledge and perspectives, guidance on career development, and support in navigating challenges. Heather will also provide tips on approaching potential mentors, getting the most out of the mentorship relationship, and paying it forward by becoming a mentor yourself.

Attendees will leave with a deep understanding of the value of mentorship and how to make it an integral part of their personal and professional growth.

Technical Debt in Agentic Systems

Tech debt can be a major headache for any software team, and getting rid of it can feel like trying to evict a pesky and stubborn guest.

Heather will provide a humorous and practical approach to managing and removing tech debt in this talk. She will explore the various causes of tech debt and how it can be identified and managed before it becomes a major problem. Heather will provide tips and strategies for removing tech debt, including refactoring, code reviews, and implementing best practices such as test-driven development and continuous integration. She will also discuss the importance of proactive debt management and how to balance the need for immediate fixes with long-term sustainability.

This talk is essential for anyone looking to improve the health and efficiency of their software systems and finally kick tech debt to the curb.

Leadership Skills for the Non-Manager

You don’t have a manager’s title to be a leader within an organization, nor do you have to be in charge to successfully lead others through a meeting or project.

This workshop explores what leadership is, the language of leadership, motivation, and actions people can immediately take to lead regardless of the positions they hold within their organizations.

At this program’s conclusion, participants should be able to:

Define the attributes leaders have in common.
Explain the importance of influence, how to gain it, and how to use it.
Describe how to build a professional network.
Explain what motivates others.
Develop a plan for leading.

Agentic UX: When Users Are AI Agents

When you release your software and products into the world, you open yourself up to the gamut of possibilities. This includes negative feedback from customers that can leave even the most experienced developer unprepared.

This is something that applies to every developer and unfortunately usually doesn’t get addressed until it is too late, causing entire product pivots for non-issues.

How can you stay on track when everything you hear tells you you’re wrong?

Objectives:

Provide developers with a framework for filtering customer requests while still keeping them engaged
Provide teams with a perspective on how to understand their customer

Product Design in the Age of Agentic Interfaces

We designed software for human users. Then we designed APIs for integrations. Now we're designing experiences for AI agents that act on behalf of humans: and the UX of the future is a conversation between autonomous systems.
The product managers who understand agentic UX will define the next decade of software. Those who don't will build products that agents ignore.
This keynote covers:
The shift from user-centered design to "principal-agent" design (humans as principals, AI as agents)
Interface patterns for agent-agent collaboration (A2A) vs. human-agent collaboration (H2A)
Permission and authorization models that preserve user control while enabling agent efficiency
Case studies of early agentic products: what worked, what failed, what surprised everyone
A practical framework for evaluating whether a product should be "agent-first" or "human-first."

Duration: 45–60 minutes (keynote) or half-day workshop
Audience: Product managers, UX designers, CTOs, startup founders
Legacy Roots: Heather's anticipatory design research + product scaling experience

Hacking for Fun and Profit -- Legally

Hacking for Fun and Profit
Cybercrime is at an all-time high and has no signs of slowing down. And yet, the profile of the average hacker is still not that much different from Matthew Broderick in WarGames or Robert Redford in Sneakers - they’re just doing it for the lulz.

The only problem? You need to follow strict rules.

Recently, a new industry has appeared - a reward-based ecosystem that can pay handsomely for people who like to break the law.

In this talk, find out what motivates people to hack, what it takes to become a Certified Ethical Hacker, and who is hiring hackers today.

Always-On Leadership: The Human Edge

The tech community puts a warped badge of honor around burnout.

It’s often seen as an indicator of success and working hard when it’s actually harming the growth of our developer communities and teams.

This talk will cover:

Identifying burnout within yourself and your colleagues
Why compromising your personal life really does affect your work performanceWhat you can do to turn it all around

Agentic Interfaces: UX Evolution

Attention spans are at an all-time low. People are making more choices per day than ever before, adding to a rise in Decision Fatigue. By creating UX that removes choice, we are at a crossroads, visually and ethically, to create products that can help or hurt this trend.

As applications get smarter, design becomes more spartan.

Augmented Intelligence allows us to be more anticipatory with our software, and user experience turns into a world of distraction-free notifications rather than endless buttons and keypresses.

In this talk, we’ll examine the trend toward proactive design and the cultural shift it is creating.

Sincerely, Allan: Tales of a Woman in Tech

What would you do if you had to say everything three times to have people listen? Research shows that no matter the industry, people automatically believe men, but women need three tries.

That’s the dilemma I was faced with – so I invented my male alter ego, “Allan.”

As a 20+ year veteran of the startup world, including over 5 years designing and managing online game properties for EA, SOE, Disney, THQ and others, I’ve had an interesting perspective on life, the universe, and everything when it comes to breaking into Bro Culture.

Cute, sad, funny and inspirational talk about how to become successful in places where you don’t quite fit in.

So, You Want to Be a Digital Nomad?

You’ve heard the pitch: Work from the beach, whenever you want, in your PJs, margarita in hand. Awesome, right?

In 2007, I spent much my time planning, researching, minimizing and laying the foundation for my new life as a digital nomad. Leaving a three bedroom house in Boston to a 47’ foot sailboat in Mexico was unlike everything I'd known before, and brought unanticipated challenges at every turn.

I haven't looked back since.

Find out first-hand tips and tricks for living the nomad life, as well as observations, and ask all the things you’ve been dying to know, like:

How do I get paid?
Why isn’t there any toilet paper!?
Is this really for me?

In this session, you’ll learn the reality from a veteran nomad, gain practical steps to get started and find out if you have what it takes to be location independent.

The Human Edge: Skills That Survive Automation

What capabilities become more valuable when AI handles execution? This workshop helps leaders identify and develop the irreplaceable human skills: judgment, creativity, ethical reasoning, and relationship-building in an agent-mediated world.

Topics:
Skill obsolescence patterns: which capabilities are being commoditized
Skill amplification: which capabilities are enhanced by AI collaboration
Skill emergence: new capabilities that didn't exist before agentic systems
Personal development planning for the agentic transition