Relevance by Design: A Sustainable Learning System for Senior Devs

Senior developers don’t struggle with learning. They struggle with the endless list of things they could learn, and the quiet feeling that they are always behind.

This session is a practical system for staying relevant on purpose: define what “relevant” means for your role, triage what to learn now vs. later vs. never, and run a weekly cadence that fits in 1–2 hours without leaking into nights and weekends. We’ll replace vanity metrics with a few signals that reflect real progress, and we’ll turn what you learn into skill you can use.

You’ll leave with a framework you can run for a month, a quarter, or a year without turning your spare time into homework.

Catch It While It's Still a Sentence: How AI Reprices Requirements

Six months in, somebody finally asks what happens when a customer cancels an order that's already half shipped. It's a fair question at the worst possible time. Before anyone wrote code, one sentence would have closed that gap. Now it's a migration and three teams who thought they were done. That's the cost-of-change curve.

Nobody draws the other curve: what it costs to go looking for gaps in the first place. It's another review, another round of what-ifs, another expensive person asking what did we miss. Every team stops asking and starts building well before the questions run out. You don't run out of gaps. You run out of hours.

AI can change what looking costs. It won't do that on its own, and getting it to is most of the job.

So we'll walk the loop: how to run it, which gaps get expensive later, and when to stop. Edge cases reveal themselves eventually, usually after the code is written, or worse, after it's in production. Or you look for them first. The best time to catch an edge case is while it's still a sentence.

Complicit by Default: Ethics and AI-Generated Code

Your code is a political act. Every line you ship facilitates something in the world: security, safety, abuse, or harm. For decades, developers have been ethical stewards of their work, but we never documented it; we passed wisdom through stories, mentorship, and code reviews. Now, AI generates code faster than you can review it and development teams are smaller. The ethical responsibility hasn't changed, but its weight has intensified; you don't have to write the harm to cause it.

In this talk, we'll examine how the ethics you've always practiced need sharper teeth. We'll look at what harm really means, from individual users to entire demographics. And we'll talk about why documenting your values, patterns, and guardrails isn't bureaucracy, it's how you collaborate ethically with AI. Because you can't surrender to the volume; the code you didn't review is code that still gets shipped.

Elevator Pitch
AI generates code faster than you can review it, and the ethics you've always practiced just got heavier.

Takeaways
Apply the harm lens at every level — individual users, demographics, and society
Push back on AI like a pair programmer — with alternatives and refined prompts, not just objections
Document the wisdom that used to live in code reviews — values, patterns, and guardrails your AI collaborator can inherit
Walk away when refusing the work is the ethical answer — pushback isn't always enough

Increasing Productivity by Doing Nothing

It is easy to mistake “busy” for “productive.” We fill every gap—messages, meetings, side tasks, even our “breaks”—and then wonder why our focus, creativity, and decision-making keep getting worse.

This talk is about doing nothing on purpose. Not as a productivity hack, but as a practical way to restore your mind, body, relationships, and clarity. You’ll leave with a simple approach you can use immediately, plus a one-week experiment to reclaim slack in your day—because the deviation from the deadline will be far worse if you run out of gas.

Future Proof with ASP.NET Core API Versioning

In the ever-evolving life of a modern application, maintaining API flexibility is crucial for the success and longevity of your systems. Your application's requirements and interfaces will change over time, and must be able to support the future without breaking the past.

This session will cover ASP.NET Core API versioning using the Asp.Versioning package. Discover practices and strategies that help you to navigate a seamless change in paths and payloads, effectively introduce version updates, and communicate deprecation and sunset policies, all to ensure that your APIs remain robust, adaptable, and ready for the requirements tomorrow without breaking the consumers of today.

The Sharp Edges of “Simple” Dependency Injection

Dependency Injection looks simple: register services, request interfaces, move on. And then production happens

This talk is a tour of the sharp edges: lifetime mismatches, scope leaks, captive dependencies, accidental singletons, disposal surprises, and performance cliffs that only show up under load. More importantly, it’s about diagnosis. When “it works on my machine” is true and the object graph is huge, you need a way to prove what’s wrong.

