Robert Harris

What happens when a self-taught programmer with a background in anthropology ends up leading engineering teams?

Robert Harris traces his path from BASIC on a Commodore 64, through a decade in archaeology and the social sciences, to running software teams - and the lessons that came with becoming a manager by accident and a leader on purpose. The hardest problems he ran into weren't technical. They were human. So he went back to his training as an anthropologist to solve them.

This 90-minute session borrows the engineer's own mental model to do it. Culture decomposes into beliefs, behaviors, and artifacts - the abstract classes - and you only observe them through their implementations: the language a team speaks, the rituals and ceremonies it repeats, the experiences that bond it, and the artifacts and art it leaves behind. Robert walks through real examples from teams he has led, including a pull request dumpster-fire beacon, rubber duck onboarding kits, and the rake every new hire steps on once.

It also makes the case that culture was never built by the building. Open source tribes and the gaming guilds of twenty years ago mastered distributed collaboration long before anyone called it remote work, and their playbook still holds for co-located, hybrid, and fully remote teams alike.

Two warnings close the loop: why copying another company's culture produces a cargo cult, and why a culture behaves like a spoked wheel, where you tune the whole system one adjustment at a time.

Attendees will leave with:

• A working taxonomy for reading and shaping the culture they already have
• Concrete rituals, language, and artifacts to adapt to their own teams, wherever those teams sit
• A systems view of culture that explains why the obvious fix usually isn't

Whether you're a reluctant manager, a seasoned leader, or someone who has stepped on a rake in production, you'll leave with the tools to turn dysfunction into culture, and culture into a team that holds together when you're not in the room.

You were promoted for being good at writing code. Then you were handed responsibility for a team of humans, with no training and no manual.

Meetings. Conflict. Silence. Motivation. Trust.

The instincts that made you a strong engineer don't transfer directly to people. Computers do what you tell them. People adapt to the environment you create - including the parts you never meant to.

Here's the good news: you don't need a new personality or a new skill set to lead well. The skills you've built as an engineer - diagnosis, systems thinking, debugging under pressure, designing for resilience - are the same ones that produce strong leaders. What's usually missing is the translation layer that lets you point them at a human system instead of a technical one.

This session builds that translation layer. We'll look at leadership not as personality traits or management hacks, but as a human system - a loop of inputs, outputs, and state that you already shape from the inside. We'll walk that loop in three parts: learning to see the system, understanding the inputs that quietly train it, and reading the signals it sends back to you.

You will learn:

• Why the skills that earned you the promotion can work against you as a leader - and which engineering instincts carry straight over
• Why your presence changes a room before you say a word
• How everyday reactions subtly train a team to wait, escalate, or go silent
• Why your most helpful instincts - protecting people, having the answers, moving fast - can create the dysfunctions you're trying to prevent
• How to read silence, conflict avoidance, and withdrawal as data instead of personality flaws

This isn't a talk about tools, frameworks, or performance management templates. It's a story-driven look at the human system you're an inextricable part of - and most of the stories are my own mistakes, drawn from 25 years in engineering leadership and a background in anthropology and psychology.

You will leave with:

• A working model of your team as a system you shape, rather than a collection of individuals you manage
• A sharper read on group behavior - what silence, friction, and disengagement are actually telling you
• Two diagnostic questions you can use in your next meeting: “What did my presence just change?” and “What is this behavior protecting them from?”

If leadership suddenly feels harder than engineering ever did, that's not a personal failure. It's a systems mismatch - one you are well equipped to fix.

The toughest problems in engineering leadership have nothing to do with the technology, and everything to do with the humans building it. The technical skills that earn an engineer the promotion can be adapted to produce great leaders, but only with the right translation layer. Without it, leaders default to instincts that work on technical systems but fail on human ones.

This workshop installs that translation layer.

Over five modules delivered in a full-day workshop, participants learn to see the human system they're already inside, recognize what their daily inputs train into it, and read the signals it sends back. From there, they assemble a Leadership OS: the integrated stack that determines how a leader shows up under pressure, and the runtime practice that keeps the defaults from taking over. The day closes with applications - the OS running against real situations every engineering leader faces: difficult conversations, deadlocked teams, feedback gone wrong, terminations, and power gradients that turn against the team.

The content draws on twenty-five years of engineering leadership from a former anthropologist, gained across startups, consultancies, and global organizations, told through first-person stories of failure modes and recoveries. Frameworks come from psychology, anthropology, systems theory, and philosophy - translated into vocabulary engineers can use.

Participants leave with diagnostic questions, pre-loaded responses, and a working operating system for leading humans the way they already lead systems: with awareness, intention, and design.

In moments of uncertainty, teams don't listen more closely to their leaders. They watch them.

What they're watching is your operating system under load. The skills that earn an engineer a promotion reward a logic-first OS stack: analyze, decide, execute. That stack misfires the moment you lead people, because human hardware runs emotion before logic finishes loading. The tools you mastered for the machine don't work on the team, and most technical leaders inherit that bug the day they step into the role.

This session rebuilds the stack as a Leadership OS, an operating system for how you show up under pressure, assembled in layers and grounded in psychology, anthropology, and Stoic philosophy.

First we build and configure it: Emotional Observability as the I/O bus that reads both your team and yourself, Stoicism as the discipline that opens space between stimulus and response, and a set of core leadership principles as the configuration that decides what fills that space.

Then we run the leadership applications: the everyday and high-stakes situations all engineering leaders face, each drawn from a real moment across a 25-year career, usually the ones that went wrong the first time.

Attendees will learn:

• Why a logic-first OS fails as a leadership stack, and what belongs underneath it
• How to develop Emotional Observability as a practice instead of treating empathy as a fixed trait
• How trust behaves like a bank account, collecting deposits and overdraft fees during moments of pressure
• How to handle the five situations that test every leader - teaching, one-on-ones, feedback, team decisions, and power dynamics - without dropping into factory defaults

All of it serves one diagnostic question: would your team still follow you if you weren't their boss?

Attendees leave with a framework for becoming a leader who earns a yes, and one application to run the moment they get back to their desk.