How do nurses share best practices?

Here is a conversation I had with Claude (complete with typos) about how we might use practices from the nursing profession in software development...

What do nurses call their internal training they do to make sure all nurses are aware of current best practices? The name "in service" is what I keep thinking.

Yes, you're right — the standard term is in-service training (or just in-services). Nurses and other healthcare professionals use this to refer to short, focused training sessions conducted on-site, typically covering updated protocols, new equipment, compliance topics (like infection control or HIPAA), or refreshers on best practices.

Related terms you might also hear:

Continuing education (CE/CEU) — more formal, often required for license renewal
Competency training — skills validation, often annual (e.g., BLS recertification)
Staff development — broader umbrella term

But "in-service" is the everyday, colloquial term nurses themselves use most often.

I am trying to tie that to software development. One future project is to start to move developers from using Auzre DevOps for source code to GitHub. There are differences that will need to be communicated. My thought was to "require" each developer to attend an "in-service" session before they are granted access to GitHub. Things like how we name things in GitHub are going to be critical, so making sure people are "told" how things need to be done is important (along with documented standards and other things). For us, this is important, but it is not life and death. For nurses, I would expect that some of their training may actually be life or death. With that being the case, how do they make their approach work and be sure it worked? What similarities are there that we might apply some of the same principles to what we want to do?

Great question — nursing in-service training has been refined over decades precisely because the stakes are so high. Here are the key principles they use and how they map to your situation:

How nursing makes in-services stick

1. Competency validation, not just attendance Nurses don't just sit through a session — they demonstrate competency afterward. A "return demonstration" or skills check confirms they can actually do the thing, not just that they heard about it.

Your equivalent: Don't just present the GitHub naming conventions and branching strategy. Have each developer complete a hands-on exercise — create a repo, name a branch, open a PR using your standards — before they get production access. Attendance is not comprehension.

2. Closed-loop accountability Healthcare tracks who completed training and ties it to privileges. You literally cannot perform certain procedures until your training record is current. No exceptions, no "I'll catch up later."

Your equivalent: You're already thinking this way — no GitHub access until the in-service is complete. Stick to it. The moment you make exceptions, the standard collapses.

3. Standardized, written protocols Nursing doesn't rely on tribal knowledge. There are written policies that the in-service references. The training teaches the protocol; the protocol outlives the training.

Your equivalent: Your naming conventions, branching strategy, PR process, etc. should exist as a living document (a repo wiki, a CLAUDE.md, a contributing guide) that the in-service walks through. When someone forgets six months later, they have a reference — not just a memory of a meeting.

4. Small, focused sessions In-services are typically 30-60 minutes on one topic. They don't try to boil the ocean. Cognitive overload kills retention.

Your equivalent: Resist the urge to cover everything about GitHub in one session. Cover what they need on day one: naming, branching model, how to open a PR, where to find help. Advanced topics (Actions, code owners, branch protection) can come later.

5. Teach-back method Nurses are often asked to explain what they just learned back to the instructor. This is one of the most effective knowledge-verification techniques in healthcare education — if you can teach it, you understood it.

Your equivalent: During your session, have developers walk you through the process verbally or on screen. "Show me how you'd name this repo for the payments team's new microservice." Awkward silence tells you exactly where the gaps are.

6. Annual recurrence and updates In-services aren't one-and-done. Protocols change, people forget, new staff arrive. Healthcare re-certifies regularly.

Your equivalent: Plan a lightweight refresher when your GitHub standards evolve — new naming conventions, new branch protection rules, etc. Doesn't need to be formal, but "we updated the standards, here's what changed" keeps drift from creeping in.

The core transferable insight

The nursing model works because it separates three things most organizations conflate:

Nursing principle	Your migration
Inform — here's the new protocol	Present your GitHub standards
Verify — prove you can do it	Hands-on exercise before access
Sustain — written reference + periodic refresh	Living documentation + check-ins

Most dev teams only do the first one (a presentation or a wiki page) and wonder why nobody follows the standards. Nursing assumes that informing alone is insufficient — and they're right, even when the stakes are lower than life and death.

The fact that your stakes are lower actually makes this easier to implement — you don't need formal testing or regulatory compliance. You just need the discipline to say: "Complete the exercise, get access. Here's the doc for when you forget. We'll revisit when things change."