You’ll leave with a practical checklist of failure patterns, guardrails that catch issues earlier, and a debugging playbook to pinpoint the registration or lifetime that made the graph go sideways, without the guessing and rewrites.

The Freedom Shift: A Developer's Path to Independent Consultant

Are you a software developer contemplating a transition to independence? This session is for you! Dive into the shift from a traditional developer role to an independent consultant. We'll cover essential freelancing skills, guide you in building a successful consultancy, and provide actionable steps with real-world advice. Join us on this journey to empower yourself with professional independence.

Design for Non-Designers (from a Non-Designer)

You don’t need to be an artist to create clean, user-friendly designs. If you’re a developer who struggles with the “aesthetic” side of your projects—or worse, if your designs end up looking like a coding error—this session is for you.

Learn how to apply the same logical mindset you use for programming to design. We’ll cover six core principles—Unity, Contrast, Proximity, Flow, Hierarchy, and Whitespace—that will help you create better, more functional designs. We’ll also dive deeper into typography and color, including tips on using color with accessibility in mind.

By the end of the session, you’ll have actionable strategies to improve your designs and stop using the “I’m not a designer” excuse. You don’t need to be an artist, just a developer with the right tools and mindset.

Previous Feedback:

“Best talk of the @codecampnyc day...fantastic stuff!”
 ~Barry May (http://bit.ly/2lPD06O)

“@jayharris just gave the best presentation I attended all day. Not to disparage any of the others. He just crushed it. #codecampnyc”
 ~Andrew J. Dittman (http://bit.ly/2joRKeh)

“Energy filled talk about design for #NonDesigners w/ @jayharris was excellent! Need to go make a few changes to my website.”
 ~Kandace Gordon (http://bit.ly/2kqkxAY)

Learning Objectives:

• An understanding of the fundamentals of design.
• An introduction to implementing type and color.
• An introduction to designing for accessibility.

Topics:

• Fundamentals of composition and design
• Examples of implementing fundamentals
• Fundamentals for implementing type
• Fundamentals for choosing and implementing color palettes
• Fundamentals for designing for accessibility and color blindness

Code Smarter with GitHub Copilot Chat

GitHub Copilot Chat is a game-changer for developers, helping you write code faster and smarter. I'll break down how to use Copilot Chat as a real coding assistant —one that boosts your productivity without doing the thinking for you. We’ll look at practical ways to integrate it into your workflow, whether you're generating code snippets, debugging, or exploring new libraries.

Learn how to write better prompts that get the results you need, and how to strike the right balance between leveraging Copilot’s power and maintaining code quality. With the right approach, Copilot Chat can help you write better code in less time, while keeping you in full control of your development process.

By the end, you’ll know how to use GitHub Copilot Chat to improve your development process and enhance your coding workflow —making it a true assistant in your everyday work.

Celebrate Your Expert: Overcoming Imposter Syndrome

If you were asked “In what areas are you an expert,” how would you answer? Would you answer at all? If your friends, colleagues, and peers were asked about your expertise, would the answer change? That word ‘expert’ gets in our way. Our self-modesty blocks self-assessment of our talents. It damages our self-worth. It leads to imposter syndrome. Break out of the cycle. Learn to acknowledge, accept, and own your talents. Let’s celebrate our expert.

Previously delivered as the keynote of Code Camp Vegas (Las Vegas, United States), Scenic City Summit (Chattanooga, United States), Music City Code (Nashville, United States), Denver Dev Day (Denver, United States), and Nebraska.Code (Lincoln, United States).

Chasing Squirrels: Keeping Up with New Technologies

New software languages, libraries, and platforms are released at an exhausting pace. Many—perhaps most—are just fruitless distractions that we will never grasp, like developer puppies chasing technology squirrels. How do you know which ones to pursue? How do you know which ones will be beneficial? The truth is it doesn't matter. And I'll tell you why.

Previously delivered as the keynote of Code PaLOUsa, (Louisville, United States) and Prairie Dev Con (Winnipeg, Canada).