In programming, duck typing means: don't check the type โ check the interface. If it has a .quack() method and a .swim() method, treat it as a duck. The label doesn't matter. The behaviour does.
Now apply that to people.
The CV Is a Type Declaration
A CV says: "I am a Senior Software Engineer." That's a type. A label. A symbol. It tells you what someone claims to be. It tells you nothing about what they can do.
Type-Checked Hiring
"Do you have a degree in Computer Science?"
"Do you have 5 years of experience in Java?"
"Are you certified in AWS?"
This is instanceof checking. You're asking what type they are. You're filtering by label. The degree, the years, the certificate โ these are type annotations. They describe what someone should be able to do. Not what they can do.
Duck-Typed Hiring
"Show me something you've built."
"Walk me through how you'd debug this."
"Here's a broken system โ fix it."
This is duck typing. You don't care what they are. You care what they can do. The person with no degree who ships production code is more "engineer" than the CS grad who can't deploy a service. Interface over inheritance.
Leadership Is Duck-Typed
Nobody becomes a leader by being appointed "leader." The title is a type declaration. Leadership is an interface:
Makes decisions when information is incomplete โ .decide(ambiguousContext)
Takes responsibility for outcomes they didn't directly cause โ .own(teamOutcome)
Creates clarity for others โ .clarify(chaos)
Shields the team from distraction โ .absorb(noise)
Grows other people โ .develop(person)
People follow them without being told to โ .attract(followership)
If someone implements this interface, they're a leader โ regardless of title, seniority, or org chart position. If someone has the title but doesn't implement the interface, they're a manager with a label. The org chart is a type system. The actual leadership graph is duck-typed.
Trust Is Duck-Typed
You don't trust someone because they say "trust me." You trust them because they implement the trust interface consistently:
Reliability โ they do what they said they'd do, repeatedly
Transparency โ they share bad news without being forced to
Competence โ they can actually do the thing
Benevolence โ they act in your interest, not just their own
Consistency โ the interface doesn't change based on who's watching
Trust is built by observed behaviour over time. It's the most aggressively duck-typed human system there is. No declaration creates it. No certificate proves it. Only consistent interface implementation builds it. And one broken method call can destroy it.
Expertise Is Duck-Typed
The question isn't "are you an expert?" The question is "can you do expert things?"
The Expert Interface
.diagnose(problem) โ identify what's actually wrong, not just the symptoms
.predict(outcome) โ know what will happen before it does
.simplify(complexity) โ explain it so others can act on it
.adapt(novelSituation) โ handle things not in the training set
.teachOthers() โ transfer the capability, not just the output
Type-Checked "Expertise"
10,000 hours logged
PhD in the field
Published papers
Conference speaker
"Senior" in the title
All type annotations. Some of the best engineers I've worked with had none of these. Some of the worst had all of them.
Culture Is Duck-Typed
Every company has values on a wall. Those are type declarations. The actual culture is whatever behaviour gets rewarded:
The wall says "innovation." People who try new things get punished for failure. The actual culture is risk-aversion.
The wall says "transparency." Bad news gets shot. The actual culture is information hiding.
The wall says "work-life balance." People who leave at 5 don't get promoted. The actual culture is presenteeism.
The wall says "collaboration." Rewards are individual. The actual culture is competition.
Culture is the interface the organisation actually implements, not the type it declares. Duck type a company by observing what gets promoted, what gets punished, and what gets ignored. That's the real API.
Relationships Are Duck-Typed
Labels say: partner, friend, colleague, mentor. But the actual relationship is whatever behaviours consistently occur:
Someone who calls themselves your friend but never shows up when things are hard โ NotImplementedError: support()
Someone who has no label but always answers the phone at 2am โ implements the friend interface
A "mentor" who only talks about themselves โ missing .listen() method
A stranger who gives you the feedback that changes your career โ implements .mentor() without the title
Where Human Duck Typing Breaks
Performative behaviour โ people who implement the interface when observed but not when it counts. The method exists but throws silently. This is social adversarial attack โ presenting the right interface to pass the duck test while the implementation is hollow.
Context-dependent interfaces โ someone implements .kind() at work but not at home. Which is the real interface? People aren't consistent objects. They're stateful, context-sensitive, and non-deterministic.
Growth and change โ a person who didn't implement .lead() last year might implement it now. Human interfaces evolve. Type checking is a snapshot; duck typing is ongoing observation. But most people snapshot โ first impressions are type checks that persist long after the interface has changed.
Structural disadvantage โ duck typing assumes equal opportunity to demonstrate the interface. If you never get a chance to .lead() because you're never given responsibility, the duck test says "not a leader." The type system (credentials, networks, background) gates who gets to demonstrate the interface. Pure duck typing is only fair when access to the test is fair.
Imposter syndrome โ implementing the full interface but convinced you're not the right type. You quack, you swim, you fly โ but you believe you're not really a duck. The duck test says you are. Your internal type checker says you aren't.
The Practical Filter
In any system โ hiring, promotion, trust, collaboration โ you have a choice:
Type Check
Fast. Scalable. Easy to automate.
"Has degree โ Has 5 years โ Has cert โ"
High false-negative rate (rejects capable people without labels).
Moderate false-positive rate (accepts people with labels but no capability).
Favours the credentialed. Disadvantages the self-taught, the career-changers, the non-traditional.
Duck Type
Slow. Requires observation. Hard to automate.
"Show me. Do it. Let me watch."
Low false-negative rate (you see capability directly).
Low false-positive rate (hard to fake under observation).
Favours the doers. Disadvantages the good-at-interviews, the credential-collectors.
The best systems use both. Type check for initial filtering (you need some signal at scale). Duck type for actual decisions. The tragedy is when organisations stop at the type check and never get to the duck test.
You are not your CV.
You are not your title.
You are not your credentials.
You are your interface โ the set of things you consistently do, under pressure, when it matters, over time.
Duck typing for humans: watch what they do. Ignore what they say they are. The interface is the identity.
Identity is a wavefunction. Labels are one measurement โ they collapse the person into a category. Behaviour is another โ it collapses them into a capability profile. Neither is complete. But if you had to choose one basis for your measurement, choose the one that observes what they actually do. Duck type the humans.